@schlessera/brain-ui-server 0.18.0 → 0.20.0

package/src/ws/dispatch.ts

@@ -177,6 +177,19 @@ export async function handleClientMessage(
       break;
     }
 
+    case "activity_subscribe": {
+      // View-scoped opt-in: without a subscription this connection never
+      // receives an activity frame. No turn correlation — subscriptions are
+      // connection state, not turn state.
+      host.activity?.stream.handleSubscribe(ws, msg);
+      break;
+    }
+
+    case "activity_unsubscribe": {
+      host.activity?.stream.handleUnsubscribe(ws, msg);
+      break;
+    }
+
     case "session_resume": {
       host.sendMessage(ws, {
         type: "session_info",

package/src/ws/host.ts

@@ -5,6 +5,16 @@ import type { SessionCatalog } from "./session-catalog.js";
 import type { BackendRegistry } from "../agent/backend.js";
 import { createSilentObservability, type Observability } from "../observability/index.js";
 import { FrameRateLimiter } from "./rate-limit.js";
+import type { ActivityStore } from "../activity/store.js";
+import type { ActivityStream } from "../activity/stream.js";
+
+/** The activity record and its live stream, when the host records activity. */
+export interface ActivityRuntime {
+  store: ActivityStore;
+  stream: ActivityStream;
+  /** Read seam for the agent-facing query tool (bridge.queryActivity). */
+  query?: (query: import("@schlessera/brain-ui-sdk/server").ActivityQuery) => Record<string, unknown>;
+}
 
 /** Host-side turn timeout. The backend no longer times out — the host owns it. */
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
@@ -65,6 +75,12 @@ export interface WsHostOptions {
    * fronting the socket with its own limiter wants.
    */
   wsRate?: { ratePerSecond: number; burst: number };
+  /**
+   * Activity recording (span store + live stream). Optional: a host without
+   * one records nothing and never sends activity frames — which is also what
+   * most existing tests want.
+   */
+  activity?: ActivityRuntime;
 }
 
 /** Identity of one turn, as it appears on a log record. */
@@ -102,6 +118,7 @@ export class WsHost {
   maxConcurrentSessions: () => number;
   readonly observability: Observability;
   readonly wsRate: { ratePerSecond: number; burst: number } | null;
+  readonly activity: ActivityRuntime | null;
   /** Scoped instruments, resolved once — `[ws]` is the existing log prefix. */
   readonly log: ReturnType<Observability["logger"]>;
   private readonly framesDropped: ReturnType<
@@ -130,6 +147,7 @@ export class WsHost {
     this.observability = options.observability ?? createSilentObservability();
     this.wsRate =
       options.wsRate && options.wsRate.ratePerSecond > 0 ? options.wsRate : null;
+    this.activity = options.activity ?? null;
     this.log = this.observability.logger("ws");
     const meter = this.observability.meter("ws");
     this.framesDropped = meter.createCounter("ws.frames.dropped", {

package/src/ws/run-session.ts

@@ -1,7 +1,13 @@
-import type { ChatImageAttachment, ClientEnvironment } from "@schlessera/brain-ui-sdk/protocol";
+import type {
+  BillingMode,
+  ChatImageAttachment,
+  ClientEnvironment,
+} from "@schlessera/brain-ui-sdk/protocol";
+import type { BackendRegistry } from "../agent/backend.js";
 import type { WSContext } from "./clients.js";
 import { withSessionId, withTurnScope } from "./frames.js";
 import { makeBridge, emitTurnError } from "./bridge.js";
+import { createTurnRecorder, type TurnRecorder } from "../activity/recorder.js";
 import { resolveTurnTarget } from "./routing.js";
 import type { QueuedFollowUp, RunningTurn } from "./turns.js";
 import { queuedBytes, queuedFollowUpBytes } from "./turns.js";
@@ -114,7 +120,26 @@ export async function runSession(
       }, host.turnTimeoutMs);
       turn.timeoutHandle = timeoutHandle;
 
-      const bridge = makeBridge(host, turn, text, backend.id);
+      // One recorder per turn identity: a queued follow-up re-mints turnId
+      // and gets its own run in the activity record. The recorder is handed
+      // the RESOLVED profile — `profileId` here is post pin-drop fallback and
+      // carries any session_info re-pin forward between queued turns — plus
+      // its billing mode, so the run's root span classifies what actually ran,
+      // never what was requested.
+      const billing = host.activity
+        ? await resolveRunBilling(host.registry, backend.id, profileId)
+        : undefined;
+      const recorder: TurnRecorder | undefined = host.activity
+        ? createTurnRecorder(
+            {
+              store: host.activity.store,
+              onWrite: () => host.activity!.stream.pump(),
+              log: host.log,
+            },
+            { turnId: turn.turnId, sessionId: turn.sessionId, ...billing }
+          )
+        : undefined;
+      const bridge = makeBridge(host, turn, text, backend.id, recorder);
       const startedAt = Date.now();
       host.reportTurnStarted(turn);
       try {
@@ -139,8 +164,22 @@ export async function runSession(
         } else {
           host.reportTurnCompleted(turn, Date.now() - startedAt);
         }
+        // Terminal precedence: cancellation and timeout are host-owned facts;
+        // otherwise the recorder refines from the buffered result frame.
+        recorder?.finish(
+          turn.cancelled
+            ? "cancelled"
+            : abortController.signal.aborted
+              ? "timeout"
+              : turn.lastResult === "error"
+                ? "error"
+                : "success"
+        );
       } catch (err) {
         emitTurnError(host, turn, err);
+        recorder?.finish(
+          turn.cancelled ? "cancelled" : abortController.signal.aborted ? "timeout" : "error"
+        );
       } finally {
         clearTimeout(timeoutHandle);
       }
@@ -167,6 +206,36 @@ export async function runSession(
   }
 }
 
+/**
+ * Profile identity + billing mode for a turn's root span. When the slot has no
+ * resolved profile id (a resumed session whose pin was dropped), the backend
+ * runs its default profile — the backend's first roster entry — so THAT
+ * profile's identity and billing are recorded, not the dead pin's. Hidden
+ * profiles are included: a session pinned to a profile the user later hid
+ * still runs on it and must classify as it. Never throws: an unreadable
+ * roster records no billing attrs, and the rollup falls back to env
+ * classification.
+ */
+async function resolveRunBilling(
+  registry: BackendRegistry,
+  backendId: string,
+  profileId: string | undefined
+): Promise<{ profileId: string; billingMode?: BillingMode } | undefined> {
+  try {
+    const providers = await registry.listAllProviders({ includeHidden: true });
+    const resolved = profileId
+      ? providers.find((provider) => provider.id === profileId)
+      : providers.find((provider) => provider.backendId === backendId);
+    if (!resolved) return undefined;
+    return {
+      profileId: resolved.id,
+      ...(resolved.billingMode ? { billingMode: resolved.billingMode } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
 /** Queue sizes are only ever reported to a human, so one decimal of MB is plenty. */
 function formatMb(bytes: number): string {
   return `${(bytes / 1024 / 1024).toFixed(1)} MB`;