fix(pipelines): show the actual sandbox scope restriction

.github/workflows/test-migrations.yml

@@ -10,16 +10,12 @@ on:
       - 'src/langbot/pkg/persistence/**'
       - 'src/langbot/pkg/entity/persistence/**'
       - 'tests/integration/persistence/**'
-      - 'tests/unit_tests/api/service/test_monitoring_sessions.py'
-      - '.github/workflows/test-migrations.yml'
   pull_request:
     types: [opened, synchronize, reopened, ready_for_review]
     paths:
       - 'src/langbot/pkg/persistence/**'
       - 'src/langbot/pkg/entity/persistence/**'
       - 'tests/integration/persistence/**'
-      - 'tests/unit_tests/api/service/test_monitoring_sessions.py'
-      - '.github/workflows/test-migrations.yml'
 
 jobs:
   test-migrations-sqlite:
@@ -84,8 +80,6 @@ jobs:
         run: >-
           uv run pytest
           tests/integration/persistence/test_migrations_postgres.py
-          tests/integration/persistence/test_monitoring_postgres.py
-          tests/unit_tests/api/service/test_monitoring_sessions.py::test_postgres_upgrade_rls_and_concurrent_bot_counts
           tests/integration/persistence/test_pgvector_postgres.py
           tests/integration/persistence/test_release_migration_postgres.py
           tests/integration/persistence/test_plugin_identity_migration.py

pyproject.toml

@@ -70,7 +70,7 @@ dependencies = [
     "langchain-text-splitters>=1.1.2",
     "chromadb>=1.0.0,<2.0.0",
     "qdrant-client (>=1.15.1,<2.0.0)",
-    "langbot-plugin==0.5.8",
+    "langbot-plugin==0.5.7",
     "asyncpg>=0.30.0",
     "line-bot-sdk>=3.19.0",
     "matrix-nio>=0.25.2",

src/langbot/pkg/api/http/controller/groups/monitoring.py

@@ -5,7 +5,6 @@ import quart
 
 from ...authz import Permission
 from ...context import RequestContext
-from ...service.monitoring_traffic import get_traffic_series
 from .. import group
 
 
@@ -378,14 +377,6 @@ class MonitoringRouterGroup(group.RouterGroup):
 
             return self.success(
                 data={
-                    'traffic': await get_traffic_series(
-                        self.ap,
-                        request_context,
-                        bot_ids=bot_ids or None,
-                        pipeline_ids=pipeline_ids or None,
-                        start_time=start_time,
-                        end_time=end_time,
-                    ),
                     'overview': overview,
                     'messages': messages,
                     'llmCalls': llm_calls,
@@ -414,7 +405,6 @@ class MonitoringRouterGroup(group.RouterGroup):
                 session_id,
                 start_time=start_time,
                 end_time=end_time,
-                bot_id=quart.request.args.get('botId'),
             )
 
             # Always return success with the analysis data

src/langbot/pkg/api/http/service/monitoring.py

@@ -29,19 +29,6 @@ _DEFAULT_CLEANUP_BATCHES_PER_TABLE = 4
 _HARD_MAX_CLEANUP_BATCHES_PER_TABLE = 100
 
 
-def _normalize_user_id(value: str | int | None) -> str | None:
-    """Convert numeric platform IDs before binding a VARCHAR with asyncpg.
-
-    Opaque string IDs (including whitespace and leading zeros) and missing
-    IDs must remain unchanged. Do not silently stringify unsupported objects.
-    """
-    if value is None or isinstance(value, str):
-        return value
-    if isinstance(value, int) and not isinstance(value, bool):
-        return str(value)
-    raise TypeError('user_id must be a string, integer, or None')
-
-
 def _workspace_transaction(method):
     """Run an explicit service entrypoint in one Workspace transaction."""
 
@@ -294,21 +281,19 @@ class MonitoringService:
         for _batch_number in range(max_batches):
 
             async def delete_batch() -> tuple[int, int]:
-                key_columns = list(model_cls.__table__.primary_key.columns)
                 select_result = await self.ap.persistence_mgr.execute_async(
-                    sqlalchemy.select(*key_columns)
+                    sqlalchemy.select(pk_column)
                     .where(model_cls.workspace_uuid == workspace_uuid, ts_column < cutoff)
                     .limit(batch_size)
                 )
-                pk_values = [tuple(row) for row in select_result.all()]
+                pk_values = list(select_result.scalars().all())
                 if not pk_values:
                     return 0, 0
 
                 delete_result = await self.ap.persistence_mgr.execute_async(
                     sqlalchemy.delete(model_cls).where(
                         model_cls.workspace_uuid == workspace_uuid,
-                        sqlalchemy.tuple_(*key_columns).in_(pk_values),
-                        ts_column < cutoff,
+                        pk_column.in_(pk_values),
                     )
                 )
                 return len(pk_values), int(delete_result.rowcount or 0)
@@ -430,7 +415,7 @@ class MonitoringService:
         status: str = 'success',
         level: str = 'info',
         platform: str | None = None,
-        user_id: str | int | None = None,
+        user_id: str | None = None,
         user_name: str | None = None,
         runner_name: str | None = None,
         variables: str | None = None,
@@ -452,7 +437,7 @@ class MonitoringService:
             'status': status,
             'level': level,
             'platform': platform,
-            'user_id': _normalize_user_id(user_id),
+            'user_id': user_id,
             'user_name': user_name,
             'runner_name': runner_name,
             'variables': variables,
@@ -625,7 +610,7 @@ class MonitoringService:
         pipeline_id: str,
         pipeline_name: str,
         platform: str | None = None,
-        user_id: str | int | None = None,
+        user_id: str | None = None,
         user_name: str | None = None,
     ) -> None:
         """Record a new session"""
@@ -637,29 +622,17 @@ class MonitoringService:
             'bot_name': bot_name,
             'pipeline_id': pipeline_id,
             'pipeline_name': pipeline_name,
-            'message_count': 1,
+            'message_count': 0,
             'start_time': datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None),
             'last_activity': datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None),
             'is_active': True,
             'platform': platform,
-            'user_id': _normalize_user_id(user_id),
+            'user_id': user_id,
             'user_name': user_name,
         }
 
-        model = persistence_monitoring.MonitoringSession
-        dialect = self.ap.persistence_mgr.get_db_engine().dialect.name
-        insert = postgresql_dialect.insert if dialect == 'postgresql' else sqlite_dialect.insert
-        statement = insert(model).values(session_data)
         await self.ap.persistence_mgr.execute_async(
-            statement.on_conflict_do_update(
-                index_elements=['workspace_uuid', 'bot_id', 'session_id'],
-                set_={
-                    'message_count': model.message_count + 1,
-                    'last_activity': statement.excluded.last_activity,
-                    'pipeline_id': statement.excluded.pipeline_id,
-                    'pipeline_name': statement.excluded.pipeline_name,
-                },
-            )
+            sqlalchemy.insert(persistence_monitoring.MonitoringSession).values(session_data)
         )
 
     @_workspace_transaction
@@ -669,7 +642,6 @@ class MonitoringService:
         session_id: str,
         pipeline_id: str | None = None,
         pipeline_name: str | None = None,
-        bot_id: str | None = None,
     ) -> bool:
         """Update session last activity time and increment message count.
 
@@ -679,9 +651,6 @@ class MonitoringService:
             True if session was found and updated, False if session doesn't exist.
         """
         workspace_uuid = self._require_write_context(context)
-        bot_id = bot_id if bot_id is not None else context.bot_uuid
-        if not bot_id:
-            raise ValueError('Session activity requires a bot_id')
         update_values = {
             'last_activity': datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None),
             'message_count': persistence_monitoring.MonitoringSession.message_count + 1,
@@ -698,7 +667,6 @@ class MonitoringService:
             .where(
                 persistence_monitoring.MonitoringSession.workspace_uuid == workspace_uuid,
                 persistence_monitoring.MonitoringSession.session_id == session_id,
-                persistence_monitoring.MonitoringSession.bot_id == bot_id,
             )
             .values(update_values)
         )
@@ -801,13 +769,13 @@ class MonitoringService:
             message_conditions.append(persistence_monitoring.MonitoringMessage.timestamp >= start_time)
             llm_conditions.append(persistence_monitoring.MonitoringLLMCall.timestamp >= start_time)
             embedding_conditions.append(persistence_monitoring.MonitoringEmbeddingCall.timestamp >= start_time)
-            session_conditions.append(persistence_monitoring.MonitoringSession.last_activity >= start_time)
+            session_conditions.append(persistence_monitoring.MonitoringSession.start_time >= start_time)
 
         if end_time:
             message_conditions.append(persistence_monitoring.MonitoringMessage.timestamp <= end_time)
             llm_conditions.append(persistence_monitoring.MonitoringLLMCall.timestamp <= end_time)
             embedding_conditions.append(persistence_monitoring.MonitoringEmbeddingCall.timestamp <= end_time)
-            session_conditions.append(persistence_monitoring.MonitoringSession.last_activity <= end_time)
+            session_conditions.append(persistence_monitoring.MonitoringSession.start_time <= end_time)
 
         # Total messages
         message_query = sqlalchemy.select(sqlalchemy.func.count(persistence_monitoring.MonitoringMessage.id))
@@ -1304,9 +1272,9 @@ class MonitoringService:
         if pipeline_ids:
             conditions.append(persistence_monitoring.MonitoringSession.pipeline_id.in_(pipeline_ids))
         if start_time:
-            conditions.append(persistence_monitoring.MonitoringSession.last_activity >= start_time)
+            conditions.append(persistence_monitoring.MonitoringSession.start_time >= start_time)
         if end_time:
-            conditions.append(persistence_monitoring.MonitoringSession.last_activity <= end_time)
+            conditions.append(persistence_monitoring.MonitoringSession.start_time <= end_time)
         if user_query and user_query.strip():
             user_pattern = f'%{user_query.strip()}%'
             conditions.append(
@@ -1408,7 +1376,6 @@ class MonitoringService:
         session_id: str,
         start_time: datetime.datetime | None = None,
         end_time: datetime.datetime | None = None,
-        bot_id: str | None = None,
     ) -> dict:
         """Get bounded session details with full statistics computed in SQL."""
         workspace_uuid = require_workspace_uuid(context)
@@ -1418,13 +1385,8 @@ class MonitoringService:
             persistence_monitoring.MonitoringSession.workspace_uuid == workspace_uuid,
             persistence_monitoring.MonitoringSession.session_id == session_id,
         )
-        if bot_id is not None:
-            session_query = session_query.where(persistence_monitoring.MonitoringSession.bot_id == bot_id)
-        session_result = await self.ap.persistence_mgr.execute_async(session_query.limit(2))
-        session_rows = session_result.all()
-        if len(session_rows) > 1:
-            return {'session_id': session_id, 'found': False, 'ambiguous': True}
-        session_row = session_rows[0] if session_rows else None
+        session_result = await self.ap.persistence_mgr.execute_async(session_query)
+        session_row = session_result.first()
 
         if not session_row:
             return {
@@ -1433,7 +1395,6 @@ class MonitoringService:
             }
 
         session = session_row[0] if isinstance(session_row, tuple) else session_row
-        bot_id = session.bot_id
 
         message_stats_result = await self.ap.persistence_mgr.execute_async(
             sqlalchemy.select(
@@ -1461,7 +1422,6 @@ class MonitoringService:
             ).where(
                 persistence_monitoring.MonitoringMessage.workspace_uuid == workspace_uuid,
                 persistence_monitoring.MonitoringMessage.session_id == session_id,
-                persistence_monitoring.MonitoringMessage.bot_id == bot_id,
             )
         )
         message_stats = message_stats_result.one()
@@ -1500,7 +1460,6 @@ class MonitoringService:
             ).where(
                 persistence_monitoring.MonitoringLLMCall.workspace_uuid == workspace_uuid,
                 persistence_monitoring.MonitoringLLMCall.session_id == session_id,
-                persistence_monitoring.MonitoringLLMCall.bot_id == bot_id,
             )
         )
         llm_stats = llm_stats_result.one()
@@ -1527,14 +1486,12 @@ class MonitoringService:
             ).where(
                 persistence_monitoring.MonitoringToolCall.workspace_uuid == workspace_uuid,
                 persistence_monitoring.MonitoringToolCall.session_id == session_id,
-                persistence_monitoring.MonitoringToolCall.bot_id == bot_id,
             )
         )
         tool_stats = tool_stats_result.one()
         tool_conditions = [
             persistence_monitoring.MonitoringToolCall.workspace_uuid == workspace_uuid,
             persistence_monitoring.MonitoringToolCall.session_id == session_id,
-            persistence_monitoring.MonitoringToolCall.bot_id == bot_id,
         ]
         if start_time is not None:
             tool_conditions.append(persistence_monitoring.MonitoringToolCall.timestamp >= start_time)
@@ -1563,7 +1520,6 @@ class MonitoringService:
             .where(
                 persistence_monitoring.MonitoringError.workspace_uuid == workspace_uuid,
                 persistence_monitoring.MonitoringError.session_id == session_id,
-                persistence_monitoring.MonitoringError.bot_id == bot_id,
             )
             .order_by(persistence_monitoring.MonitoringError.timestamp.desc())
             .limit(detail_limit + 1)
@@ -2048,9 +2004,9 @@ class MonitoringService:
         if pipeline_ids:
             conditions.append(persistence_monitoring.MonitoringSession.pipeline_id.in_(pipeline_ids))
         if start_time:
-            conditions.append(persistence_monitoring.MonitoringSession.last_activity >= start_time)
+            conditions.append(persistence_monitoring.MonitoringSession.start_time >= start_time)
         if end_time:
-            conditions.append(persistence_monitoring.MonitoringSession.last_activity <= end_time)
+            conditions.append(persistence_monitoring.MonitoringSession.start_time <= end_time)
 
         query = sqlalchemy.select(persistence_monitoring.MonitoringSession).order_by(
             persistence_monitoring.MonitoringSession.last_activity.desc()
@@ -2084,7 +2040,6 @@ class MonitoringService:
 
     # ========== Feedback Methods ==========
 
-    @_workspace_transaction
     async def record_feedback(
         self,
         context: ExecutionContext,
@@ -2099,7 +2054,7 @@ class MonitoringService:
         session_id: str | None = None,
         message_id: str | None = None,
         stream_id: str | None = None,
-        user_id: str | int | None = None,
+        user_id: str | None = None,
         platform: str | None = None,
     ) -> str | None:
         """Record user feedback (like/dislike) from AI Bot conversation.
@@ -2155,7 +2110,7 @@ class MonitoringService:
             'session_id': session_id,
             'message_id': message_id,
             'stream_id': stream_id,
-            'user_id': _normalize_user_id(user_id),
+            'user_id': user_id,
             'platform': platform,
         }
         dialect_name = self.ap.persistence_mgr.get_db_engine().dialect.name

src/langbot/pkg/api/http/service/monitoring_traffic.py

@@ -1,83 +0,0 @@
-"""Bounded traffic aggregation, independent of record-list pagination."""
-
-from __future__ import annotations
-
-import datetime
-import typing
-
-import sqlalchemy
-
-from ....entity.persistence.monitoring import MonitoringLLMCall, MonitoringMessage
-from .tenant import TenantContext, require_workspace_uuid
-
-if typing.TYPE_CHECKING:
-    from ....core.app import Application
-
-MAX_TRAFFIC_POINTS = 1000
-
-
-async def get_traffic_series(
-    ap: Application,
-    context: TenantContext,
-    *,
-    bot_ids: list[str] | None = None,
-    pipeline_ids: list[str] | None = None,
-    start_time: datetime.datetime | None = None,
-    end_time: datetime.datetime | None = None,
-) -> dict:
-    """Count all matching records in UTC buckets, returning at most 1000 points."""
-    workspace_uuid = require_workspace_uuid(context)
-    bucket = 'hour' if start_time and end_time and end_time - start_time <= datetime.timedelta(days=7) else 'day'
-    step = datetime.timedelta(hours=1) if bucket == 'hour' else datetime.timedelta(days=1)
-    postgres = ap.persistence_mgr.get_db_engine().dialect.name == 'postgresql'
-    points: dict[datetime.datetime, dict[str, int]] = {}
-    truncated = False
-    for model, field in ((MonitoringMessage, 'messages'), (MonitoringLLMCall, 'llm_calls')):
-        timestamp = model.timestamp
-        if postgres:
-            time_bucket = sqlalchemy.func.date_trunc(bucket, timestamp)
-        else:
-            pattern = '%Y-%m-%dT%H:00:00' if bucket == 'hour' else '%Y-%m-%dT00:00:00'
-            time_bucket = sqlalchemy.func.strftime(pattern, timestamp)
-        conditions = [model.workspace_uuid == workspace_uuid]
-        if bot_ids:
-            conditions.append(model.bot_id.in_(bot_ids))
-        if pipeline_ids:
-            conditions.append(model.pipeline_id.in_(pipeline_ids))
-        if start_time is not None:
-            conditions.append(timestamp >= start_time)
-        if end_time is not None:
-            conditions.append(timestamp <= end_time)
-        statement = (
-            sqlalchemy.select(time_bucket.label('bucket'), sqlalchemy.func.count(model.id).label('count'))
-            .where(*conditions)
-            .group_by(time_bucket)
-            .order_by(time_bucket)
-            .limit(MAX_TRAFFIC_POINTS + 1)
-        )
-        result = await ap.persistence_mgr.execute_async(statement)
-        rows = result.all()
-        truncated = truncated or len(rows) > MAX_TRAFFIC_POINTS
-        for timestamp_value, count in rows[:MAX_TRAFFIC_POINTS]:
-            key = (
-                datetime.datetime.fromisoformat(timestamp_value)
-                if isinstance(timestamp_value, str)
-                else timestamp_value
-            )
-            points.setdefault(key, {'messages': 0, 'llm_calls': 0})[field] = int(count)
-
-    def floor(value: datetime.datetime) -> datetime.datetime:
-        return value.replace(minute=0, second=0, microsecond=0, **({'hour': 0} if bucket == 'day' else {}))
-
-    first = floor(start_time) if start_time is not None else min(points, default=None)
-    last = floor(end_time) if end_time is not None else max(points, default=None)
-    series = []
-    if first is not None and last is not None:
-        cursor = first
-        while cursor <= last and len(series) < MAX_TRAFFIC_POINTS:
-            series.append(
-                {'timestamp': cursor.isoformat() + 'Z', **points.get(cursor, {'messages': 0, 'llm_calls': 0})}
-            )
-            cursor += step
-        truncated = truncated or cursor <= last
-    return {'bucket': bucket, 'points': series, 'truncated': truncated}

src/langbot/pkg/entity/persistence/monitoring.py

@@ -111,8 +111,8 @@ class MonitoringSession(Base):
         sqlalchemy.ForeignKey('workspaces.uuid', ondelete='CASCADE'),
         primary_key=True,
     )
-    bot_id = sqlalchemy.Column(sqlalchemy.String(255), primary_key=True, index=True)
     session_id = sqlalchemy.Column(sqlalchemy.String(255), primary_key=True)
+    bot_id = sqlalchemy.Column(sqlalchemy.String(255), nullable=False, index=True)
     bot_name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
     pipeline_id = sqlalchemy.Column(sqlalchemy.String(255), nullable=False, index=True)
     pipeline_name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)

src/langbot/pkg/persistence/alembic/versions/0023_bot_scoped_sessions.py

@@ -1,104 +0,0 @@
-"""Scope monitoring sessions by bot without changing runtime session IDs.
-
-Revision ID: 0023_bot_scoped_sessions
-Revises: 0022_codex_credentials
-"""
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql, sqlite
-
-revision = '0023_bot_scoped_sessions'
-down_revision = '0022_codex_credentials'
-branch_labels = None
-depends_on = None
-
-_TABLE = 'monitoring_sessions'
-_KEY = ['workspace_uuid', 'bot_id', 'session_id']
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-    inspector = sa.inspect(conn)
-    if _TABLE not in inspector.get_table_names():
-        return
-    pk = inspector.get_pk_constraint(_TABLE)
-    if pk['constrained_columns'] == _KEY:
-        return
-    # PostgreSQL alters in place, retaining indexes, grants, policies and RLS.
-    # SQLite batch reflection retains all existing indexes and foreign keys.
-    with op.batch_alter_table(_TABLE, naming_convention={'pk': 'pk_%(table_name)s'}) as batch:
-        batch.drop_constraint(pk['name'] or f'pk_{_TABLE}', type_='primary')
-        batch.create_primary_key(f'pk_{_TABLE}', _KEY)
-
-    metadata = sa.MetaData()
-    sessions = sa.Table(_TABLE, metadata, autoload_with=conn)
-    messages = sa.Table('monitoring_messages', metadata, autoload_with=conn)
-    m = messages.c
-    collisions = (
-        sa.select(m.workspace_uuid, m.session_id)
-        .group_by(m.workspace_uuid, m.session_id)
-        .having(sa.func.count(sa.distinct(m.bot_id)) > 1)
-        .subquery()
-    )
-    partition = [m.workspace_uuid, m.bot_id, m.session_id]
-    # Repair only demonstrable collisions. Retention may have removed earlier
-    # evidence; these summaries describe surviving messages, never invented text.
-    ranked = (
-        sa.select(
-            *[m[name] for name in _KEY],
-            m.bot_name,
-            m.pipeline_id,
-            m.pipeline_name,
-            m.platform,
-            m.user_id,
-            m.user_name,
-            sa.func.sum(sa.case((sa.or_(m.role == 'user', m.role.is_(None)), 1), else_=0))
-            .over(partition_by=partition)
-            .label('message_count'),
-            sa.func.min(m.timestamp).over(partition_by=partition).label('start_time'),
-            sa.func.max(m.timestamp).over(partition_by=partition).label('last_activity'),
-            sa.func.row_number().over(partition_by=partition, order_by=[m.timestamp.desc(), m.id.desc()]).label('rank'),
-        )
-        .join(
-            collisions,
-            sa.and_(m.workspace_uuid == collisions.c.workspace_uuid, m.session_id == collisions.c.session_id),
-        )
-        .subquery()
-    )
-    columns = _KEY + [
-        'bot_name',
-        'pipeline_id',
-        'pipeline_name',
-        'platform',
-        'user_id',
-        'user_name',
-        'message_count',
-        'start_time',
-        'last_activity',
-        'is_active',
-    ]
-    select = sa.select(*[ranked.c[name] for name in columns[:-1]], sa.literal(True)).where(ranked.c.rank == 1)
-    insert = postgresql.insert if conn.dialect.name == 'postgresql' else sqlite.insert
-    statement = insert(sessions).from_select(columns, select)
-    conn.execute(
-        statement.on_conflict_do_update(
-            index_elements=_KEY,
-            set_={name: statement.excluded[name] for name in columns if name not in _KEY and name != 'is_active'},
-        )
-    )
-
-
-def downgrade() -> None:
-    conn = op.get_bind()
-    if _TABLE not in sa.inspect(conn).get_table_names():
-        return
-    collisions = conn.execute(
-        sa.text('SELECT 1 FROM monitoring_sessions GROUP BY workspace_uuid, session_id HAVING COUNT(*) > 1 LIMIT 1')
-    ).first()
-    if collisions:
-        raise RuntimeError('Cannot downgrade bot-scoped sessions without losing colliding bot records')
-    pk = sa.inspect(conn).get_pk_constraint(_TABLE)
-    with op.batch_alter_table(_TABLE, naming_convention={'pk': 'pk_%(table_name)s'}) as batch:
-        batch.drop_constraint(pk['name'] or f'pk_{_TABLE}', type_='primary')
-        batch.create_primary_key(f'pk_{_TABLE}', ['workspace_uuid', 'session_id'])

src/langbot/pkg/persistence/tenant_uow.py

@@ -207,8 +207,6 @@ _SYNC_PROXY_CAPABILITY: contextvars.ContextVar[_ScopedSessionGuardState | None]
 _ALLOWED_SCOPED_BUILTIN_FUNCTION_TYPES = {
     'coalesce': sqlalchemy.sql.functions.coalesce,
     'count': sqlalchemy.sql.functions.count,
-    'min': sqlalchemy.sql.functions.min,
-    'max': sqlalchemy.sql.functions.max,
     'now': sqlalchemy.sql.functions.now,
     'sum': sqlalchemy.sql.functions.sum,
 }

src/langbot/pkg/pipeline/monitoring_helper.py

@@ -79,7 +79,6 @@ class MonitoringHelper:
             session_updated = await ap.monitoring_service.update_session_activity(
                 get_query_execution_context(query),
                 session_id,
-                bot_id=bot_id,
                 pipeline_id=pipeline_id,
                 pipeline_name=pipeline_name,
             )

src/langbot/pkg/plugin/handler.py

@@ -48,7 +48,6 @@ from ..utils import constants
 
 _DEFAULT_BINARY_STORAGE_VALUE_BYTES = 10 * 1024 * 1024
 _HARD_MAX_BINARY_STORAGE_VALUE_BYTES = 64 * 1024 * 1024
-_UNSET_INSTALLATION_SCOPE = object()
 
 
 def _binary_storage_value_limit(ap: Any) -> int:
@@ -480,6 +479,7 @@ class RuntimeConnectionHandler(handler.Handler):
         self._outbound_installation_context: contextvars.ContextVar[InstallationBinding | None] = (
             contextvars.ContextVar(
                 f'{self.__class__.__name__}_{id(self)}_outbound_installation',
+                default=None,
             )
         )
         self._installation_bindings: dict[
@@ -1631,15 +1631,13 @@ class RuntimeConnectionHandler(handler.Handler):
     ) -> InstallationBinding | ActionContext | None:
         if action_context is not None:
             return super().resolve_outbound_action_context(action_context)
-        # An explicit scope targets the nested call, not its inbound caller.
-        # None deliberately clears the context for runtime-scoped actions.
-        scoped_context = self._outbound_installation_context.get(_UNSET_INSTALLATION_SCOPE)
-        if scoped_context is not _UNSET_INSTALLATION_SCOPE:
-            return typing.cast(InstallationBinding | None, scoped_context)
-        return self.current_action_context
+        inbound_context = self.current_action_context
+        if inbound_context is not None:
+            return inbound_context
+        return self._outbound_installation_context.get()
 
     def require_outbound_installation_context(self) -> InstallationBinding:
-        binding = self._outbound_installation_context.get(None)
+        binding = self._outbound_installation_context.get()
         if not isinstance(binding, InstallationBinding):
             raise ValueError('Host plugin action requires an InstallationBinding scope')
         return binding

tests/integration/api/test_monitoring.py

@@ -9,7 +9,7 @@ Run: uv run pytest tests/integration/api/test_monitoring.py -q
 from __future__ import annotations
 
 import pytest
-from unittest.mock import MagicMock, AsyncMock, Mock, patch
+from unittest.mock import MagicMock, AsyncMock, Mock
 from types import SimpleNamespace
 
 from tests.factories import FakeApp
@@ -280,20 +280,13 @@ class TestMonitoringAllDataEndpoint:
     @pytest.mark.asyncio
     async def test_get_all_data_success(self, quart_test_client):
         """GET /api/v1/monitoring/data returns all data."""
-        traffic = {'series': [], 'truncated': False}
-        with patch(
-            'langbot.pkg.api.http.controller.groups.monitoring.get_traffic_series',
-            new=AsyncMock(return_value=traffic),
-        ) as get_traffic:
-            response = await quart_test_client.get(
-                '/api/v1/monitoring/data', headers={'Authorization': 'Bearer test_token'}
-            )
-        get_traffic.assert_awaited_once()
+        response = await quart_test_client.get(
+            '/api/v1/monitoring/data', headers={'Authorization': 'Bearer test_token'}
+        )
 
         assert response.status_code == 200
         data = await response.get_json()
         assert 'overview' in data['data']
-        assert data['data']['traffic'] == traffic
 
 
 @pytest.mark.usefixtures('mock_circular_import_chain')

tests/integration/persistence/resource_migration_support.py

@@ -193,22 +193,6 @@ async def create_legacy_resource_schema(engine, *, instance_uuid: str) -> None:
         sa.Column('message_id', sa.String(255), nullable=True),
     )
 
-    # Include historical monitoring columns consumed by later migrations.
-    for table_name in ('monitoring_messages', 'monitoring_sessions'):
-        table = monitoring_tables[table_name]
-        for name, value in (('bot_name', 'bot'), ('pipeline_id', 'pipeline-1'), ('pipeline_name', 'pipeline')):
-            table.append_column(sa.Column(name, sa.String(255), nullable=False, default=value))
-        for name in ('platform', 'user_id', 'user_name'):
-            table.append_column(sa.Column(name, sa.String(255)))
-        if table_name == 'monitoring_messages':
-            table.append_column(sa.Column('bot_id', sa.String(255), nullable=False, default='bot-1'))
-            table.append_column(sa.Column('role', sa.String(50)))
-        else:
-            table.append_column(sa.Column('message_count', sa.Integer, nullable=False, default=1))
-            table.append_column(
-                sa.Column('start_time', sa.DateTime, nullable=False, default=datetime.datetime(2026, 1, 1))
-            )
-
     now = datetime.datetime(2026, 1, 1)
     async with engine.begin() as conn:
         await conn.run_sync(metadata.create_all)

tests/integration/persistence/test_migrations.py

@@ -17,7 +17,6 @@ from sqlalchemy import text
 from sqlalchemy.ext.asyncio import create_async_engine
 
 from langbot.pkg.entity.persistence.base import Base
-from langbot.pkg.persistence import mgr as persistence_mgr  # noqa: F401 -- register all ORM tables
 from langbot.pkg.persistence.alembic_runner import (
     run_alembic_downgrade,
     run_alembic_upgrade,
@@ -109,6 +108,7 @@ class TestSQLiteMigrationUpgrade:
         await run_alembic_upgrade(sqlite_engine, 'head')
 
         assert await get_alembic_current(sqlite_engine) == _get_script_head()
+        assert _get_script_head() == '0022_codex_credentials'
 
     @pytest.mark.asyncio
     async def test_upgrade_from_reasoning_config_head_to_merged_head(self, sqlite_engine):
@@ -119,7 +119,7 @@ class TestSQLiteMigrationUpgrade:
         await run_alembic_stamp(sqlite_engine, '0018_llm_reasoning_config')
         await run_alembic_upgrade(sqlite_engine, 'head')
 
-        assert await get_alembic_current(sqlite_engine) == _get_script_head()
+        assert await get_alembic_current(sqlite_engine) == '0022_codex_credentials'
 
     @pytest.mark.asyncio
     async def test_upgrade_from_baseline_to_head(self, sqlite_engine):
@@ -280,15 +280,6 @@ class TestSQLiteMigrationUpgrade:
 class TestSQLiteMigrationFreshDatabase:
     """Tests for fresh database workflow."""
 
-    @pytest.mark.asyncio
-    async def test_bot_scoped_sessions_skips_absent_table(self, sqlite_engine):
-        """A partial schema needs no session key migration in either direction."""
-        await run_alembic_stamp(sqlite_engine, '0022_codex_credentials')
-        await run_alembic_upgrade(sqlite_engine, '0023_bot_scoped_sessions')
-        assert await get_alembic_current(sqlite_engine) == '0023_bot_scoped_sessions'
-        await run_alembic_downgrade(sqlite_engine, '0022_codex_credentials')
-        assert await get_alembic_current(sqlite_engine) == '0022_codex_credentials'
-
     @pytest.mark.asyncio
     async def test_fresh_db_upgrade_from_scratch(self, tmp_path):
         """

tests/integration/persistence/test_monitoring_postgres.py

@@ -1,354 +0,0 @@
-"""Monitoring regressions through asyncpg, Cloud UoW guards, and migrated RLS.
-
-TEST_POSTGRES_URL must identify a disposable PostgreSQL/pgvector test server
-with permission to create databases and roles. Each run owns a fresh database;
-no existing tables are dropped. Without that URL these tests are skipped.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import uuid
-from types import SimpleNamespace
-
-import pytest
-import pytest_asyncio
-import sqlalchemy as sa
-from sqlalchemy.ext.asyncio import create_async_engine
-
-from langbot.pkg.api.http.context import ExecutionContext
-from langbot.pkg.api.http.service.monitoring import MonitoringService
-from langbot.pkg.entity.persistence import monitoring as models
-from langbot.pkg.entity.persistence.workspace import Workspace
-from langbot.pkg.persistence.mgr import PersistenceManager, PersistenceMode
-from langbot.pkg.persistence.tenant_uow import TenantScopeRequiredError
-from langbot.pkg.pipeline.monitoring_helper import MonitoringHelper
-
-pytestmark = [pytest.mark.integration, pytest.mark.slow, pytest.mark.asyncio(loop_scope='module')]
-
-WORKSPACE_A = '00000000-0000-0000-0000-00000000000a'
-WORKSPACE_B = '00000000-0000-0000-0000-00000000000b'
-RESOURCE = dict(bot_id='same-bot', bot_name='Bot', pipeline_id='same-pipeline', pipeline_name='Pipeline')
-MONITORING_TABLES = tuple(
-    table for table in models.MonitoringMessage.metadata.sorted_tables if table.name.startswith('monitoring_')
-)
-
-
-def _context(workspace_uuid):
-    return ExecutionContext(
-        instance_uuid='monitoring-postgres-test',
-        workspace_uuid=workspace_uuid,
-        placement_generation=1,
-        bot_uuid=RESOURCE['bot_id'],
-        pipeline_uuid=RESOURCE['pipeline_id'],
-    )
-
-
-def _application(url):
-    return SimpleNamespace(
-        instance_config=SimpleNamespace(
-            data={
-                'database': {
-                    'use': 'postgresql',
-                    'postgresql': {
-                        'host': url.host,
-                        'port': url.port,
-                        'user': url.username,
-                        'password': url.password,
-                        'database': url.database,
-                    },
-                }
-            }
-        ),
-        logger=logging.getLogger('monitoring-postgres-test'),
-    )
-
-
-@pytest_asyncio.fixture(scope='module', loop_scope='module')
-async def cloud_database():
-    url = os.environ.get('TEST_POSTGRES_URL')
-    if not url:
-        pytest.skip('TEST_POSTGRES_URL not set')
-    admin_url = sa.engine.make_url(url)
-    admin = create_async_engine(admin_url, isolation_level='AUTOCOMMIT')
-    suffix = uuid.uuid4().hex[:12]
-    database_name = f'lb_monitoring_{suffix}'
-    runtime_role = f'lb_monitoring_{suffix}'
-    password = f'Test{uuid.uuid4().hex}'
-    database_created = role_created = False
-    release_manager = runtime_manager = None
-    quote = admin.dialect.identifier_preparer.quote
-    from langbot.pkg.persistence import mgr as mgr_module
-    from langbot.pkg.persistence.databases.postgresql import PostgreSQLDatabaseManager
-    from langbot.pkg.utils import constants
-
-    with pytest.MonkeyPatch.context() as patch:
-        patch.setattr(mgr_module.database, 'preregistered_managers', [PostgreSQLDatabaseManager])
-        patch.setattr(constants, 'instance_id', 'monitoring-postgres-test')
-        try:
-            async with admin.connect() as conn:
-                await conn.execute(sa.text(f'CREATE DATABASE {quote(database_name)}'))
-                database_created = True
-                await conn.execute(
-                    sa.text(f"CREATE ROLE {quote(runtime_role)} LOGIN NOSUPERUSER NOBYPASSRLS PASSWORD '{password}'")
-                )
-                role_created = True
-            release_app = _application(admin_url.set(database=database_name))
-            release_manager = PersistenceManager(release_app, mode=PersistenceMode.RELEASE_MIGRATION)
-            release_app.persistence_mgr = release_manager
-            await release_manager.initialize()
-            async with release_manager.get_db_engine().begin() as conn:
-                for workspace in (WORKSPACE_A, WORKSPACE_B):
-                    await conn.execute(
-                        sa.insert(Workspace).values(
-                            uuid=workspace,
-                            instance_uuid='monitoring-postgres-test',
-                            name=workspace,
-                            slug=workspace,
-                            source='cloud_projection',
-                        )
-                    )
-                tables = release_manager._runtime_business_table_names()
-                quoted_tables = ', '.join(f'public.{quote(name)}' for name in tables)
-                await conn.execute(
-                    sa.text(f'GRANT CONNECT ON DATABASE {quote(database_name)} TO {quote(runtime_role)}')
-                )
-                await conn.execute(sa.text(f'GRANT USAGE ON SCHEMA public TO {quote(runtime_role)}'))
-                await conn.execute(
-                    sa.text(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE {quoted_tables} TO {quote(runtime_role)}')
-                )
-                await conn.execute(sa.text(f'GRANT SELECT ON public.alembic_version TO {quote(runtime_role)}'))
-                sequences = await release_manager._runtime_business_sequence_names(conn, tables)
-                if sequences:
-                    names = ', '.join(f'public.{quote(name)}' for name in sequences)
-                    await conn.execute(sa.text(f'GRANT USAGE, SELECT ON SEQUENCE {names} TO {quote(runtime_role)}'))
-            runtime_app = _application(admin_url.set(database=database_name, username=runtime_role, password=password))
-            runtime_manager = PersistenceManager(runtime_app, mode=PersistenceMode.CLOUD_RUNTIME)
-            runtime_app.persistence_mgr = runtime_manager
-            await runtime_manager.initialize()
-            runtime_app.monitoring_service = MonitoringService(runtime_app)
-            yield runtime_app, release_manager.get_db_engine()
-        finally:
-            if runtime_manager is not None:
-                await runtime_manager.shutdown()
-            if release_manager is not None:
-                await release_manager.shutdown()
-            async with admin.connect() as conn:
-                if database_created:
-                    await conn.execute(sa.text(f'DROP DATABASE {quote(database_name)} WITH (FORCE)'))
-                if role_created:
-                    await conn.execute(sa.text(f'DROP ROLE {quote(runtime_role)}'))
-            await admin.dispose()
-
-
-@pytest_asyncio.fixture(loop_scope='module')
-async def service(cloud_database):
-    application, admin = cloud_database
-    async with admin.begin() as conn:
-        for table in MONITORING_TABLES:
-            await conn.execute(sa.delete(table))
-    application.instance_config.data.pop('monitoring', None)
-    return application.monitoring_service
-
-
-async def _read(service, method, context, *args, **kwargs):
-    # HTTP auth binds a tenant scope; exercise that same guard for service reads.
-    async with service.ap.persistence_mgr.tenant_scope(context.workspace_uuid):
-        return await getattr(service, method)(context, *args, **kwargs)
-
-
-def _query(context, sender_id):
-    return SimpleNamespace(
-        _execution_context=context,
-        launcher_type='person',
-        launcher_id='same-user',
-        sender_id=sender_id,
-        message_chain=SimpleNamespace(model_dump=lambda: [{'type': 'Plain', 'text': 'hello'}]),
-        resp_message_chain=[SimpleNamespace(model_dump=lambda: [{'type': 'Plain', 'text': 'reply'}])],
-        message_event=SimpleNamespace(sender=SimpleNamespace(nickname='Alice')),
-        variables={'public': 'value', '_private': 'hidden'},
-    )
-
-
-@pytest.mark.parametrize('user_id', [123456789, -100123456789, 0, None, '', '00123', '  opaque用户  '])
-@pytest.mark.parametrize('record_type', ['message', 'session', 'feedback'])
-async def test_optional_user_ids_round_trip_through_asyncpg(service, user_id, record_type):
-    context = _context(WORKSPACE_A)
-    expected = str(user_id) if isinstance(user_id, int) else user_id
-    if record_type == 'message':
-        record_id = await service.record_message(
-            context,
-            **RESOURCE,
-            message_content='hello',
-            session_id='same-session',
-            user_id=user_id,
-        )
-        details = await _read(service, 'get_message_details', context, record_id)
-        assert details['message']['user_id'] == expected
-    elif record_type == 'session':
-        await service.record_session_start(context, **RESOURCE, session_id='same-session', user_id=user_id)
-        rows, total = await _read(service, 'get_sessions', context)
-        assert total == 1
-        assert rows[0]['user_id'] == expected
-    else:
-        await service.record_feedback(context, feedback_id='same-feedback', feedback_type=1, user_id=user_id)
-        rows, total = await _read(service, 'get_feedback_list', context)
-        assert total == 1
-        assert rows[0]['user_id'] == expected
-
-
-@pytest.mark.parametrize('user_id', [123456789, -100123456789])
-async def test_query_lifecycle_persists_messages_session_and_llm_link(service, user_id, caplog):
-    context = _context(WORKSPACE_A)
-    query = _query(context, user_id)
-    message_id = await MonitoringHelper.record_query_start(service.ap, query, **RESOURCE)
-    assert message_id, caplog.text
-    await MonitoringHelper.record_llm_call(
-        service.ap,
-        query,
-        **RESOURCE,
-        model_name='model',
-        input_tokens=3,
-        output_tokens=5,
-        duration_ms=25,
-        message_id=message_id,
-    )
-    await MonitoringHelper.record_query_success(service.ap, message_id, query)
-    await MonitoringHelper.record_query_response(service.ap, query, **RESOURCE)
-    rows, total = await _read(service, 'get_messages', context)
-    assert total == 2
-    assert {row['role'] for row in rows} == {'user', 'assistant'}
-    assert {row['user_id'] for row in rows} == {str(user_id)}
-    details = await _read(service, 'get_message_details', context, message_id)
-    assert details['message']['status'] == 'success'
-    assert details['message']['variables'] == '{"public": "value"}'
-    assert details['llm_calls'][0]['message_id'] == message_id
-    assert details['llm_stats']['total_tokens'] == 8
-    sessions, total = await _read(service, 'get_sessions', context)
-    assert total == 1
-    assert sessions[0]['session_id'] == 'person_same-user'
-    assert sessions[0]['user_id'] == str(user_id)
-    assert not [record for record in caplog.records if record.levelno >= logging.ERROR]
-
-
-@pytest.mark.parametrize('user_id', [123, -123])
-async def test_query_error_persists_error_message_and_linked_log(service, user_id, caplog):
-    context = _context(WORKSPACE_A)
-    message_id = await MonitoringHelper.record_query_error(
-        service.ap,
-        _query(context, user_id),
-        **RESOURCE,
-        error=ValueError('failed query'),
-    )
-    assert message_id, caplog.text
-    details = await _read(service, 'get_message_details', context, message_id)
-    assert details['message']['user_id'] == str(user_id)
-    assert details['message']['status'] == 'error'
-    assert details['errors'][0]['message_id'] == message_id
-    assert details['errors'][0]['error_type'] == 'ValueError'
-
-
-@pytest.mark.parametrize('user_id', [True, 1.5, b'123', ['123']])
-@pytest.mark.parametrize('record_type', ['message', 'session', 'feedback'])
-async def test_unsupported_user_ids_fail_at_the_write_boundary(service, user_id, record_type):
-    context = _context(WORKSPACE_A)
-    with pytest.raises(TypeError, match='user_id must be a string, integer, or None'):
-        if record_type == 'message':
-            await service.record_message(
-                context,
-                **RESOURCE,
-                message_content='hello',
-                session_id='session',
-                user_id=user_id,
-            )
-        elif record_type == 'session':
-            await service.record_session_start(context, **RESOURCE, session_id='session', user_id=user_id)
-        else:
-            await service.record_feedback(context, feedback_id='feedback', feedback_type=1, user_id=user_id)
-    async with service.ap.persistence_mgr.tenant_scope(WORKSPACE_A):
-        for model in (models.MonitoringMessage, models.MonitoringSession, models.MonitoringFeedback):
-            count = await service.ap.persistence_mgr.execute_async(sa.select(sa.func.count()).select_from(model))
-            assert count.scalar_one() == 0
-
-
-async def test_session_analysis_aggregates_under_cloud_sql_guard(service):
-    context = _context(WORKSPACE_A)
-    await service.record_session_start(context, **RESOURCE, session_id='same-session')
-    await service.record_message(context, **RESOURCE, session_id='same-session', message_content='hello')
-    result = await _read(service, 'get_session_analysis', context, 'same-session')
-    assert result['found'] is True
-    assert result['message_stats'] == {'total': 1, 'success': 1, 'error': 0, 'pending': 0}
-    assert result['llm_stats']['total_calls'] == 0
-    assert result['tool_stats']['total_calls'] == 0
-    assert result['session_duration_seconds'] == 0
-
-
-async def test_rls_is_enforced_without_application_workspace_predicates(service, cloud_database):
-    _, admin = cloud_database
-    for workspace in (WORKSPACE_A, WORKSPACE_B):
-        await service.record_message(
-            _context(workspace), **RESOURCE, session_id='same-session', message_content=workspace
-        )
-    async with admin.connect() as conn:
-        states = (
-            await conn.execute(
-                sa.text(
-                    'SELECT relname, relrowsecurity, relforcerowsecurity FROM pg_class '
-                    "WHERE relname LIKE 'monitoring_%' AND relkind = 'r'"
-                )
-            )
-        ).all()
-        assert len(states) == len(MONITORING_TABLES)
-        assert all(enabled and forced for _, enabled, forced in states)
-    engine = service.ap.persistence_mgr.get_db_engine()
-    async with engine.connect() as conn:
-        role = (
-            await conn.execute(sa.text('SELECT rolsuper, rolbypassrls FROM pg_roles WHERE rolname = current_user'))
-        ).one()
-        assert role == (False, False)
-        assert (await conn.execute(sa.select(models.MonitoringMessage.id))).all() == []
-    for workspace in (WORKSPACE_A, WORKSPACE_B):
-        async with service.ap.persistence_mgr.tenant_uow(workspace):
-            rows = (
-                await service.ap.persistence_mgr.execute_async(sa.select(models.MonitoringMessage.workspace_uuid))
-            ).all()
-            assert rows == [(workspace,)]
-    with pytest.raises(TenantScopeRequiredError):
-        await service.ap.persistence_mgr.execute_async(sa.select(models.MonitoringMessage.id))
-
-
-async def test_traffic_series_aggregates_all_rows_under_cloud_rls(service):
-    import datetime
-    from langbot.pkg.api.http.service.monitoring_traffic import get_traffic_series
-
-    context = _context(WORKSPACE_A)
-    for workspace, count in ((WORKSPACE_A, 61), (WORKSPACE_B, 2)):
-        async with service.ap.persistence_mgr.tenant_scope(workspace):
-            await service.ap.persistence_mgr.execute_async(
-                sa.insert(models.MonitoringMessage).values(
-                    [
-                        dict(
-                            workspace_uuid=workspace,
-                            id=f'{workspace}-m-{i}',
-                            **RESOURCE,
-                            session_id='shared',
-                            message_content='test',
-                            status='success',
-                            level='info',
-                            timestamp=datetime.datetime(2026, 9, 11, 1, 30),
-                        )
-                        for i in range(count)
-                    ]
-                )
-            )
-    async with service.ap.persistence_mgr.tenant_uow(WORKSPACE_A):
-        result = await get_traffic_series(
-            service.ap,
-            context,
-            bot_ids=[RESOURCE['bot_id']],
-            start_time=datetime.datetime(2026, 9, 11),
-            end_time=datetime.datetime(2026, 9, 12),
-        )
-    assert result['truncated'] is False
-    assert sum(point['messages'] for point in result['points']) == 61

tests/integration/persistence/test_resource_tenancy_migration.py

@@ -142,7 +142,7 @@ async def test_legacy_sqlite_resources_are_backfilled_and_contracted(tmp_path):
         assert pk_columns == {
             'binary_storages': ('workspace_uuid', 'unique_key'),
             'plugin_settings': ('workspace_uuid', 'plugin_author', 'plugin_name'),
-            'monitoring_sessions': ('workspace_uuid', 'bot_id', 'session_id'),
+            'monitoring_sessions': ('workspace_uuid', 'session_id'),
         }
 
         pipeline_run_foreign_keys = await _inspect(
@@ -237,10 +237,8 @@ async def test_sqlite_scoped_keys_allow_cross_workspace_but_reject_same_workspac
             await conn.execute(
                 sa.text(
                     'INSERT INTO monitoring_sessions '
-                    '(workspace_uuid, session_id, bot_id, bot_name, pipeline_id, pipeline_name, '
-                    'start_time, last_activity, message_count, is_active) '
-                    "VALUES (:workspace_uuid, 'session-1', 'bot-2', 'bot', 'pipeline-2', 'pipeline', "
-                    'CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 1, 1)'
+                    '(workspace_uuid, session_id, bot_id, last_activity, is_active) '
+                    "VALUES (:workspace_uuid, 'session-1', 'bot-2', CURRENT_TIMESTAMP, 1)"
                 ),
                 {'workspace_uuid': second_workspace_uuid},
             )

tests/integration/plugin/test_rag_file_transfer_protocol.py

@@ -1,307 +0,0 @@
-"""Real Core/SDK protocol regression tests; no subprocesses or external services.
-
-Run against the intended local SDK (``uv run --no-sync`` after local install).
-The in-memory transport carries JSON strings through Handler.run on both sides;
-send_file, envelope validation, base64 decoding and transfer storage are real.
-Only Core's database/object-storage services, parser dispatch/provider and host
-sandbox prerequisite probing are doubles. Worker launch/registration is
-represented by its already-registered state.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-from contextlib import asynccontextmanager
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import AsyncMock
-
-import pytest
-
-from langbot.pkg.plugin.handler import RuntimeConnectionHandler
-from langbot_plugin.entities.io.actions.enums import CommonAction, LangBotToRuntimeAction, PluginToRuntimeAction
-from langbot_plugin.entities.io.context import ActionContext, InstallationBinding, PluginWorkerPolicy, RuntimeIdentity
-from langbot_plugin.runtime.context import RuntimeContext
-from langbot_plugin.runtime.io.connection import Connection
-from langbot_plugin.entities.io.errors import ActionCallError, ConnectionClosedError
-from langbot_plugin.runtime.io.handler import FILE_CHUNK_LENGTH, Handler
-from langbot_plugin.runtime.io.handlers.control import ControlConnectionHandler
-from langbot_plugin.runtime.io.handlers.plugin import PluginConnectionHandler
-from langbot_plugin.runtime.plugin.mgr import PluginManager
-from langbot_plugin.runtime.security import PLUGIN_FILE_STORAGE_DIR_ENV
-
-
-pytestmark = pytest.mark.asyncio
-PAYLOAD = bytes(range(256)) * 161 + b'\x00original RAG file\xff'
-BINDING = InstallationBinding(
-    instance_uuid='instance-a',
-    workspace_uuid='workspace-a',
-    placement_generation=7,
-    installation_uuid='00000000-0000-4000-8000-000000000001',
-    runtime_revision=3,
-    artifact_digest='a' * 64,
-)
-LEGACY = ActionContext(**BINDING.model_dump(exclude={'runtime_revision', 'artifact_digest'}))
-
-
-class QueueConnection(Connection):
-    """Only the byte transport is replaced, not the request/response machinery."""
-
-    def __init__(self):
-        self.incoming = asyncio.Queue()
-        self.sent = []
-        self.peer = None
-
-    async def send(self, message: str) -> None:
-        assert isinstance(message, str)
-        self.sent.append(json.loads(message))
-        await self.peer.incoming.put(message)
-
-    async def receive(self) -> str:
-        message = await self.incoming.get()
-        if message is None:
-            raise ConnectionClosedError('test transport closed')
-        return message
-
-    async def close(self) -> None:
-        await self.incoming.put(None)
-        await self.peer.incoming.put(None)
-
-
-def connection_pair():
-    left, right = QueueConnection(), QueueConnection()
-    left.peer, right.peer = right, left
-    return left, right
-
-
-@asynccontextmanager
-async def protocol_stack(tmp_path, monkeypatch, profile='oss_dev', binding=LEGACY):
-    monkeypatch.chdir(tmp_path)
-    stored = tmp_path / 'original.bin'
-    stored.write_bytes(PAYLOAD)
-    storage_calls = []
-
-    async def get_file_stream(execution_context, storage_path):
-        storage_calls.append((execution_context, storage_path))
-        assert execution_context.workspace_uuid == BINDING.workspace_uuid
-        assert storage_path == 'knowledge/original.bin'
-        return stored.read_bytes()
-
-    async def get_execution_binding(workspace_uuid, expected_generation):
-        assert workspace_uuid == BINDING.workspace_uuid
-        assert expected_generation == BINDING.placement_generation
-        return BINDING
-
-    setting = SimpleNamespace(
-        plugin_author='tester',
-        plugin_name='engine',
-        installation_uuid=BINDING.installation_uuid,
-        runtime_revision=BINDING.runtime_revision,
-        artifact_digest=BINDING.artifact_digest,
-    )
-    app = SimpleNamespace(
-        deployment=SimpleNamespace(mode='oss' if profile == 'oss_dev' else 'cloud'),
-        logger=logging.getLogger(__name__),
-        persistence_mgr=SimpleNamespace(execute_async=AsyncMock(return_value=SimpleNamespace(first=lambda: setting))),
-        workspace_service=SimpleNamespace(get_execution_binding=get_execution_binding),
-        rag_runtime_service=SimpleNamespace(get_file_stream=get_file_stream),
-    )
-    core_conn, control_conn = connection_pair()
-    monkeypatch.setenv(PLUGIN_FILE_STORAGE_DIR_ENV, str(tmp_path / 'core-transfer'))
-    core = RuntimeConnectionHandler(core_conn, AsyncMock(return_value=False), app)
-    core.register_installation_binding(BINDING, plugin_author='tester', plugin_name='engine')
-    runtime = RuntimeContext()
-    runtime.plugin_mgr = PluginManager(runtime)
-    # No worker is launched: omit only host nsjail/cgroup prerequisite probing.
-    monkeypatch.setattr(runtime.plugin_mgr.worker_launcher, 'configure', lambda policy, profile: None)
-    monkeypatch.setenv(PLUGIN_FILE_STORAGE_DIR_ENV, str(tmp_path / 'runtime-transfer'))
-    control = ControlConnectionHandler(control_conn, runtime)
-    runtime.activate_control_handler(control)
-    bridge_conn, plugin_conn = connection_pair()
-    bridge = PluginConnectionHandler(bridge_conn, runtime, file_storage_dir=str(tmp_path / 'bridge-transfer'))
-    plugin = Handler(plugin_conn, file_storage_dir=str(tmp_path / 'plugin-transfer'))
-    # Trusted state left by registration, not plugin-supplied action data.
-    bridge.bind_action_context(binding)
-    runtime.plugin_mgr.plugin_handlers.append(bridge)
-    runtime.plugin_mgr.plugins.append(SimpleNamespace(_runtime_plugin_handler=bridge))
-    handlers = [core, control, bridge, plugin]
-    tasks = [asyncio.create_task(handler.run()) for handler in handlers]
-    try:
-        await asyncio.wait_for(
-            core.set_runtime_config(
-                runtime_identity=RuntimeIdentity(instance_uuid='instance-a', runtime_id='test-runtime'),
-                worker_policy=PluginWorkerPolicy(
-                    max_cpus=1,
-                    max_memory_mb=128,
-                    max_pids=32,
-                    max_open_files=64,
-                    max_file_size_mb=8,
-                    require_hard_limits=False,
-                ),
-                runtime_profile=profile,
-                cloud_service_url=None,
-            ),
-            5,
-        )
-        if isinstance(binding, InstallationBinding):
-            runtime.activate_installation_binding(binding)
-        else:
-            runtime.bind_workspace(binding)
-        yield SimpleNamespace(
-            core=core,
-            control=control,
-            runtime=runtime,
-            bridge=bridge,
-            plugin=plugin,
-            core_conn=core_conn,
-            control_conn=control_conn,
-            bridge_conn=bridge_conn,
-            plugin_conn=plugin_conn,
-            app=app,
-            storage_calls=storage_calls,
-        )
-    finally:
-        for handler in handlers:
-            await handler.close()
-        await asyncio.wait_for(asyncio.gather(*tasks, return_exceptions=True), 5)
-
-
-def assert_chunks(connection, binding, payload=PAYLOAD):
-    chunks = [message for message in connection.sent if message.get('action') == CommonAction.FILE_CHUNK.value]
-    expected = (len(payload) + FILE_CHUNK_LENGTH - 1) // FILE_CHUNK_LENGTH
-    assert expected > 1
-    assert len(chunks) == expected
-    assert [chunk['data']['chunk_index'] for chunk in chunks] == list(range(expected))
-    assert {chunk['data']['chunk_amount'] for chunk in chunks} == {expected}
-    assert all(chunk['context'] == binding.model_dump() for chunk in chunks)
-    assert len({chunk['data']['file_key'] for chunk in chunks}) == 1
-    return chunks[0]['data']['file_key']
-
-
-@pytest.mark.parametrize(
-    'profile,binding',
-    [('oss_dev', LEGACY), ('oss_dev', BINDING), ('shared', BINDING)],
-    ids=['legacy-oss', 'managed-oss', 'managed-shared'],
-)
-async def test_knowledge_file_roundtrip_reaches_plugin_original_bytes(tmp_path, monkeypatch, profile, binding):
-    async with protocol_stack(tmp_path, monkeypatch, profile, binding) as stack:
-        # Legacy plugin API sends no authority; Runtime supplies its trusted binding.
-        result = await asyncio.wait_for(
-            stack.plugin.call_action(
-                PluginToRuntimeAction.GET_KNOWLEDEGE_FILE_STREAM,
-                {'storage_path': 'knowledge/original.bin'},
-            ),
-            5,
-        )
-        assert await stack.plugin.read_local_file(result['file_key']) == PAYLOAD
-        assert len(stack.storage_calls) == 1
-        core_key = assert_chunks(stack.core_conn, binding)
-        plugin_key = assert_chunks(stack.bridge_conn, binding)
-        assert result['file_key'] == plugin_key != core_key
-        assert not (Path(stack.control.file_storage_dir) / core_key).exists()
-        assert not stack.control._owned_transfer_files
-        callbacks = [
-            message
-            for message in stack.control_conn.sent
-            if message.get('action') == PluginToRuntimeAction.GET_KNOWLEDEGE_FILE_STREAM.value
-        ]
-        assert len(callbacks) == 1
-        assert callbacks[0]['context'] == binding.model_dump()
-        assert callbacks[0]['data'] == {'storage_path': 'knowledge/original.bin'}
-
-
-async def test_shared_control_rejects_legacy_chunks_before_storage(tmp_path, monkeypatch):
-    async with protocol_stack(tmp_path, monkeypatch, 'shared', BINDING) as stack:
-        with stack.core.installation_scope(LEGACY):
-            with pytest.raises(ActionCallError, match='InstallationBinding|Legacy FILE_CHUNK'):
-                await asyncio.wait_for(stack.core.send_file(PAYLOAD, ''), 5)
-        assert not list(Path(stack.control.file_storage_dir).iterdir())
-        assert not stack.control._owned_transfer_files
-
-
-async def test_candidate_artifact_pretransfer_does_not_require_active_installation(tmp_path, monkeypatch):
-    async with protocol_stack(tmp_path, monkeypatch, 'shared', BINDING) as stack:
-        candidate = BINDING.model_copy(
-            update={'installation_uuid': 'candidate-installation', 'runtime_revision': 1, 'artifact_digest': 'c' * 64}
-        )
-        assert not stack.runtime.is_current_installation_binding(candidate)
-        with stack.core.installation_scope(candidate):
-            key = await asyncio.wait_for(stack.core.send_file(PAYLOAD, 'lbp'), 5)
-        assert_chunks(stack.core_conn, candidate)
-        assert await stack.control.read_local_file(key) == PAYLOAD
-        assert not stack.runtime.is_current_installation_binding(candidate)
-
-
-async def test_nested_parser_target_owns_file_and_action_envelopes(tmp_path, monkeypatch):
-    async with protocol_stack(tmp_path, monkeypatch, 'shared', BINDING) as stack:
-        target = BINDING.model_copy(
-            update={
-                'installation_uuid': 'parser-installation',
-                'runtime_revision': 2,
-                'artifact_digest': 'b' * 64,
-            }
-        )
-        stack.runtime.activate_installation_binding(target)
-        parser_calls = []
-        restored = []
-
-        async def parse_document(author, name, context_data, file_bytes):
-            parser_calls.append((stack.control.current_action_context, author, name, context_data, file_bytes))
-            return {'documents': [{'text': 'parsed'}]}
-
-        stack.runtime.plugin_mgr.parse_document = parse_document
-
-        class ParserConnector:
-            async def require_workspace_context(self, context):
-                assert context.workspace_uuid == BINDING.workspace_uuid
-
-            async def call_parser(self, plugin_name, context_data, file_bytes):
-                assert plugin_name == 'tester/parser'
-                assert stack.core.current_action_context == BINDING
-                with stack.core.installation_scope(target):
-                    result = await stack.core.parse_document('tester', 'parser', context_data, file_bytes)
-                restored.append(stack.core.resolve_outbound_action_context(None))
-                return result
-
-        stack.app.plugin_connector = ParserConnector()
-        result = await asyncio.wait_for(
-            stack.plugin.call_action(
-                PluginToRuntimeAction.INVOKE_PARSER,
-                {
-                    'plugin_author': 'tester',
-                    'plugin_name': 'parser',
-                    'storage_path': 'knowledge/original.bin',
-                    'filename': 'original.bin',
-                },
-            ),
-            5,
-        )
-        assert result == {'documents': [{'text': 'parsed'}]}
-        key = assert_chunks(stack.core_conn, target)
-        parse_requests = [
-            message
-            for message in stack.core_conn.sent
-            if message.get('action') == LangBotToRuntimeAction.PARSE_DOCUMENT.value
-        ]
-        assert len(parse_requests) == 1
-        assert parse_requests[0]['context'] == target.model_dump()
-        assert parse_requests[0]['data']['context']['file_key'] == key
-        assert parser_calls == [
-            (
-                target,
-                'tester',
-                'parser',
-                {
-                    'mime_type': 'application/octet-stream',
-                    'filename': 'original.bin',
-                    'metadata': {},
-                },
-                PAYLOAD,
-            )
-        ]
-        assert restored == [BINDING]
-        assert stack.core.current_action_context is None
-        assert stack.core.resolve_outbound_action_context(None) is None
-        assert not (Path(stack.control.file_storage_dir) / key).exists()

tests/unit_tests/api/service/test_monitoring_identifiers.py

@@ -1,19 +0,0 @@
-"""Identifier normalization must not rely on SQLite's permissive codecs."""
-
-import pytest
-
-from langbot.pkg.api.http.service import monitoring
-
-
-@pytest.mark.parametrize(
-    ('value', 'expected'),
-    [(None, None), ('', ''), ('00123', '00123'), ('  用户  ', '  用户  '), (123, '123'), (-123, '-123'), (0, '0')],
-)
-def test_normalize_user_id_preserves_opaque_strings(value, expected):
-    assert monitoring._normalize_user_id(value) == expected
-
-
-@pytest.mark.parametrize('value', [True, False, 1.5, b'123', ['123'], {'id': 123}])
-def test_normalize_user_id_rejects_unsupported_types(value):
-    with pytest.raises(TypeError, match='user_id must be a string, integer, or None'):
-        monitoring._normalize_user_id(value)

tests/unit_tests/api/service/test_monitoring_sessions.py

@@ -1,220 +0,0 @@
-"""Bot-scoped session regressions exercised against real SQL databases."""
-
-import datetime as dt
-import logging
-from types import SimpleNamespace
-
-import pytest
-import sqlalchemy as sa
-from sqlalchemy.ext.asyncio import create_async_engine
-
-from langbot.pkg.api.http.context import ExecutionContext
-from langbot.pkg.api.http.service.monitoring import MonitoringService
-from langbot.pkg.entity.persistence.base import Base
-from langbot.pkg.entity.persistence import monitoring as models
-from langbot.pkg.persistence.mgr import PersistenceManager
-from langbot.pkg.pipeline.monitoring_helper import MonitoringHelper
-
-from tests.integration.persistence.test_monitoring_postgres import cloud_database  # noqa: F401
-
-pytestmark = pytest.mark.asyncio
-
-
-@pytest.mark.asyncio(loop_scope='module')
-async def test_postgres_upgrade_rls_and_concurrent_bot_counts(cloud_database):  # noqa: F811
-    import asyncio
-    import importlib
-    from alembic.migration import MigrationContext
-    from alembic.operations import Operations
-    from tests.integration.persistence.test_monitoring_postgres import WORKSPACE_A, _context, _read
-
-    ap, admin = cloud_database
-    service = ap.monitoring_service
-    ctx = _context(WORKSPACE_A)
-    await service.record_session_start(ctx, session_id='person_42', **resource('a'))
-    for bot in ['a', 'b']:
-        await service.record_message(ctx, session_id='person_42', message_content=bot, **resource(bot))
-    async with admin.begin() as conn:
-
-        def migrate(connection):
-            migration = importlib.import_module('langbot.pkg.persistence.alembic.versions.0023_bot_scoped_sessions')
-            with Operations.context(MigrationContext.configure(connection)):
-                migration.downgrade()
-                migration.upgrade()
-            rls = connection.execute(
-                sa.text("SELECT relrowsecurity, relforcerowsecurity FROM pg_class WHERE relname='monitoring_sessions'")
-            ).one()
-            assert tuple(rls) == (True, True)
-            assert (
-                connection.execute(
-                    sa.text("SELECT count(*) FROM pg_policies WHERE tablename='monitoring_sessions'")
-                ).scalar_one()
-                == 1
-            )
-
-        await conn.run_sync(migrate)
-    rows, total = await _read(service, 'get_sessions', ctx)
-    assert total == 2
-    assert {r['bot_id']: r['message_count'] for r in rows} == {'a': 1, 'b': 1}
-    await asyncio.gather(*[service.record_session_start(ctx, session_id='race', **resource('a')) for _ in range(10)])
-    result = await _read(service, 'get_session_analysis', ctx, 'race', bot_id='a')
-    assert result['session']['message_count'] == 10
-    assert not (await _read(service, 'get_session_analysis', ctx, 'person_42'))['found']
-    assert (await _read(service, 'get_session_analysis', ctx, 'person_42', bot_id='b'))['message_stats']['total'] == 1
-
-
-async def test_migration_reconstructs_collisions_and_preserves_indexes(service):
-    import importlib
-    from alembic.migration import MigrationContext
-    from alembic.operations import Operations
-
-    engine = service.ap.persistence_mgr.get_db_engine()
-    async with engine.begin() as conn:
-
-        def upgrade(connection):
-            table = models.MonitoringSession.__table__
-            table.drop(connection)
-            metadata = sa.MetaData()
-            legacy = table.to_metadata(metadata)
-            legacy.primary_key._columns.remove(legacy.c.bot_id)
-            legacy.c.bot_id.primary_key = False
-            # Resolve the unchanged Workspace FK in copied metadata.
-            Base.metadata.tables['workspaces'].to_metadata(metadata)
-            legacy.create(connection)
-            now = dt.datetime(2026, 1, 1)
-            connection.execute(
-                sa.insert(legacy).values(
-                    workspace_uuid='workspace',
-                    session_id='person_42',
-                    **resource('a'),
-                    message_count=99,
-                    start_time=now,
-                    last_activity=now,
-                    is_active=True,
-                )
-            )
-            for bot in ['a', 'b']:
-                connection.execute(
-                    sa.insert(models.MonitoringMessage).values(
-                        id=bot,
-                        workspace_uuid='workspace',
-                        timestamp=now,
-                        **resource(bot),
-                        session_id='person_42',
-                        message_content=bot,
-                        role='user',
-                        status='success',
-                        level='info',
-                    )
-                )
-            indexes = {i['name'] for i in sa.inspect(connection).get_indexes('monitoring_sessions')}
-            migration = importlib.import_module('langbot.pkg.persistence.alembic.versions.0023_bot_scoped_sessions')
-            with Operations.context(MigrationContext.configure(connection)):
-                migration.upgrade()
-                migration.upgrade()  # Fresh/already-upgraded schema is safe.
-            assert sa.inspect(connection).get_pk_constraint('monitoring_sessions')['constrained_columns'] == [
-                'workspace_uuid',
-                'bot_id',
-                'session_id',
-            ]
-            assert indexes <= {i['name'] for i in sa.inspect(connection).get_indexes('monitoring_sessions')}
-
-        await conn.run_sync(upgrade)
-    rows, total = await service.get_sessions(context())
-    assert total == 2
-    assert {r['bot_id']: r['message_count'] for r in rows} == {'a': 1, 'b': 1}
-    assert {r['pipeline_id'] for r in rows} == {'a', 'b'}
-
-
-def context(bot=None):
-    return ExecutionContext(instance_uuid='test', workspace_uuid='workspace', placement_generation=1, bot_uuid=bot)
-
-
-def resource(bot):
-    return dict(bot_id=bot, bot_name=bot, pipeline_id=bot, pipeline_name=bot)
-
-
-@pytest.fixture
-async def service():
-    engine = create_async_engine('sqlite+aiosqlite:///:memory:')
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-
-    class Persistence:
-        serialize_model = PersistenceManager.serialize_model
-
-        def get_db_engine(self):
-            return engine
-
-        async def execute_async(self, stmt):
-            async with engine.begin() as conn:
-                return await conn.execute(stmt)
-
-    ap = SimpleNamespace(persistence_mgr=Persistence(), logger=logging.getLogger(__name__))
-    ap.monitoring_service = MonitoringService(ap)
-    yield ap.monitoring_service
-    await engine.dispose()
-
-
-async def test_helper_first_message_count_and_two_bot_isolation(service):
-    for bot in ['a', 'b', 'a']:
-        query = SimpleNamespace(
-            _execution_context=context(bot),
-            launcher_type='person',
-            launcher_id=42,
-            sender_id=42,
-            message_chain=SimpleNamespace(model_dump=lambda: []),
-        )
-        assert await MonitoringHelper.record_query_start(service.ap, query, **resource(bot))
-    rows, total = await service.get_sessions(context())
-    assert total == 2
-    assert {r['bot_id']: r['message_count'] for r in rows} == {'a': 2, 'b': 1}
-    assert {r['pipeline_id'] for r in rows} == {'a', 'b'}
-    assert {r['session_id'] for r in rows} == {'person_42'}
-
-
-async def test_analysis_fails_closed_and_scopes_statistics(service):
-    for bot in ['a', 'b']:
-        await service.record_session_start(context(bot), session_id='person_42', **resource(bot))
-        await service.record_message(context(bot), session_id='person_42', message_content=bot, **resource(bot))
-    assert (await service.get_session_analysis(context(), 'person_42'))['found'] is False
-    result = await service.get_session_analysis(context(), 'person_42', bot_id='b')
-    assert result['message_stats']['total'] == 1
-    assert result['session']['bot_id'] == 'b'
-
-
-async def test_activity_requires_bot_and_upsert_counts_racing_first_queries(service):
-    for _ in range(2):
-        await service.record_session_start(context('a'), session_id='person_42', **resource('a'))
-    with pytest.raises(ValueError, match='bot'):
-        await service.update_session_activity(context(), 'person_42')
-    assert await service.update_session_activity(context('a'), 'person_42')
-    assert not await service.update_session_activity(context('b'), 'person_42')
-    rows, _ = await service.get_sessions(context())
-    assert rows[0]['message_count'] == 3
-
-
-async def test_old_active_sessions_are_listed_exported_and_not_cleaned(service):
-    for bot in ['a', 'b']:
-        await service.record_session_start(context(bot), session_id='person_42', **resource(bot))
-    old = dt.datetime(2000, 1, 1)
-    await service.ap.persistence_mgr.execute_async(sa.update(models.MonitoringSession).values(start_time=old))
-    await service.ap.persistence_mgr.execute_async(
-        sa.update(models.MonitoringSession).where(models.MonitoringSession.bot_id == 'a').values(last_activity=old)
-    )
-    since = dt.datetime.now(dt.timezone.utc).replace(tzinfo=None) - dt.timedelta(days=1)
-    rows, total = await service.get_sessions(context(), start_time=since)
-    assert total == 1 and rows[0]['bot_id'] == 'b'
-    assert len(await service.export_sessions(context(), start_time=since)) == 1
-    count = await service._delete_expired_in_batches(
-        context(),
-        models.MonitoringSession,
-        models.MonitoringSession.last_activity,
-        models.MonitoringSession.session_id,
-        since,
-        1,
-        2,
-    )
-    assert count == 1
-    rows, total = await service.get_sessions(context())
-    assert total == 1 and rows[0]['bot_id'] == 'b'

tests/unit_tests/api/service/test_monitoring_traffic.py

@@ -1,125 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from types import SimpleNamespace
-
-import pytest
-import sqlalchemy
-from sqlalchemy.ext.asyncio import create_async_engine
-
-from langbot.pkg.api.http.context import ExecutionContext
-from langbot.pkg.entity.persistence.base import Base
-from langbot.pkg.entity.persistence.monitoring import MonitoringLLMCall, MonitoringMessage
-from langbot.pkg.entity.persistence.workspace import Workspace
-
-pytestmark = pytest.mark.asyncio
-
-A = '00000000-0000-0000-0000-00000000000a'
-B = '00000000-0000-0000-0000-00000000000b'
-START = datetime.datetime(2026, 1, 1)
-
-
-@pytest.fixture
-async def traffic_app():
-    engine = create_async_engine('sqlite+aiosqlite:///:memory:')
-    async with engine.begin() as connection:
-        await connection.run_sync(Base.metadata.create_all)
-        await connection.execute(
-            sqlalchemy.insert(Workspace),
-            [
-                {'uuid': wid, 'instance_uuid': 'instance', 'name': wid, 'slug': wid, 'source': 'cloud_projection'}
-                for wid in (A, B)
-            ],
-        )
-        for wid, bot, count in [(A, 'bot-a', 60), (A, 'bot-b', 7), (B, 'bot-a', 9)]:
-            common = {
-                'workspace_uuid': wid,
-                'timestamp': START,
-                'bot_id': bot,
-                'bot_name': bot,
-                'pipeline_id': 'pipeline',
-                'pipeline_name': 'Pipeline',
-                'session_id': 'person_42',
-                'status': 'success',
-            }
-            await connection.execute(
-                sqlalchemy.insert(MonitoringMessage),
-                [
-                    dict(common, id=f'{wid}-{bot}-{i}', message_content='test fixture', level='info', role='user')
-                    for i in range(count)
-                ],
-            )
-            await connection.execute(
-                sqlalchemy.insert(MonitoringLLMCall),
-                [
-                    dict(
-                        common,
-                        id=f'{wid}-{bot}-{i}',
-                        model_name='fixture-model',
-                        input_tokens=1,
-                        output_tokens=1,
-                        total_tokens=2,
-                        duration=1,
-                    )
-                    for i in range(count)
-                ],
-            )
-
-    class Persistence:
-        def get_db_engine(self):
-            return engine
-
-        async def execute_async(self, statement):
-            async with engine.connect() as connection:
-                return await connection.execute(statement)
-
-    yield SimpleNamespace(persistence_mgr=Persistence())
-    await engine.dispose()
-
-
-async def test_traffic_counts_all_rows_not_just_latest_page(traffic_app):
-    from langbot.pkg.api.http.service.monitoring_traffic import get_traffic_series
-
-    context = ExecutionContext(instance_uuid='instance', workspace_uuid=A, placement_generation=1)
-    result = await get_traffic_series(
-        traffic_app, context, bot_ids=['bot-a'], start_time=START, end_time=START + datetime.timedelta(hours=2)
-    )
-    assert result['bucket'] == 'hour'
-    assert result['truncated'] is False
-    assert sum(point['messages'] for point in result['points']) == 60
-    assert sum(point['llm_calls'] for point in result['points']) == 60
-    assert len(result['points']) == 3
-    assert result['points'][1]['messages'] == result['points'][1]['llm_calls'] == 0
-    assert result['points'][0]['timestamp'] == '2026-01-01T00:00:00Z'
-
-
-async def test_traffic_workspace_pipeline_and_empty_filters(traffic_app):
-    from langbot.pkg.api.http.service.monitoring_traffic import get_traffic_series
-
-    context = ExecutionContext(instance_uuid='instance', workspace_uuid=B, placement_generation=1)
-    kwargs = dict(start_time=START, end_time=START + datetime.timedelta(hours=2))
-    result = await get_traffic_series(traffic_app, context, **kwargs)
-    assert sum(point['messages'] for point in result['points']) == 9
-    empty = await get_traffic_series(traffic_app, context, pipeline_ids=['missing'], **kwargs)
-    assert sum(point['messages'] for point in empty['points']) == 0
-    assert sum(point['llm_calls'] for point in empty['points']) == 0
-
-
-async def test_traffic_bounds_large_ranges_and_marks_truncation(traffic_app):
-    from langbot.pkg.api.http.service.monitoring_traffic import get_traffic_series
-
-    context = ExecutionContext(instance_uuid='instance', workspace_uuid=A, placement_generation=1)
-    result = await get_traffic_series(
-        traffic_app, context, start_time=START, end_time=START + datetime.timedelta(days=5000)
-    )
-    assert result['bucket'] == 'day'
-    assert result['truncated'] is True
-    assert len(result['points']) == 1000
-
-
-async def test_traffic_fails_closed_without_workspace(traffic_app):
-    from langbot.pkg.api.http.authz import WorkspaceRequiredError
-    from langbot.pkg.api.http.service.monitoring_traffic import get_traffic_series
-
-    with pytest.raises(WorkspaceRequiredError):
-        await get_traffic_series(traffic_app, None)

tests/unit_tests/persistence/test_tenant_uow.py

@@ -958,8 +958,6 @@ async def test_scoped_session_rejects_raw_or_unapproved_sql(
     [
         sa.select(sa.literal('set_config(')),
         sa.select(sa.func.count()),
-        sa.select(sa.func.min(sa.column('timestamp'))),
-        sa.select(sa.func.max(sa.column('timestamp'))),
         sa.select(sa.func.coalesce(sa.func.sum(sa.literal(1)), sa.literal(0))),
         sa.select(
             sa.func.now(),

tests/unit_tests/plugin/test_handler_invocation_scope.py

@@ -1,193 +0,0 @@
-"""Exercise nested installation routing through real Core/SDK wire envelopes."""
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import json
-from types import SimpleNamespace
-from unittest.mock import AsyncMock
-
-import pytest
-from langbot_plugin.entities.io.actions.enums import CommonAction, LangBotToRuntimeAction, PluginToRuntimeAction
-from langbot_plugin.entities.io.req import ActionRequest
-from langbot_plugin.entities.io.resp import ActionResponse
-from langbot_plugin.runtime.io import handler as sdk_handler
-
-from langbot.pkg.plugin.connector import PluginRuntimeConnector
-from tests.unit_tests.plugin.test_handler_tenancy import RecordingConnection, make_handler, workspace_context
-
-
-class ReplyingConnection(RecordingConnection):
-    """Replace only the transport, retaining serialization and response routing."""
-
-    async def send(self, message: str) -> None:
-        await super().send(message)
-        request = json.loads(message)
-        if 'action' in request:
-            response = ActionResponse.success({'elements': []})
-            response.seq_id = request['seq_id']
-            await self.handler._route_response(response.seq_id, response.model_dump())
-
-    @property
-    def requests(self):
-        return [request for message in self.sent if 'action' in (request := json.loads(message))]
-
-
-@pytest.fixture
-def bridge(monkeypatch):
-    runtime_handler, app, binding_a = make_handler()
-    connection = ReplyingConnection()
-    connection.handler = runtime_handler
-    runtime_handler.conn = connection
-    monkeypatch.setattr(sdk_handler, 'FILE_CHUNK_LENGTH', 4)
-    binding_b = binding_a.model_copy(
-        update={
-            'installation_uuid': '00000000-0000-4000-8000-000000000002',
-            'runtime_revision': 2,
-            'artifact_digest': 'b' * 64,
-        }
-    )
-    return runtime_handler, app, connection, binding_a, binding_b
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize('mode', ['managed', 'legacy'])
-async def test_nested_invoke_parser_uses_target_for_every_chunk_and_parse(bridge, mode):
-    runtime_handler, app, connection, binding_a, binding_b = bridge
-    app.instance_config = SimpleNamespace(data={'plugin': {'enable': True}})
-    app.deployment.mode = 'cloud' if mode == 'managed' else 'oss'
-    connector = PluginRuntimeConnector(app, AsyncMock())
-    connector.handler = runtime_handler
-    app.plugin_connector = connector
-    execution_context = runtime_handler._execution_context(binding_a)
-    setting_b = SimpleNamespace(
-        installation_uuid=binding_b.installation_uuid,
-        runtime_revision=binding_b.runtime_revision,
-        artifact_digest=binding_b.artifact_digest,
-        install_info={'_artifact_storage': 'tenant_binary_storage_v1'} if mode == 'managed' else {},
-    )
-    connector._setting_for_plugin = AsyncMock(return_value=(execution_context, setting_b))
-    connector.require_workspace_context = AsyncMock(return_value=execution_context)
-    file_bytes = b'parser document'
-    app.rag_runtime_service = SimpleNamespace(get_file_stream=AsyncMock(return_value=file_bytes))
-    inbound_context = binding_a
-    if mode == 'legacy':
-        inbound_context = workspace_context().for_installation(binding_a.installation_uuid)
-        setting_a = SimpleNamespace(
-            plugin_author='author-a',
-            plugin_name='plugin-a',
-            installation_uuid=binding_a.installation_uuid,
-            runtime_revision=binding_a.runtime_revision,
-            artifact_digest=binding_a.artifact_digest,
-        )
-        app.persistence_mgr.execute_async.return_value = SimpleNamespace(first=lambda: setting_a)
-    expected = binding_b if mode == 'managed' else connector._legacy_oss_bridge_binding(execution_context)
-    request = ActionRequest.make_request(
-        101,
-        PluginToRuntimeAction.INVOKE_PARSER.value,
-        {'plugin_author': 'author-b', 'plugin_name': 'parser-b', 'storage_path': 'file-a'},
-        inbound_context,
-    )
-
-    await runtime_handler._handle_action(request.model_dump())
-
-    response = json.loads(connection.sent[-1])
-    assert response['code'] == 0, response
-    chunks = connection.requests[:-1]
-    parse = connection.requests[-1]
-    assert len(chunks) == 4
-    assert all(chunk['action'] == CommonAction.FILE_CHUNK.value for chunk in chunks)
-    assert parse['action'] == LangBotToRuntimeAction.PARSE_DOCUMENT.value
-    assert all(request['context'] == expected.model_dump() for request in connection.requests)
-    assert b''.join(base64.b64decode(chunk['data']['chunk_base64']) for chunk in chunks) == file_bytes
-    assert {chunk['data']['file_key'] for chunk in chunks} == {parse['data']['context']['file_key']}
-    connector._setting_for_plugin.assert_awaited_once_with('author-b', 'parser-b', require_enabled=True)
-    assert runtime_handler.current_action_context is None
-    assert runtime_handler.resolve_outbound_action_context(None) is None
-
-
-@pytest.mark.asyncio
-async def test_explicit_argument_overrides_scope_and_inbound_falls_back(bridge):
-    runtime_handler, _, connection, binding_a, binding_b = bridge
-    token = runtime_handler._current_action_context.set(binding_a)
-    try:
-        with runtime_handler.installation_scope(binding_b):
-            await runtime_handler.call_action(
-                LangBotToRuntimeAction.LIST_PARSERS, {}, action_context=binding_a.model_dump()
-            )
-        await runtime_handler.list_parsers()
-    finally:
-        runtime_handler._current_action_context.reset(token)
-    assert [request['context'] for request in connection.requests] == [binding_a.model_dump()] * 2
-    assert runtime_handler.resolve_outbound_action_context(None) is None
-
-
-@pytest.mark.asyncio
-async def test_explicit_none_scope_clears_inbound_and_restores_outer_scope(bridge):
-    runtime_handler, _, connection, binding_a, binding_b = bridge
-    token = runtime_handler._current_action_context.set(binding_a)
-    try:
-        with runtime_handler.installation_scope(binding_b):
-            await runtime_handler.ping()
-            await runtime_handler.list_parsers()
-        await runtime_handler.list_parsers()
-    finally:
-        runtime_handler._current_action_context.reset(token)
-    assert [request.get('context') for request in connection.requests] == [
-        None,
-        binding_b.model_dump(),
-        binding_a.model_dump(),
-    ]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize('failure', [RuntimeError, asyncio.CancelledError])
-async def test_scope_restores_after_exception_or_cancellation(bridge, failure):
-    runtime_handler, _, connection, binding_a, binding_b = bridge
-    with runtime_handler.installation_scope(binding_a):
-        with pytest.raises(failure):
-            with runtime_handler.installation_scope(binding_b):
-                await runtime_handler.list_parsers()
-                raise failure()
-        await runtime_handler.list_parsers()
-    await runtime_handler.list_parsers()
-    assert [request.get('context') for request in connection.requests] == [
-        binding_b.model_dump(),
-        binding_a.model_dump(),
-        None,
-    ]
-
-
-@pytest.mark.asyncio
-async def test_concurrent_nested_scopes_do_not_leak_on_task_cancellation(bridge):
-    runtime_handler, _, connection, binding_a, binding_b = bridge
-    entered = asyncio.Event()
-    release = asyncio.Event()
-
-    async def cancelled_invocation():
-        with runtime_handler.installation_scope(binding_b):
-            await runtime_handler.list_parsers()
-            entered.set()
-            await release.wait()
-
-    token = runtime_handler._current_action_context.set(binding_a)
-    task = asyncio.create_task(cancelled_invocation())
-    try:
-        await asyncio.wait_for(entered.wait(), timeout=2)
-        with runtime_handler.installation_scope(None):
-            await runtime_handler.list_parsers()
-        task.cancel()
-        with pytest.raises(asyncio.CancelledError):
-            await task
-        await runtime_handler.list_parsers()
-    finally:
-        runtime_handler._current_action_context.reset(token)
-        task.cancel()
-        await asyncio.gather(task, return_exceptions=True)
-    assert [request.get('context') for request in connection.requests] == [
-        binding_b.model_dump(),
-        None,
-        binding_a.model_dump(),
-    ]
-    assert runtime_handler.resolve_outbound_action_context(None) is None

uv.lock

@@ -2129,7 +2129,7 @@ requires-dist = [
     { name = "ebooklib", specifier = ">=0.18" },
     { name = "gewechat-client", specifier = ">=0.1.5" },
     { name = "html2text", specifier = ">=2024.2.26" },
-    { name = "langbot-plugin", specifier = "==0.5.8" },
+    { name = "langbot-plugin", specifier = "==0.5.7" },
     { name = "langchain", specifier = ">=1.3.9" },
     { name = "langchain-core", specifier = ">=1.3.3" },
     { name = "langchain-text-splitters", specifier = ">=1.1.2" },
@@ -2196,7 +2196,7 @@ dev = [
 
 [[package]]
 name = "langbot-plugin"
-version = "0.5.8"
+version = "0.5.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiofiles" },
@@ -2217,9 +2217,9 @@ dependencies = [
     { name = "watchdog" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d0/ab/8d8bd6b8355c5b30b4aab2b5322fd28d8f36158f36d6b4ee33f4df4bc861/langbot_plugin-0.5.8.tar.gz", hash = "sha256:46fbdf948f4a2d110607738ab35633c9ab22a30784edce3a4e684cd19bab84ff", size = 487972, upload-time = "2026-09-11T09:27:58.304Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d2/7d/b024770f1f52c9dc71ddcab79fc07dfb6147ce8e645f0fed170d758e49cb/langbot_plugin-0.5.7.tar.gz", hash = "sha256:faecd566b7ff57dc5f3a5b1be01e2165d25924031c0a65a829c83b51c65255ee", size = 480635, upload-time = "2026-09-04T13:39:22.505Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/13/4939205e2f7922ec09113e390e35f9355ce6d93e1b380a4b3c49441130f5/langbot_plugin-0.5.8-py3-none-any.whl", hash = "sha256:4fbbcfa55f1dcb9af8392b48de8b7877ea79c880dfd268d651404702614d182e", size = 311552, upload-time = "2026-09-11T09:27:57.082Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/25/416745039cacace6a0ca3f719a2eff41dc74cdb30ef7ffaec1de0142bd2e/langbot_plugin-0.5.7-py3-none-any.whl", hash = "sha256:b1a20bcb6a2d482019eafbfe0ac628c106b8e915c7afe89df057b4d8e2015f05", size = 310463, upload-time = "2026-09-04T13:39:21.18Z" },
 ]
 
 [[package]]

web/src/app/home/bots/components/bot-session/BotSessionMonitor.tsx

@@ -157,9 +157,6 @@ const BotSessionMonitor = forwardRef<
   const [messagePage, setMessagePage] = useState(0);
   const [loadingSessions, setLoadingSessions] = useState(false);
   const [loadingMessages, setLoadingMessages] = useState(false);
-  const [sessionError, setSessionError] = useState(false);
-  const [messageError, setMessageError] = useState(false);
-  const [analysisError, setAnalysisError] = useState(false);
   const [copiedUserId, setCopiedUserId] = useState(false);
   const [feedbackMap, setFeedbackMap] = useState<
     Record<string, SessionFeedback>
@@ -239,8 +236,6 @@ const BotSessionMonitor = forwardRef<
   const loadSessions = useCallback(async () => {
     const requestId = ++sessionRequestIdRef.current;
     setLoadingSessions(true);
-    setSessionError(false);
-    setSessions([]);
     try {
       const response = await httpClient.getBotSessions(botId, {
         limit: SESSION_PAGE_SIZE,
@@ -259,7 +254,6 @@ const BotSessionMonitor = forwardRef<
     } catch (error) {
       if (requestId === sessionRequestIdRef.current) {
         console.error('Failed to load sessions:', error);
-        setSessionError(true);
       }
     } finally {
       if (requestId === sessionRequestIdRef.current) {
@@ -280,18 +274,12 @@ const BotSessionMonitor = forwardRef<
     async (sessionId: string, page: number) => {
       const requestId = ++messageRequestIdRef.current;
       setLoadingMessages(true);
-      setMessageError(false);
-      setAnalysisError(false);
-      setMessages([]);
-      setToolCalls([]);
-      setFeedbackMap({});
       setExpandedToolCallIds({});
       try {
         const messagesRes = await httpClient.getSessionMessages(
           sessionId,
           MESSAGE_PAGE_SIZE,
           page * MESSAGE_PAGE_SIZE,
-          botId,
         );
         if (requestId !== messageRequestIdRef.current) return;
         const sorted = (messagesRes.messages ?? []).sort(
@@ -302,19 +290,22 @@ const BotSessionMonitor = forwardRef<
         setMessageTotal(messagesRes.total ?? 0);
 
         try {
-          const analysisRes = await httpClient.getSessionAnalysis<{
+          const analysisParams = new URLSearchParams();
+          if (sorted.length > 0) {
+            analysisParams.set('startTime', sorted[0].timestamp);
+            analysisParams.set('endTime', sorted[sorted.length - 1].timestamp);
+          }
+          const analysisRes = await httpClient.get<{
             tool_calls?: SessionToolCall[];
-          }>(sessionId, botId, {
-            startTime: sorted[0]?.timestamp,
-            endTime: sorted[sorted.length - 1]?.timestamp,
-          });
+          }>(
+            `/api/v1/monitoring/sessions/${encodeURIComponent(sessionId)}/analysis?${analysisParams.toString()}`,
+          );
           if (requestId !== messageRequestIdRef.current) return;
           setToolCalls(analysisRes?.tool_calls ?? []);
         } catch (analysisError) {
           if (requestId !== messageRequestIdRef.current) return;
           console.error('Failed to load session tool calls:', analysisError);
           setToolCalls([]);
-          setAnalysisError(true);
         }
 
         // Collect user message IDs for feedback matching
@@ -346,7 +337,6 @@ const BotSessionMonitor = forwardRef<
       } catch (error) {
         if (requestId === messageRequestIdRef.current) {
           console.error('Failed to load session messages:', error);
-          setMessageError(true);
         }
       } finally {
         if (requestId === messageRequestIdRef.current) {
@@ -359,9 +349,6 @@ const BotSessionMonitor = forwardRef<
 
   useEffect(() => {
     loadSessions();
-    return () => {
-      sessionRequestIdRef.current += 1;
-    };
   }, [loadSessions]);
 
   useEffect(() => {
@@ -375,17 +362,12 @@ const BotSessionMonitor = forwardRef<
     } else {
       messageRequestIdRef.current += 1;
       setLoadingMessages(false);
-      setMessageError(false);
-      setAnalysisError(false);
       setMessages([]);
       setMessageTotal(0);
       setToolCalls([]);
       setExpandedToolCallIds({});
       setFeedbackMap({});
     }
-    return () => {
-      messageRequestIdRef.current += 1;
-    };
   }, [selectedSessionId, messagePage, loadMessages]);
 
   useEffect(() => {
@@ -746,20 +728,6 @@ const BotSessionMonitor = forwardRef<
               <div className="flex items-center justify-center py-12 text-sm text-muted-foreground">
                 {t('bots.sessionMonitor.loading')}
               </div>
-            ) : sessionError ? (
-              <div
-                role="alert"
-                className="p-3 space-y-2 text-sm text-destructive"
-              >
-                <p>{t('monitoring.loadError')}</p>
-                <button
-                  type="button"
-                  onClick={loadSessions}
-                  className="rounded border px-2 py-1 text-foreground"
-                >
-                  {t('common.retry')}
-                </button>
-              </div>
             ) : sessions.length === 0 ? (
               <div className="text-center text-muted-foreground py-12 text-sm">
                 {t('bots.sessionMonitor.noSessions')}
@@ -930,46 +898,10 @@ const BotSessionMonitor = forwardRef<
                 className="flex-1 px-4 py-4 overflow-y-auto min-h-0"
               >
                 <div className="space-y-4">
-                  {analysisError && !loadingMessages && (
-                    <div
-                      role="alert"
-                      className="text-sm text-destructive space-y-2"
-                    >
-                      <p>
-                        {t('monitoring.toolCalls.title')}:{' '}
-                        {t('monitoring.loadError')}
-                      </p>
-                      <button
-                        type="button"
-                        onClick={() =>
-                          loadMessages(selectedSessionId, messagePage)
-                        }
-                        className="rounded border px-2 py-1 text-foreground"
-                      >
-                        {t('common.retry')}
-                      </button>
-                    </div>
-                  )}
                   {loadingMessages ? (
                     <div className="text-center text-muted-foreground py-12 text-sm">
                       {t('bots.sessionMonitor.loading')}
                     </div>
-                  ) : messageError ? (
-                    <div
-                      role="alert"
-                      className="text-sm text-destructive space-y-2"
-                    >
-                      <p>{t('monitoring.loadError')}</p>
-                      <button
-                        type="button"
-                        onClick={() =>
-                          loadMessages(selectedSessionId, messagePage)
-                        }
-                        className="rounded border px-2 py-1 text-foreground"
-                      >
-                        {t('common.retry')}
-                      </button>
-                    </div>
                   ) : timelineItems.length === 0 ? (
                     <div className="text-center text-muted-foreground py-12 text-sm">
                       {t('bots.sessionMonitor.noMessages')}

web/src/app/home/monitoring/components/overview-cards/OverviewCards.tsx

@@ -4,18 +4,24 @@ import { MessageSquare, Sparkles, Check, Users } from 'lucide-react';
 import MetricCard from './MetricCard';
 import SystemStatusCard from './SystemStatusCards';
 import TrafficChart from './TrafficChart';
-import { OverviewMetrics, MonitoringData } from '../../types/monitoring';
+import {
+  OverviewMetrics,
+  MonitoringMessage,
+  LLMCall,
+} from '../../types/monitoring';
 
 interface OverviewCardsProps {
   metrics: OverviewMetrics | null;
-  traffic?: MonitoringData['traffic'];
+  messages?: MonitoringMessage[];
+  llmCalls?: LLMCall[];
   loading?: boolean;
   refreshKey?: number;
 }
 
 export default function OverviewCards({
   metrics,
-  traffic,
+  messages = [],
+  llmCalls = [],
   loading,
   refreshKey,
 }: OverviewCardsProps) {
@@ -94,7 +100,7 @@ export default function OverviewCards({
       </div>
 
       {/* Traffic Chart */}
-      <TrafficChart traffic={traffic} loading={loading} />
+      <TrafficChart messages={messages} llmCalls={llmCalls} loading={loading} />
     </div>
   );
 }

web/src/app/home/monitoring/components/overview-cards/TrafficChart.tsx

@@ -11,33 +11,119 @@ import {
   ResponsiveContainer,
   Legend,
 } from 'recharts';
-import { MonitoringData } from '../../types/monitoring';
+import { MonitoringMessage, LLMCall } from '../../types/monitoring';
 
 interface TrafficChartProps {
-  traffic?: MonitoringData['traffic'];
+  messages: MonitoringMessage[];
+  llmCalls: LLMCall[];
   loading?: boolean;
 }
 
-export default function TrafficChart({ traffic, loading }: TrafficChartProps) {
+interface ChartDataPoint {
+  time: string;
+  timestamp: number;
+  messages: number;
+  llmCalls: number;
+}
+
+export default function TrafficChart({
+  messages,
+  llmCalls,
+  loading,
+}: TrafficChartProps) {
   const { t } = useTranslation();
-  const chartData = useMemo(
-    () =>
-      (traffic?.points ?? []).map((point) => ({
-        ...point,
-        time: point.timestamp.toLocaleString(
-          [],
-          traffic?.bucket === 'day'
-            ? { month: 'short', day: 'numeric' }
-            : {
-                month: 'short',
-                day: 'numeric',
-                hour: '2-digit',
-                minute: '2-digit',
-              },
-        ),
-      })),
-    [traffic],
-  );
+
+  const chartData = useMemo(() => {
+    const safeMessages = Array.isArray(messages) ? messages : [];
+    const safeLlmCalls = Array.isArray(llmCalls) ? llmCalls : [];
+    if (!safeMessages.length && !safeLlmCalls.length) {
+      return [];
+    }
+
+    // Combine all timestamps and find the range
+    const allTimestamps = [
+      ...safeMessages.map((m) => m.timestamp.getTime()),
+      ...safeLlmCalls.map((c) => c.timestamp.getTime()),
+    ];
+
+    if (allTimestamps.length === 0) return [];
+
+    const minTime = Math.min(...allTimestamps);
+    const maxTime = Math.max(...allTimestamps);
+    const timeRange = maxTime - minTime;
+
+    // Determine bucket size based on time range
+    let bucketSize: number;
+    let formatTime: (date: Date) => string;
+
+    if (timeRange <= 60 * 60 * 1000) {
+      // <= 1 hour: 5-minute buckets
+      bucketSize = 5 * 60 * 1000;
+      formatTime = (date) =>
+        date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    } else if (timeRange <= 6 * 60 * 60 * 1000) {
+      // <= 6 hours: 15-minute buckets
+      bucketSize = 15 * 60 * 1000;
+      formatTime = (date) =>
+        date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    } else if (timeRange <= 24 * 60 * 60 * 1000) {
+      // <= 24 hours: 1-hour buckets
+      bucketSize = 60 * 60 * 1000;
+      formatTime = (date) =>
+        date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    } else if (timeRange <= 7 * 24 * 60 * 60 * 1000) {
+      // <= 7 days: 4-hour buckets
+      bucketSize = 4 * 60 * 60 * 1000;
+      formatTime = (date) =>
+        `${date.toLocaleDateString([], {
+          month: 'short',
+          day: 'numeric',
+        })} ${date.toLocaleTimeString([], { hour: '2-digit' })}`;
+    } else {
+      // > 7 days: 1-day buckets
+      bucketSize = 24 * 60 * 60 * 1000;
+      formatTime = (date) =>
+        date.toLocaleDateString([], { month: 'short', day: 'numeric' });
+    }
+
+    // Create buckets
+    const buckets: Map<number, ChartDataPoint> = new Map();
+    const startBucket = Math.floor(minTime / bucketSize) * bucketSize;
+    const endBucket = Math.ceil(maxTime / bucketSize) * bucketSize;
+
+    for (let bucket = startBucket; bucket <= endBucket; bucket += bucketSize) {
+      buckets.set(bucket, {
+        time: formatTime(new Date(bucket)),
+        timestamp: bucket,
+        messages: 0,
+        llmCalls: 0,
+      });
+    }
+
+    // Count messages per bucket
+    safeMessages.forEach((msg) => {
+      const bucket =
+        Math.floor(msg.timestamp.getTime() / bucketSize) * bucketSize;
+      const point = buckets.get(bucket);
+      if (point) {
+        point.messages++;
+      }
+    });
+
+    // Count LLM calls per bucket
+    safeLlmCalls.forEach((call) => {
+      const bucket =
+        Math.floor(call.timestamp.getTime() / bucketSize) * bucketSize;
+      const point = buckets.get(bucket);
+      if (point) {
+        point.llmCalls++;
+      }
+    });
+
+    return Array.from(buckets.values()).sort(
+      (a, b) => a.timestamp - b.timestamp,
+    );
+  }, [messages, llmCalls]);
 
   if (loading) {
     return (
@@ -64,13 +150,7 @@ export default function TrafficChart({ traffic, loading }: TrafficChartProps) {
         </h3>
         <div className="h-[300px] flex flex-col items-center justify-center text-muted-foreground gap-2">
           <BarChart3 className="h-[3rem] w-[3rem]" />
-          <div className="text-sm">
-            {t(
-              traffic
-                ? 'monitoring.trafficChart.noData'
-                : 'monitoring.trafficChart.unavailable',
-            )}
-          </div>
+          <div className="text-sm">{t('monitoring.trafficChart.noData')}</div>
         </div>
       </div>
     );
@@ -81,11 +161,6 @@ export default function TrafficChart({ traffic, loading }: TrafficChartProps) {
       <h3 className="text-base font-semibold text-foreground mb-6">
         {t('monitoring.trafficChart.title')}
       </h3>
-      {traffic?.truncated && (
-        <p role="status" className="text-sm text-muted-foreground mb-3">
-          {t('monitoring.trafficChart.truncated')}
-        </p>
-      )}
       <div className="h-[300px]">
         <ResponsiveContainer width="100%" height="100%">
           <AreaChart

web/src/app/home/monitoring/hooks/useMonitoringData.ts

@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { useState, useEffect, useCallback, useMemo } from 'react';
 import {
   FilterState,
   MonitoringData,
@@ -6,8 +6,7 @@ import {
   LLMCall,
   EmbeddingCall,
 } from '../types/monitoring';
-import { backendClient, useCurrentWorkspace } from '@/app/infra/http';
-import { getCurrentWorkspaceSnapshot } from '@/app/infra/http/currentWorkspaceStore';
+import { backendClient } from '@/app/infra/http';
 import { parseUTCTimestamp } from '../utils/dateUtils';
 
 /**
@@ -17,10 +16,6 @@ export function useMonitoringData(filterState: FilterState) {
   const [data, setData] = useState<MonitoringData | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
-  const workspaceUuid = useCurrentWorkspace()?.workspace.uuid;
-  const requestIdRef = useRef(0);
-  const scope = JSON.stringify([workspaceUuid, filterState]);
-  const [requestScope, setRequestScope] = useState<string | null>(null);
 
   // Memoize filter parameters to prevent unnecessary re-renders
   const selectedBotsStr = useMemo(
@@ -77,12 +72,6 @@ export function useMonitoringData(filterState: FilterState) {
 
   // Fetch data based on filters
   const fetchData = useCallback(async () => {
-    const requestId = ++requestIdRef.current;
-    const isCurrent = () =>
-      requestId === requestIdRef.current &&
-      getCurrentWorkspaceSnapshot()?.workspace.uuid === workspaceUuid;
-    setRequestScope(scope);
-    setData(null);
     setLoading(true);
     setError(null);
 
@@ -102,7 +91,6 @@ export function useMonitoringData(filterState: FilterState) {
         endTime,
         limit: 50,
       });
-      if (!isCurrent()) return;
 
       const overview = response?.overview ?? {
         total_messages: 0,
@@ -139,17 +127,6 @@ export function useMonitoringData(filterState: FilterState) {
 
       // Transform the response to match MonitoringData interface
       const transformedData: MonitoringData = {
-        traffic: response.traffic
-          ? {
-              bucket: response.traffic.bucket,
-              truncated: response.traffic.truncated,
-              points: response.traffic.points.map((point) => ({
-                timestamp: parseUTCTimestamp(point.timestamp),
-                messages: point.messages,
-                llmCalls: point.llm_calls,
-              })),
-            }
-          : undefined,
         overview: {
           totalMessages: overview.total_messages,
           llmCalls: overview.llm_calls,
@@ -419,33 +396,22 @@ export function useMonitoringData(filterState: FilterState) {
 
       setData(transformedData);
     } catch (err) {
-      if (!isCurrent()) return;
       setError(err as Error);
       console.error('Failed to fetch monitoring data:', err);
     } finally {
-      if (isCurrent()) setLoading(false);
+      setLoading(false);
     }
-  }, [
-    getTimeRange,
-    filterState.selectedBots,
-    filterState.selectedPipelines,
-    scope,
-    workspaceUuid,
-  ]);
+  }, [getTimeRange, filterState.selectedBots, filterState.selectedPipelines]);
 
   // Fetch data when filter state changes
   useEffect(() => {
     fetchData();
-    return () => {
-      requestIdRef.current += 1;
-    };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     selectedBotsStr,
     selectedPipelinesStr,
     filterState.timeRange,
     customDateRangeStr,
-    workspaceUuid,
   ]);
 
   // Manual refetch function
@@ -454,9 +420,9 @@ export function useMonitoringData(filterState: FilterState) {
   };
 
   return {
-    data: requestScope === scope ? data : null,
-    loading: requestScope !== scope || loading,
-    error: requestScope === scope ? error : null,
+    data,
+    loading,
+    error,
     refetch,
   };
 }

web/src/app/home/monitoring/types/monitoring.ts

@@ -217,11 +217,6 @@ export interface FeedbackStats {
 }
 
 export interface MonitoringData {
-  traffic?: {
-    bucket: 'hour' | 'day';
-    points: Array<{ timestamp: Date; messages: number; llmCalls: number }>;
-    truncated: boolean;
-  };
   overview: OverviewMetrics;
   messages: MonitoringMessage[];
   llmCalls: LLMCall[];

web/src/app/home/monitoring/utils/conversationTurns.ts

@@ -155,18 +155,17 @@ function findTurnBySessionTime(
   sessionTurns: Map<string, ConversationTurn[]>,
   sessionId: string | undefined,
   timestamp: Date,
-  botId: string,
 ): ConversationTurn | undefined {
   if (!sessionId) {
     return undefined;
   }
 
-  const turns = sessionTurns.get(JSON.stringify([botId, sessionId]));
+  const turns = sessionTurns.get(sessionId);
   if (!turns?.length) {
     return undefined;
   }
 
-  let nearest: ConversationTurn | undefined;
+  let nearest = turns[0];
   const targetTime = timestamp.getTime();
 
   for (const turn of turns) {
@@ -204,16 +203,15 @@ export function buildConversationTurns(
 
   for (const message of visibleMessages) {
     const role = normalizeRole(message, activityMessageIds);
-    const sessionKey = JSON.stringify([message.botId, message.sessionId]);
-    const previousTurn = lastTurnBySession.get(sessionKey);
+    const previousTurn = lastTurnBySession.get(message.sessionId);
     const shouldStartTurn = role === 'user' || !previousTurn;
     const turn = shouldStartTurn ? createTurn(message) : previousTurn;
 
     if (shouldStartTurn) {
-      const turns = sessionTurns.get(sessionKey) ?? [];
+      const turns = sessionTurns.get(message.sessionId) ?? [];
       turns.push(turn);
-      sessionTurns.set(sessionKey, turns);
-      lastTurnBySession.set(sessionKey, turn);
+      sessionTurns.set(message.sessionId, turns);
+      lastTurnBySession.set(message.sessionId, turn);
     }
 
     addMessageToTurn(turn, message, role);
@@ -223,14 +221,9 @@ export function buildConversationTurns(
   const allTurns = Array.from(sessionTurns.values()).flat();
 
   for (const call of llmCalls) {
-    const turn = call.messageId
-      ? messageIdToTurn.get(call.messageId)
-      : findTurnBySessionTime(
-          sessionTurns,
-          call.sessionId,
-          call.timestamp,
-          call.botId,
-        );
+    const turn =
+      (call.messageId ? messageIdToTurn.get(call.messageId) : undefined) ??
+      findTurnBySessionTime(sessionTurns, call.sessionId, call.timestamp);
 
     if (!turn) {
       continue;
@@ -250,14 +243,9 @@ export function buildConversationTurns(
   }
 
   for (const call of toolCalls) {
-    const turn = call.messageId
-      ? messageIdToTurn.get(call.messageId)
-      : findTurnBySessionTime(
-          sessionTurns,
-          call.sessionId,
-          call.timestamp,
-          call.botId,
-        );
+    const turn =
+      (call.messageId ? messageIdToTurn.get(call.messageId) : undefined) ??
+      findTurnBySessionTime(sessionTurns, call.sessionId, call.timestamp);
 
     if (!turn) {
       continue;
@@ -274,14 +262,9 @@ export function buildConversationTurns(
   }
 
   for (const error of errors) {
-    const turn = error.messageId
-      ? messageIdToTurn.get(error.messageId)
-      : findTurnBySessionTime(
-          sessionTurns,
-          error.sessionId,
-          error.timestamp,
-          error.botId,
-        );
+    const turn =
+      (error.messageId ? messageIdToTurn.get(error.messageId) : undefined) ??
+      findTurnBySessionTime(sessionTurns, error.sessionId, error.timestamp);
 
     if (!turn) {
       continue;

web/src/app/infra/http/BackendClient.ts

@@ -563,24 +563,10 @@ export class BackendClient extends BaseHttpClient {
     return this.get(`/api/v1/monitoring/sessions?${queryParams.toString()}`);
   }
 
-  public getSessionAnalysis<T>(
-    sessionId: string,
-    botId: string,
-    options: { startTime?: string; endTime?: string } = {},
-  ): Promise<T> {
-    const queryParams = new URLSearchParams({ botId });
-    if (options.startTime) queryParams.set('startTime', options.startTime);
-    if (options.endTime) queryParams.set('endTime', options.endTime);
-    return this.get(
-      `/api/v1/monitoring/sessions/${encodeURIComponent(sessionId)}/analysis?${queryParams.toString()}`,
-    );
-  }
-
   public getSessionMessages(
     sessionId: string,
     limit: number = 200,
     offset: number = 0,
-    botId?: string,
   ): Promise<{
     messages: Array<{
       id: string;
@@ -604,7 +590,6 @@ export class BackendClient extends BaseHttpClient {
   }> {
     const queryParams = new URLSearchParams();
     queryParams.append('sessionId', sessionId);
-    if (botId) queryParams.append('botId', botId);
     queryParams.append('limit', limit.toString());
     queryParams.append('offset', offset.toString());
     return this.get(`/api/v1/monitoring/messages?${queryParams.toString()}`);
@@ -1511,11 +1496,6 @@ export class BackendClient extends BaseHttpClient {
     endTime?: string;
     limit?: number;
   }): Promise<{
-    traffic?: {
-      bucket: 'hour' | 'day';
-      points: Array<{ timestamp: string; messages: number; llm_calls: number }>;
-      truncated: boolean;
-    };
     overview: {
       total_messages: number;
       llm_calls: number;

web/src/i18n/locales/en-US.ts

@@ -1644,16 +1644,7 @@ const enUS = {
     queryVariables: {
       title: 'Query Variables',
     },
-    loadError: 'Failed to load monitoring data',
-    partialMessages:
-      'Showing {{shown}} of {{total}} messages. Conversation traces may be incomplete.',
-    partialModelCalls: 'Showing {{shown}} of {{total}} model calls.',
-    partialToolCalls:
-      'Showing {{shown}} of {{total}} tool calls. Conversation traces may be incomplete.',
-    partialErrors: 'Showing {{shown}} of {{total}} errors.',
     trafficChart: {
-      unavailable: 'Traffic aggregation unavailable',
-      truncated: 'Traffic range truncated. Choose a shorter time range.',
       title: 'Traffic Overview',
       messages: 'Messages',
       llmCalls: 'LLM Calls',

web/src/i18n/locales/es-ES.ts

@@ -1602,17 +1602,7 @@ const esES = {
     queryVariables: {
       title: 'Variables de consulta',
     },
-    loadError: 'No se pudieron cargar los datos de monitoreo',
-    partialMessages:
-      'Se muestran {{shown}} de {{total}} mensajes. Las trazas de conversación pueden estar incompletas.',
-    partialModelCalls: 'Se muestran {{shown}} de {{total}} llamadas al modelo.',
-    partialToolCalls:
-      'Se muestran {{shown}} de {{total}} llamadas a herramientas. Las trazas de conversación pueden estar incompletas.',
-    partialErrors: 'Se muestran {{shown}} de {{total}} errores.',
     trafficChart: {
-      unavailable: 'Agregación de tráfico no disponible',
-      truncated:
-        'Rango de tráfico truncado. Selecciona un intervalo más corto.',
       title: 'Resumen de tráfico',
       messages: 'Mensajes',
       llmCalls: 'Llamadas LLM',

web/src/i18n/locales/ja-JP.ts

@@ -1653,17 +1653,7 @@ const jaJP = {
     queryVariables: {
       title: 'クエリ変数',
     },
-    loadError: 'モニタリングデータを読み込めませんでした',
-    partialMessages:
-      '全 {{total}} 件中 {{shown}} 件のメッセージを表示。会話トレースは不完全な場合があります。',
-    partialModelCalls: '全 {{total}} 件中 {{shown}} 件のモデル呼び出しを表示。',
-    partialToolCalls:
-      '全 {{total}} 件中 {{shown}} 件のツール呼び出しを表示。会話トレースは不完全な場合があります。',
-    partialErrors: '全 {{total}} 件中 {{shown}} 件のエラーを表示。',
     trafficChart: {
-      unavailable: 'トラフィック集計を利用できません',
-      truncated:
-        'トラフィック範囲が切り詰められています。短い期間を選択してください。',
       title: 'トラフィック概要',
       messages: 'メッセージ',
       llmCalls: 'LLM呼び出し',

web/src/i18n/locales/ru-RU.ts

@@ -1574,16 +1574,7 @@ const ruRU = {
     queryVariables: {
       title: 'Переменные запроса',
     },
-    loadError: 'Не удалось загрузить данные мониторинга',
-    partialMessages:
-      'Показано {{shown}} из {{total}} сообщений. Трассировки диалогов могут быть неполными.',
-    partialModelCalls: 'Показано {{shown}} из {{total}} вызовов модели.',
-    partialToolCalls:
-      'Показано {{shown}} из {{total}} вызовов инструментов. Трассировки диалогов могут быть неполными.',
-    partialErrors: 'Показано {{shown}} из {{total}} ошибок.',
     trafficChart: {
-      unavailable: 'Агрегированные данные трафика недоступны',
-      truncated: 'Диапазон трафика обрезан. Выберите более короткий период.',
       title: 'Обзор трафика',
       messages: 'Сообщения',
       llmCalls: 'Вызовы LLM',

web/src/i18n/locales/th-TH.ts

@@ -1543,17 +1543,7 @@ const thTH = {
     queryVariables: {
       title: 'ตัวแปรคำค้นหา',
     },
-    loadError: 'โหลดข้อมูลการตรวจสอบไม่สำเร็จ',
-    partialMessages:
-      'แสดง {{shown}} จาก {{total}} ข้อความ ประวัติการสนทนาอาจไม่ครบถ้วน',
-    partialModelCalls: 'แสดง {{shown}} จาก {{total}} การเรียกโมเดล',
-    partialToolCalls:
-      'แสดง {{shown}} จาก {{total}} การเรียกเครื่องมือ ประวัติการสนทนาอาจไม่ครบถ้วน',
-    partialErrors: 'แสดง {{shown}} จาก {{total}} ข้อผิดพลาด',
     trafficChart: {
-      unavailable: 'ไม่มีข้อมูลสรุปปริมาณการใช้งาน',
-      truncated:
-        'ช่วงข้อมูลปริมาณการใช้งานถูกตัดทอน โปรดเลือกช่วงเวลาที่สั้นลง',
       title: 'ภาพรวมปริมาณการใช้งาน',
       messages: 'ข้อความ',
       llmCalls: 'การเรียก LLM',

web/src/i18n/locales/vi-VN.ts

@@ -1567,17 +1567,7 @@ const viVN = {
     queryVariables: {
       title: 'Biến truy vấn',
     },
-    loadError: 'Không thể tải dữ liệu giám sát',
-    partialMessages:
-      'Hiển thị {{shown}} trên {{total}} tin nhắn. Dấu vết hội thoại có thể không đầy đủ.',
-    partialModelCalls: 'Hiển thị {{shown}} trên {{total}} lượt gọi mô hình.',
-    partialToolCalls:
-      'Hiển thị {{shown}} trên {{total}} lượt gọi công cụ. Dấu vết hội thoại có thể không đầy đủ.',
-    partialErrors: 'Hiển thị {{shown}} trên {{total}} lỗi.',
     trafficChart: {
-      unavailable: 'Không có dữ liệu tổng hợp lưu lượng',
-      truncated:
-        'Phạm vi lưu lượng bị cắt ngắn. Hãy chọn khoảng thời gian ngắn hơn.',
       title: 'Tổng quan lưu lượng',
       messages: 'Tin nhắn',
       llmCalls: 'Cuộc gọi LLM',

web/src/i18n/locales/zh-Hans.ts

@@ -1572,16 +1572,7 @@ const zhHans = {
     queryVariables: {
       title: '查询变量',
     },
-    loadError: '监控数据加载失败',
-    partialMessages:
-      '显示 {{total}} 条消息中的 {{shown}} 条，对话轨迹可能不完整。',
-    partialModelCalls: '显示 {{total}} 次模型调用中的 {{shown}} 次。',
-    partialToolCalls:
-      '显示 {{total}} 次工具调用中的 {{shown}} 次，对话轨迹可能不完整。',
-    partialErrors: '显示 {{total}} 条错误中的 {{shown}} 条。',
     trafficChart: {
-      unavailable: '流量聚合数据不可用',
-      truncated: '流量时间范围已截断，请选择更短的时间范围。',
       title: '流量概览',
       messages: '消息数',
       llmCalls: 'LLM调用',

web/src/i18n/locales/zh-Hant.ts

@@ -1495,16 +1495,7 @@ const zhHant = {
     queryVariables: {
       title: '查詢變數',
     },
-    loadError: '監控資料載入失敗',
-    partialMessages:
-      '顯示 {{total}} 則訊息中的 {{shown}} 則，對話軌跡可能不完整。',
-    partialModelCalls: '顯示 {{total}} 次模型呼叫中的 {{shown}} 次。',
-    partialToolCalls:
-      '顯示 {{total}} 次工具呼叫中的 {{shown}} 次，對話軌跡可能不完整。',
-    partialErrors: '顯示 {{total}} 筆錯誤中的 {{shown}} 筆。',
     trafficChart: {
-      unavailable: '流量彙總資料無法使用',
-      truncated: '流量時間範圍已截斷，請選擇較短的時間範圍。',
       title: '流量概覽',
       messages: '訊息',
       llmCalls: 'LLM呼叫',

web/tests/e2e/bot-session-tool-timeline.spec.ts

@@ -66,381 +66,7 @@ function toolCall(
   };
 }
 
-test.describe('bot session request recovery', () => {
-  for (const failure of [
-    'initial list',
-    'list page',
-    'session switch',
-    'message page',
-    'analysis',
-  ]) {
-    test(`${failure} failure is visible and retry recovers`, async ({
-      page,
-    }) => {
-      await installLangBotApiMocks(page, { authenticated: true });
-      let failing = true;
-      await page.route('**/api/v1/monitoring/**', async (route) => {
-        const url = new URL(route.request().url());
-        const offset = Number(url.searchParams.get('offset') || 0);
-        const second = url.searchParams.get('sessionId') === 'person-second';
-        const list = url.pathname.endsWith('/sessions');
-        const message = url.pathname.endsWith('/messages');
-        const analysis = url.pathname.endsWith('/analysis');
-        if (!list && !message && !analysis) return route.fallback();
-        const fail =
-          failing &&
-          ((list && failure === 'initial list') ||
-            (list && failure === 'list page' && offset > 0) ||
-            (message && failure === 'session switch' && second) ||
-            (message && failure === 'message page' && offset > 0) ||
-            (analysis && failure === 'analysis'));
-        if (fail)
-          return route.fulfill({
-            status: 500,
-            json: { code: 500, message: 'fixture failure' },
-          });
-        const data = list
-          ? {
-              sessions: [sessionId, 'person-second'].map((id, i) => ({
-                session_id: id,
-                bot_id: botId,
-                bot_name: botName,
-                pipeline_id: pipelineId,
-                pipeline_name: pipelineName,
-                message_count: 51,
-                start_time: at(0),
-                last_activity: at(4),
-                is_active: true,
-                user_name: offset ? `Page two ${i}` : `Recovery user ${i}`,
-              })),
-              total: 21,
-            }
-          : message
-            ? {
-                messages: [
-                  sessionMessage(
-                    'recovery-message',
-                    'user',
-                    0,
-                    second
-                      ? 'Second session message'
-                      : offset
-                        ? 'Second page message'
-                        : 'Successful message',
-                  ),
-                ],
-                total: 51,
-              }
-            : {
-                tool_calls: [
-                  toolCall('recovery-tool', 1, 'recovered_tool', 40),
-                ],
-              };
-        return route.fulfill({ json: { code: 0, data } });
-      });
-      await page.goto(`/home/bots?id=${botId}`);
-      await page.getByRole('tab', { name: /Sessions/ }).click();
-      if (failure === 'list page') {
-        await page.getByRole('button', { name: 'Next', exact: true }).click();
-      } else if (failure !== 'initial list') {
-        await page.getByRole('button', { name: /Recovery user 0/ }).click();
-        if (failure !== 'analysis') {
-          await expect(
-            page.getByText('Successful message', { exact: true }),
-          ).toBeVisible();
-          if (failure === 'session switch')
-            await page.getByRole('button', { name: /Recovery user 1/ }).click();
-          else
-            await page
-              .getByRole('button', { name: 'Next', exact: true })
-              .last()
-              .click();
-        }
-      }
-      await expect(page.getByRole('alert')).toBeVisible();
-      await expect(
-        page.getByText('No sessions found', { exact: true }),
-      ).toHaveCount(0);
-      if (failure === 'analysis') {
-        await expect(page.getByRole('alert')).toContainText(/Tool/i);
-        await expect(
-          page.getByText('Successful message', { exact: true }),
-        ).toBeVisible();
-      } else {
-        await expect(
-          page.getByText('Successful message', { exact: true }),
-        ).toHaveCount(0);
-      }
-      if (failure === 'list page')
-        await expect(
-          page.getByRole('button', { name: /Recovery user 0/ }),
-        ).toHaveCount(0);
-      failing = false;
-      await page
-        .getByRole('alert')
-        .getByRole('button', { name: 'Retry', exact: true })
-        .click();
-      await expect(page.getByRole('alert')).toHaveCount(0);
-      if (failure === 'initial list' || failure === 'list page') {
-        await expect(
-          page.getByRole('button', {
-            name: failure === 'list page' ? /Page two 0/ : /Recovery user 0/,
-          }),
-        ).toBeVisible();
-      } else {
-        await expect(
-          page.getByText(
-            failure === 'session switch'
-              ? 'Second session message'
-              : failure === 'message page'
-                ? 'Second page message'
-                : 'Successful message',
-            { exact: true },
-          ),
-        ).toBeVisible();
-        await expect(
-          page.getByText('recovered_tool', { exact: true }),
-        ).toBeVisible();
-      }
-    });
-  }
-});
-
-test.describe('bot session request races', () => {
-  for (const kind of ['messages', 'analysis', 'sessions']) {
-    for (const status of [200, 500]) {
-      test(`ignores stale ${kind} ${status} after switching`, async ({
-        page,
-      }) => {
-        await installLangBotApiMocks(page, { authenticated: true });
-        let release!: () => void;
-        const gate = new Promise<void>((resolve) => {
-          release = resolve;
-        });
-        let held = false;
-        let released = false;
-        await page.route('**/api/v1/monitoring/**', async (route) => {
-          const url = new URL(route.request().url());
-          const list = url.pathname.endsWith('/sessions');
-          const message = url.pathname.endsWith('/messages');
-          const analysis = url.pathname.endsWith('/analysis');
-          if (!list && !message && !analysis) return route.fallback();
-          const old =
-            kind === 'sessions'
-              ? url.searchParams.get('userQuery') === 'old'
-              : message
-                ? url.searchParams.get('sessionId') === sessionId
-                : url.pathname.includes(sessionId);
-          const isHeld = old && url.pathname.endsWith(`/${kind}`);
-          if (isHeld) {
-            held = true;
-            await gate;
-            if (status === 500) {
-              await route.fulfill({ status: 500, json: { code: 500 } });
-              released = true;
-              return;
-            }
-          }
-          const data = list
-            ? {
-                sessions: [sessionId, 'person-new'].map((id, i) => ({
-                  session_id: id,
-                  bot_id: botId,
-                  bot_name: botName,
-                  pipeline_id: pipelineId,
-                  pipeline_name: pipelineName,
-                  message_count: 1,
-                  start_time: at(0),
-                  last_activity: at(4),
-                  is_active: true,
-                  user_name: isHeld ? 'Stale list' : `Race user ${i}`,
-                })),
-                total: 2,
-              }
-            : message
-              ? {
-                  messages: [
-                    sessionMessage(
-                      'race-message',
-                      'user',
-                      0,
-                      old ? 'Old message' : 'Current message',
-                    ),
-                  ],
-                  total: 1,
-                }
-              : {
-                  tool_calls: [
-                    toolCall(
-                      'race-tool',
-                      1,
-                      old ? 'old_tool' : 'current_tool',
-                      40,
-                    ),
-                  ],
-                };
-          await route.fulfill({ json: { code: 0, data } });
-          if (isHeld) released = true;
-        });
-        await page.goto(`/home/bots?id=${botId}`);
-        await page.getByRole('tab', { name: /Sessions/ }).click();
-        if (kind === 'sessions') {
-          await page
-            .getByRole('textbox', { name: 'User ID or name' })
-            .fill('old');
-          await page
-            .getByRole('textbox', { name: 'User ID or name' })
-            .press('Enter');
-        } else await page.getByRole('button', { name: /Race user 0/ }).click();
-        await expect.poll(() => held).toBe(true);
-        if (kind === 'sessions') {
-          await page
-            .getByRole('textbox', { name: 'User ID or name' })
-            .fill('new');
-          await page
-            .getByRole('textbox', { name: 'User ID or name' })
-            .press('Enter');
-          await expect(
-            page.getByRole('button', { name: /Race user 0/ }),
-          ).toBeVisible();
-        } else {
-          await page.getByRole('button', { name: /Race user 1/ }).click();
-          await expect(
-            page.getByText('Current message', { exact: true }),
-          ).toBeVisible();
-        }
-        release();
-        await expect.poll(() => released).toBe(true);
-        // Allow the released HTTP response and React's queued update to settle.
-        await page.waitForTimeout(200);
-        await expect(page.getByRole('alert')).toHaveCount(0);
-        await expect(page.getByText('Stale list', { exact: true })).toHaveCount(
-          0,
-        );
-        if (kind !== 'sessions') {
-          await expect(
-            page.getByText('Current message', { exact: true }),
-          ).toBeVisible();
-          await expect(
-            page.getByText('current_tool', { exact: true }),
-          ).toBeVisible();
-          await expect(
-            page.getByText('Old message', { exact: true }),
-          ).toHaveCount(0);
-          await expect(page.getByText('old_tool', { exact: true })).toHaveCount(
-            0,
-          );
-        }
-      });
-    }
-  }
-});
-
 test.describe('bot session monitor tool timeline', () => {
-  test('isolates messages and analysis for two bots sharing a raw session id', async ({
-    page,
-  }) => {
-    await installLangBotApiMocks(page, { authenticated: true });
-    const requests: Array<{ bot: string; path: string }> = [];
-    await page.route('**/api/v1/monitoring/**', async (route) => {
-      const url = new URL(route.request().url());
-      const selectedBot = url.searchParams.get('botId');
-      if (
-        !url.pathname.endsWith('/sessions') &&
-        !url.pathname.endsWith('/messages') &&
-        !url.pathname.endsWith('/analysis')
-      ) {
-        return route.fallback();
-      }
-      expect(['bot-shared-a', 'bot-shared-b']).toContain(selectedBot);
-      expect(route.request().headers().authorization).toBe(
-        'Bearer playwright-token',
-      );
-      expect(route.request().headers()['x-workspace-id']).toBe(
-        'workspace-playwright',
-      );
-      requests.push({ bot: selectedBot!, path: url.pathname });
-      const shared = {
-        session_id: sessionId,
-        bot_id: selectedBot,
-        bot_name: selectedBot,
-        pipeline_id: pipelineId,
-        pipeline_name: pipelineName,
-        message_count: 1,
-        start_time: at(0),
-        last_activity: at(4),
-        is_active: true,
-        platform: 'person',
-        user_id: 'shared-user',
-        user_name: 'Shared User',
-      };
-      const data = url.pathname.endsWith('/sessions')
-        ? { sessions: [shared], total: 1 }
-        : url.pathname.endsWith('/messages')
-          ? {
-              messages: [
-                {
-                  ...sessionMessage(
-                    'shared-message',
-                    'user',
-                    0,
-                    `Message for ${selectedBot}`,
-                  ),
-                  bot_id: selectedBot,
-                },
-              ],
-              total: 1,
-            }
-          : {
-              session_id: sessionId,
-              found: true,
-              tool_calls: [
-                {
-                  ...toolCall('shared-tool', 1, `tool_${selectedBot}`, 40),
-                  bot_id: selectedBot,
-                },
-              ],
-            };
-      if (url.pathname.endsWith('/messages'))
-        expect(url.searchParams.get('sessionId')).toBe(sessionId);
-      if (url.pathname.endsWith('/analysis'))
-        expect(decodeURIComponent(url.pathname)).toContain(
-          `/sessions/${sessionId}/analysis`,
-        );
-      await route.fulfill({ json: { code: 0, data } });
-    });
-    for (const selectedBot of ['bot-shared-a', 'bot-shared-b']) {
-      await page.goto(`/home/bots?id=${selectedBot}`);
-      await page.getByRole('tab', { name: /Sessions/ }).click();
-      await page.getByRole('button', { name: /Shared User/ }).click();
-      await expect(
-        page.getByText(`Message for ${selectedBot}`, { exact: true }),
-      ).toBeVisible();
-      await expect(
-        page.getByText(`tool_${selectedBot}`, { exact: true }),
-      ).toBeVisible();
-      const otherBot =
-        selectedBot === 'bot-shared-a' ? 'bot-shared-b' : 'bot-shared-a';
-      await expect(
-        page.getByText(`Message for ${otherBot}`, { exact: true }),
-      ).toHaveCount(0);
-      await expect(
-        page.getByText(`tool_${otherBot}`, { exact: true }),
-      ).toHaveCount(0);
-      expect(
-        requests.some(
-          (request) =>
-            request.bot === selectedBot && request.path.endsWith('/messages'),
-        ),
-      ).toBe(true);
-      expect(
-        requests.some(
-          (request) =>
-            request.bot === selectedBot && request.path.endsWith('/analysis'),
-        ),
-      ).toBe(true);
-    }
-  });
   test('renders tool calls as left-side agent events interleaved with messages', async ({
     page,
   }) => {
@@ -491,41 +117,11 @@ test.describe('bot session monitor tool timeline', () => {
       },
     });
 
-    const monitoringRequests: import('@playwright/test').Request[] = [];
-    page.on('request', (request) => {
-      if (request.url().includes('/api/v1/monitoring/'))
-        monitoringRequests.push(request);
-    });
     await page.goto(`/home/bots?id=${botId}`);
     await page.getByRole('tab', { name: /Sessions/ }).click();
     await page.getByRole('button', { name: /Timeline User/ }).click();
 
     await expect(page.getByText('Need a timeline check')).toBeVisible();
-    await expect
-      .poll(() =>
-        monitoringRequests.some((request) =>
-          request.url().includes('/analysis?'),
-        ),
-      )
-      .toBe(true);
-    for (const request of monitoringRequests.filter((request) =>
-      /\/messages\?|\/analysis\?/.test(request.url()),
-    )) {
-      const url = new URL(request.url());
-      expect(url.searchParams.get('botId')).toBe(botId);
-      if (url.pathname.endsWith('/analysis')) {
-        expect(url.searchParams.get('startTime')).toBe(at(0));
-        expect(url.searchParams.get('endTime')).toBe(at(4));
-      }
-      expect(request.headers().authorization).toBe('Bearer playwright-token');
-      expect(request.headers()['x-workspace-id']).toBe('workspace-playwright');
-      if (url.pathname.endsWith('/messages'))
-        expect(url.searchParams.get('sessionId')).toBe(sessionId);
-      else
-        expect(decodeURIComponent(url.pathname)).toContain(
-          `/sessions/${sessionId}/analysis`,
-        );
-    }
     await expect(
       page.getByText('repo_file_read', { exact: true }),
     ).toBeVisible();

web/tests/e2e/monitoring-turns.spec.ts

@@ -1,4 +1,4 @@
-import { expect, test, Route } from '@playwright/test';
+import { expect, test } from '@playwright/test';
 
 import { installLangBotApiMocks } from './fixtures/langbot-api';
 import { buildConversationTurns } from '../../src/app/home/monitoring/utils/conversationTurns';
@@ -271,198 +271,7 @@ function rawMonitoringData() {
   };
 }
 
-async function respond(route: Route, label: string) {
-  const data = rawMonitoringData();
-  data.messages = [rawMessage(message(label, 'user', 10, label))];
-  await route.fulfill({ json: { code: 0, data } });
-}
-
-test.describe('monitoring request contracts', () => {
-  test('shows failures instead of empty success and retries with auth and Workspace headers', async ({
-    page,
-  }) => {
-    await installLangBotApiMocks(page, { authenticated: true });
-    let failing = true;
-    await page.route('**/api/v1/monitoring/data?*', async (route) => {
-      expect(route.request().headers().authorization).toBe(
-        'Bearer playwright-token',
-      );
-      expect(route.request().headers()['x-workspace-id']).toBe(
-        'workspace-playwright',
-      );
-      if (failing)
-        await route.fulfill({
-          status: 500,
-          json: { code: 500, msg: 'fixture database unavailable' },
-        });
-      else await respond(route, 'Recovered monitoring');
-    });
-    await page.goto('/home/monitoring');
-    await expect(page.getByRole('alert')).toContainText(
-      'Failed to load monitoring data',
-    );
-    await expect(page.getByText('No message records')).toHaveCount(0);
-    failing = false;
-    await page.getByRole('button', { name: 'Retry', exact: true }).click();
-    await expect(
-      page.getByText('Recovered monitoring', { exact: true }),
-    ).toBeVisible();
-    await expect(page.getByRole('alert')).toHaveCount(0);
-  });
-
-  test('latest filter request wins over delayed data and delayed failures', async ({
-    page,
-  }) => {
-    await installLangBotApiMocks(page, { authenticated: true });
-    const pending: Route[] = [];
-    await page.route('**/api/v1/monitoring/data?*', (route) => {
-      pending.push(route);
-    });
-    await page.goto('/home/monitoring');
-    await expect.poll(() => pending.length).toBe(2);
-    await page.getByRole('combobox').last().click();
-    await page.getByRole('option', { name: /Last 7 days/i }).click();
-    await expect.poll(() => pending.length).toBe(3);
-    await respond(pending[2], 'Latest filter data');
-    await expect(
-      page.getByText('Latest filter data', { exact: true }),
-    ).toBeVisible();
-    await respond(pending[0], 'Obsolete filter data');
-    await respond(pending[1], 'Obsolete filter data');
-    await page.evaluate(
-      () =>
-        new Promise<void>((resolve) =>
-          requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
-        ),
-    );
-    await expect(
-      page.getByText('Latest filter data', { exact: true }),
-    ).toBeVisible();
-    await page
-      .getByRole('button', { name: 'Refresh Data', exact: true })
-      .click();
-    await expect.poll(() => pending.length).toBe(4);
-    await expect(
-      page.getByText('Obsolete filter data', { exact: true }),
-    ).toHaveCount(0);
-    await page.getByRole('combobox').last().click();
-    await page.getByRole('option', { name: /Last 24 hours/i }).click();
-    await expect.poll(() => pending.length).toBe(5);
-    await respond(pending[4], 'Current result');
-    await expect(
-      page.getByText('Current result', { exact: true }),
-    ).toBeVisible();
-    await pending[3].fulfill({
-      status: 500,
-      json: { code: 500, msg: 'old failure' },
-    });
-    await expect(
-      page.getByText('Current result', { exact: true }),
-    ).toBeVisible();
-    await expect(page.getByRole('alert')).toHaveCount(0);
-  });
-
-  test('uses aggregate traffic rather than the sparse record page and discloses truncation', async ({
-    page,
-  }) => {
-    const data = rawMonitoringData();
-    data.totalCount.messages = 125;
-    await installLangBotApiMocks(page, {
-      authenticated: true,
-      monitoringData: {
-        ...data,
-        traffic: {
-          bucket: 'hour',
-          truncated: true,
-          points: [
-            { timestamp: time(0).toISOString(), messages: 125, llm_calls: 77 },
-            { timestamp: time(1).toISOString(), messages: 0, llm_calls: 0 },
-          ],
-        },
-      },
-    });
-    await page.goto('/home/monitoring');
-    await expect(
-      page.getByText(
-        'Showing 7 of 125 messages. Conversation traces may be incomplete.',
-      ),
-    ).toBeVisible();
-    await expect(
-      page.getByText('Traffic range truncated. Choose a shorter time range.'),
-    ).toBeVisible();
-    const chart = page.locator('.recharts-wrapper');
-    await expect(chart).toHaveCount(1);
-    await chart
-      .locator(':scope > .recharts-surface')
-      .hover({ position: { x: 70, y: 100 } });
-    await expect(chart.locator('.recharts-tooltip-wrapper')).toContainText(
-      '125',
-    );
-    await expect(chart.locator('.recharts-tooltip-wrapper')).toContainText(
-      '77',
-    );
-  });
-
-  test('does not invent traffic totals when aggregation is unavailable', async ({
-    page,
-  }) => {
-    await installLangBotApiMocks(page, {
-      authenticated: true,
-      monitoringData: rawMonitoringData(),
-    });
-    await page.goto('/home/monitoring');
-    await expect(
-      page.getByText('Traffic aggregation unavailable'),
-    ).toBeVisible();
-    await expect(page.locator('.recharts-wrapper')).toHaveCount(0);
-  });
-});
-
 test.describe('monitoring conversation turn grouping', () => {
-  test('does not reassign explicitly linked activity outside the visible page', () => {
-    const turns = buildConversationTurns(
-      [message('visible', 'user', 10, 'Visible turn')],
-      [llmCall('older-call', 11, 'off-page', 10, 5, 40)],
-      [errorLog('older-error', 11, 'off-page')],
-      [toolCall('older-tool', 11, 'off-page', 'search', 40)],
-    );
-    expect(turns[0].llmCalls).toEqual([]);
-    expect(turns[0].toolCalls).toEqual([]);
-    expect(turns[0].errors).toEqual([]);
-  });
-
-  test('does not assign unlinked activity before the first visible turn', () => {
-    const turns = buildConversationTurns(
-      [message('visible', 'user', 10, 'Visible turn')],
-      [llmCall('older-call', 1, undefined, 10, 5, 40)],
-      [{ ...errorLog('older-error', 1, ''), messageId: undefined }],
-      [toolCall('older-tool', 1, undefined, 'search', 40)],
-    );
-    expect(turns[0].llmCalls).toEqual([]);
-    expect(turns[0].toolCalls).toEqual([]);
-    expect(turns[0].errors).toEqual([]);
-  });
-
-  test('isolates same-session messages and activity by bot identity', () => {
-    const first = message('first', 'user', 1, 'Bot one');
-    const other = {
-      ...message('other', 'user', 2, 'Bot two'),
-      botId: 'other-bot',
-    };
-    const reply = message('reply', 'assistant', 3, 'Bot one reply');
-    const turns = buildConversationTurns(
-      [first, other, reply],
-      [llmCall('call', 3, undefined, 10, 5, 40)],
-      [errorLog('error', 3, first.id)],
-      [toolCall('tool', 3, undefined, 'search', 40)],
-    );
-    const own = turns.find((turn) => turn.id === first.id)!;
-    expect(own.assistantMessages.map((item) => item.id)).toEqual(['reply']);
-    expect(own.llmCalls.map((item) => item.id)).toEqual(['call']);
-    expect(own.toolCalls.map((item) => item.id)).toEqual(['tool']);
-    expect(turns.find((turn) => turn.id === other.id)?.totalTokens).toBe(0);
-  });
-
   test('keeps a single user message as one observable turn', () => {
     const userOnly = message(
       'single-user-only',

web/tests/unit/session-monitor-pagination.test.mjs

@@ -134,22 +134,6 @@ test('session tool calls are bounded to the visible message page', () => {
   const monitor = read(
     'src/app/home/bots/components/bot-session/BotSessionMonitor.tsx',
   );
-  includes(monitor, 'startTime: sorted[0]?.timestamp', 'analysis page start');
-  includes(
-    monitor,
-    'endTime: sorted[sorted.length - 1]?.timestamp',
-    'analysis page end',
-  );
-  includes(monitor, 'sessionId, botId, {', 'bot-scoped analysis');
-  const client = read('src/app/infra/http/BackendClient.ts');
-  includes(
-    client,
-    "queryParams.set('startTime', options.startTime)",
-    'analysis start query',
-  );
-  includes(
-    client,
-    "queryParams.set('endTime', options.endTime)",
-    'analysis end query',
-  );
+  includes(monitor, "analysisParams.set('startTime'", 'analysis page start');
+  includes(monitor, "analysisParams.set('endTime'", 'analysis page end');
 });