@schlessera/brain-ui-server 0.15.0 → 0.17.0

package/src/ws/run-session.ts

@@ -5,7 +5,13 @@ import { makeBridge, emitTurnError } from "./bridge.js";
 import { resolveTurnTarget } from "./routing.js";
 import type { QueuedFollowUp, RunningTurn } from "./turns.js";
 import { queuedBytes, queuedFollowUpBytes } from "./turns.js";
-import { MAX_SESSION_QUEUE, QUEUE_MAX_BYTES, QUEUE_WARN_BYTES, type WsHost } from "./host.js";
+import {
+  MAX_SESSION_QUEUE,
+  QUEUE_MAX_BYTES,
+  QUEUE_WARN_BYTES,
+  turnLogAttributes,
+  type WsHost,
+} from "./host.js";
 
 /**
  * Run one session slot: the initial turn, then any queued follow-up turns in
@@ -20,6 +26,8 @@ export async function runSession(
     attachments: ChatImageAttachment[];
     providerId?: string;
     client?: ClientEnvironment;
+    /** Client correlation id for a new conversation; echoed on session_info. */
+    draftId?: string;
   }
 ): Promise<void> {
   const { coordinator } = host;
@@ -28,10 +36,14 @@ export async function runSession(
   try {
     target = await resolveTurnTarget(host.registry, host.catalog, initial.sessionId, initial.providerId);
   } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    // No turn exists yet — routing failed before one was minted — so the
+    // report carries only the session identity the client asked for.
+    host.reportTurnFailed("BACKEND_ERROR", { sessionId: initial.sessionId }, message);
     host.sendToClients({
       type: "error",
       code: "BACKEND_ERROR",
-      message: err instanceof Error ? err.message : String(err),
+      message,
       ...(initial.sessionId ? { sessionId: initial.sessionId } : {}),
     });
     return;
@@ -41,10 +53,11 @@ export async function runSession(
 
   const { backend, profileId: initialProfileId } = target;
   if (target.droppedPin) {
-    console.warn(
-      `[agent] session ${initial.sessionId} pinned profile "${target.droppedPin}" ` +
-        `is unavailable; running on the default profile.`
-    );
+    host.log.emit({
+      severityText: "WARN",
+      body: "pinned profile unavailable; running on the default profile",
+      attributes: { "session.id": initial.sessionId, profile: target.droppedPin },
+    });
     host.sendToClients({
       type: "status",
       status: "thinking",
@@ -55,12 +68,15 @@ export async function runSession(
   const turn: RunningTurn = {
     sessionId: initial.sessionId ?? null,
     turnId: crypto.randomUUID(),
+    // Only meaningful when the client had no session id to send.
+    draftId: initial.sessionId ? null : (initial.draftId ?? null),
     providerId: initialProfileId ?? null,
     backend,
     abortController: new AbortController(),
     timeoutHandle: setTimeout(() => {}, 0),
     queue: [],
     cancelled: false,
+    lastResult: null,
   };
   clearTimeout(turn.timeoutHandle);
   coordinator.running.add(turn);
@@ -82,7 +98,13 @@ export async function runSession(
       const abortController = new AbortController();
       turn.abortController = abortController;
       const timeoutHandle = setTimeout(() => {
-        console.log("[agent] Turn timed out after", host.turnTimeoutMs, "ms");
+        host.log.emit({
+          severityText: "WARN",
+          body: "turn timed out",
+          // Read from the live turn: session_info may have named the session
+          // after this timer was armed.
+          attributes: { ...turnLogAttributes(turn), "timeout.ms": host.turnTimeoutMs },
+        });
         abortController.abort();
         // Reject any pending interactive request for this turn too. A bridge
         // that awaits askUser/approval without racing the abort signal would
@@ -93,6 +115,8 @@ export async function runSession(
       turn.timeoutHandle = timeoutHandle;
 
       const bridge = makeBridge(host, turn, text, backend.id);
+      const startedAt = Date.now();
+      host.reportTurnStarted(turn);
       try {
         await backend.startTurn({
           prompt: text,
@@ -103,6 +127,14 @@ export async function runSession(
           bridge,
           ...(client ? { client } : {}),
         });
+        // A resolved startTurn is not a successful turn: backends resolve for
+        // runtime failures and report them on the terminal result frame, which
+        // the bridge recorded on the turn.
+        if (turn.lastResult === "error") {
+          host.reportTurnFailed("BACKEND_RESULT_ERROR", turn);
+        } else {
+          host.reportTurnCompleted(turn, Date.now() - startedAt);
+        }
       } catch (err) {
         emitTurnError(host, turn, err);
       } finally {
@@ -118,8 +150,10 @@ export async function runSession(
 
       if (!turn.cancelled && turn.queue.length > 0) {
         next = turn.queue.shift()!;
-        // A queued follow-up is its own turn — give it a fresh identity.
+        // A queued follow-up is its own turn — give it a fresh identity, and
+        // its own terminal disposition.
         turn.turnId = crypto.randomUUID();
+        turn.lastResult = null;
       }
     }
   } finally {
@@ -144,9 +178,10 @@ export async function handleChatMessage(
     attachments: ChatImageAttachment[];
     providerId?: string;
     client?: ClientEnvironment;
+    draftId?: string;
   }
 ): Promise<void> {
-  const { text, attachments, sessionId, providerId: requestedProviderId, client } = msg;
+  const { text, attachments, sessionId, providerId: requestedProviderId, client, draftId } = msg;
   const { coordinator } = host;
   const runningTurn = sessionId ? coordinator.bySession.get(sessionId) : undefined;
 
@@ -158,11 +193,10 @@ export async function handleChatMessage(
       // device snapshot is deliberately not forwarded: a follow-up joins a
       // turn whose system prompt was already built and cannot be revised.
       backend.followUp({ sessionId, prompt: text, attachments }).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        host.reportTurnFailed("FOLLOWUP_FAILED", runningTurn, message);
         host.sendToClients(
-          withTurnScope(
-            { type: "error", code: "FOLLOWUP_FAILED", message: err instanceof Error ? err.message : String(err) },
-            runningTurn
-          )
+          withTurnScope({ type: "error", code: "FOLLOWUP_FAILED", message }, runningTurn)
         );
       });
     } else {
@@ -204,7 +238,15 @@ export async function handleChatMessage(
           ? `Queue is holding ${formatMb(total)} across ${runningTurn.queue.length} messages (limit ${formatMb(QUEUE_MAX_BYTES)}).`
           : undefined;
       if (detail) {
-        console.warn(`[ws] session ${sessionId} queue at ${formatMb(total)} across ${runningTurn.queue.length} messages`);
+        host.log.emit({
+          severityText: "WARN",
+          body: "session follow-up queue is heavy",
+          attributes: {
+            "session.id": sessionId,
+            size: formatMb(total),
+            queued: runningTurn.queue.length,
+          },
+        });
       }
       host.sendToClients(
         withSessionId({ type: "status", status: "queued", ...(detail ? { detail } : {}) }, sessionId)
@@ -234,5 +276,6 @@ export async function handleChatMessage(
     attachments,
     providerId: requestedProviderId,
     ...(client ? { client } : {}),
+    ...(draftId ? { draftId } : {}),
   });
 }

package/src/ws/session-catalog.ts

@@ -1,4 +1,5 @@
 import type { Database } from "bun:sqlite";
+import type { Logger } from "@opentelemetry/api-logs";
 import type { ServerResultMessage } from "@schlessera/brain-ui-sdk/protocol";
 
 /**
@@ -42,7 +43,20 @@ const UPSERT_SESSION_SQL = `INSERT INTO sessions (id, title, created_at, last_ac
      backend_id = COALESCE(excluded.backend_id, backend_id)`;
 
 /** SQLite-backed catalog over the app's own database (injected by createApp). */
-export function createSessionCatalog(db: () => Database): SessionCatalog {
+export function createSessionCatalog(db: () => Database, log?: Logger): SessionCatalog {
+  // Persistence stays non-throwing — losing one accounting row must not kill
+  // the turn — but never silent: a full disk or locked database would
+  // otherwise drop every session record with nothing anywhere.
+  const reportWriteFailure = (sessionId: string, err: unknown): void => {
+    log?.emit({
+      severityText: "WARN",
+      body: "session persistence failed",
+      attributes: {
+        "session.id": sessionId,
+        error: err instanceof Error ? err.message : String(err),
+      },
+    });
+  };
   return {
     getStoredProviderId(sessionId) {
       const row = db()
@@ -72,7 +86,9 @@ export function createSessionCatalog(db: () => Database): SessionCatalog {
             providerId,
             backendId
           );
-      } catch {}
+      } catch (err) {
+        reportWriteFailure(sessionId, err);
+      }
     },
 
     persistSession(msg, promptText, providerId, backendId) {
@@ -90,7 +106,9 @@ export function createSessionCatalog(db: () => Database): SessionCatalog {
             providerId,
             backendId
           );
-      } catch {}
+      } catch (err) {
+        reportWriteFailure(msg.sessionId, err);
+      }
     },
   };
 }

package/src/ws/turns.ts

@@ -1,3 +1,4 @@
+import type { Logger } from "@opentelemetry/api-logs";
 import type {
   AgentBackend,
   PermissionDecision,
@@ -54,6 +55,20 @@ export interface RunningTurn {
   timeoutHandle: ReturnType<typeof setTimeout>;
   queue: QueuedFollowUp[];
   cancelled: boolean;
+  /**
+   * Terminal disposition of the CURRENT turn's `result` frame, when one has
+   * streamed. Backends RESOLVE startTurn for runtime failures (the failure
+   * rides the result frame as outcome "error"), so completion accounting must
+   * read this — a resolved startTurn alone does not mean the turn succeeded.
+   * Reset when a queued follow-up becomes the next turn.
+   */
+  lastResult: "success" | "error" | "cancelled" | null;
+  /**
+   * Correlation id the client minted for this NEW conversation, echoed back on
+   * `session_info` so the client can tell its own turn's identity from a
+   * background turn's. Null on a resumed session or a client that sent none.
+   */
+  draftId: string | null;
 }
 
 // Pending interactive requests are tagged with their turn so a per-session
@@ -93,6 +108,13 @@ export interface PendingMask {
  * explicit object with a defined lifecycle.
  */
 export class TurnCoordinator {
+  /**
+   * Where collisions are reported. Assigned by the owning WsHost so the
+   * coordinator reports through the same consumer as everything else; absent
+   * (a bare coordinator in a test) means silence.
+   */
+  log?: Logger;
+
   readonly running = new Set<RunningTurn>();
   readonly bySession = new Map<string, RunningTurn>();
   startingSessions = 0;
@@ -173,9 +195,11 @@ export class TurnCoordinator {
   ): boolean {
     const existing = map.get(id);
     if (existing && existing.turn !== turn) {
-      console.error(
-        `[ws] interactive id collision: "${id}" is already pending for another turn`
-      );
+      this.log?.emit({
+        severityText: "ERROR",
+        body: "interactive id collision: already pending for another turn",
+        attributes: { "request.id": id },
+      });
       return true;
     }
     return false;