@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/runtime/routes/browser-context.ts

@@ -1,3 +1,4 @@
+import type { Conversation } from "../../daemon/conversation.js";
 import { resolveTurnClientOs } from "../../daemon/conversation-client-surface.js";
 import { findConversation } from "../../daemon/conversation-registry.js";
 import type { ToolContext } from "../../tools/types.js";
@@ -13,6 +14,22 @@ export async function resolveBrowserContext(
   headers: Record<string, string>,
   abortSignal?: AbortSignal,
 ): Promise<ToolContext> {
+  return (
+    await resolveBrowserExecutionContext(
+      conversationId,
+      sessionId,
+      headers,
+      abortSignal,
+    )
+  ).context;
+}
+
+export async function resolveBrowserExecutionContext(
+  conversationId: string | undefined,
+  sessionId: string,
+  headers: Record<string, string>,
+  abortSignal?: AbortSignal,
+): Promise<{ context: ToolContext; conversation?: Conversation }> {
   const conversation = conversationId
     ? findConversation(conversationId)
     : undefined;
@@ -24,16 +41,19 @@ export async function resolveBrowserContext(
     (signal): signal is AbortSignal => signal !== undefined,
   );
   return {
-    workingDir: process.cwd(),
-    conversationId: conversation
-      ? conversationId!
-      : browserCliConversationKey(sessionId),
-    trustClass: conversation?.trustContext?.trustClass ?? "unknown",
-    transportInterface: conversation?.transportInterface,
-    clientOs: conversation
-      ? resolveTurnClientOs(conversation).clientOs
-      : undefined,
-    sourceActorPrincipalId: actor,
-    signal: signals.length ? AbortSignal.any(signals) : undefined,
+    context: {
+      workingDir: process.cwd(),
+      conversationId: conversation
+        ? conversationId!
+        : browserCliConversationKey(sessionId),
+      trustClass: conversation?.trustContext?.trustClass ?? "unknown",
+      transportInterface: conversation?.transportInterface,
+      clientOs: conversation
+        ? resolveTurnClientOs(conversation).clientOs
+        : undefined,
+      sourceActorPrincipalId: actor,
+      signal: signals.length ? AbortSignal.any(signals) : undefined,
+    },
+    ...(conversation ? { conversation } : {}),
   };
 }

package/src/runtime/routes/browser-routes.ts

@@ -11,16 +11,20 @@
 
 import { z } from "zod";
 
-import { executeBrowserOperation } from "../../browser/operations.js";
+import {
+  browserOperationLifecycle,
+  executeBrowserOperation,
+} from "../../browser/operations.js";
 import {
   BROWSER_OPERATIONS,
   type BrowserOperation,
 } from "../../browser/types.js";
 import { shouldUseVirtualDesktopBrowser } from "../../browser/virtual-desktop-target.js";
+import { bestEffortModeSessionTracking } from "../../daemon/mode-session-tracking.js";
 import { executeDesktopBrowserOperation } from "../../desktop/desktop-browser-operations.js";
 import type { ContentBlock } from "../../providers/types.js";
 import { LOCAL_PRINCIPALS } from "../auth/route-policy.js";
-import { resolveBrowserContext } from "./browser-context.js";
+import { resolveBrowserExecutionContext } from "./browser-context.js";
 export { browserCliConversationKey } from "./browser-context.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -68,16 +72,51 @@ async function handleBrowserExecute({
   const { operation, input, sessionId, conversationId, desktop } =
     BrowserExecuteParams.parse(body);
 
-  const context = await resolveBrowserContext(
+  const resolved = await resolveBrowserExecutionContext(
     conversationId,
     sessionId,
     headers,
     abortSignal,
   );
+  const { context, conversation } = resolved;
+  const typedOperation = operation as BrowserOperation;
+  const operationToken = conversation?.currentRequestId
+    ? bestEffortModeSessionTracking("browser admission", () =>
+        conversation.browserModeSessions.beginOperation({
+          turnId: conversation.currentRequestId!,
+          lifecycle: browserOperationLifecycle(typedOperation),
+          at: Date.now(),
+        }),
+      )
+    : undefined;
   const execute = shouldUseVirtualDesktopBrowser(desktop, input, context)
     ? executeDesktopBrowserOperation
     : executeBrowserOperation;
-  const result = await execute(operation as BrowserOperation, input, context);
+  const finishOperationTracking = (isError: boolean) => {
+    if (!operationToken) {
+      return;
+    }
+    bestEffortModeSessionTracking("browser completion", () =>
+      conversation?.browserModeSessions.finishOperation(operationToken, {
+        at: Date.now(),
+        isError,
+        cancelled: context.signal?.aborted === true,
+        ...(typedOperation === "close"
+          ? { terminalReason: "browser_closed" as const }
+          : typedOperation === "detach"
+            ? { terminalReason: "browser_detached" as const }
+            : {}),
+      }),
+    );
+  };
+  let result;
+  try {
+    result = await execute(typedOperation, input, context);
+  } catch (error) {
+    finishOperationTracking(true);
+    throw error;
+  }
+  finishOperationTracking(result.isError);
 
   const screenshots = extractScreenshots(result.contentBlocks);
 

package/src/runtime/routes/btw-routes.ts

@@ -2,9 +2,10 @@
  * Route handler for the POST /v1/btw SSE-streaming side-chain endpoint.
  *
  * Runs an ephemeral LLM call that reuses the conversation's provider, tool
- * definitions, and message history for prompt-cache efficiency. Uses the
- * conversation's system prompt when a conversation-specific override is active;
- * otherwise builds a fresh prompt excluding BOOTSTRAP.md so first-run
+ * definitions, and message history for prompt-cache efficiency; the
+ * empty-state greeting targets no real conversation and sends no tools. Uses
+ * the conversation's system prompt when a conversation-specific override is
+ * active; otherwise builds a fresh prompt excluding BOOTSTRAP.md so first-run
  * onboarding instructions don't leak into cosmetic UI calls like identity
  * intro generation. The response is streamed as SSE events (`btw_text_delta`,
  * `btw_complete`, `btw_error`).
@@ -145,7 +146,11 @@ async function handleBtw({
           const result = await runBtwSidechain({
             content: effectiveContent,
             conversation,
-            tools: getAllToolDefinitions(),
+            // The side-chain forces `tool_choice: none`, so tool definitions
+            // only earn their tokens as a shared cache prefix with a real
+            // conversation. The greeting runs against an ephemeral one with its
+            // own system prompt, so it shares nothing and sends no tools.
+            tools: isGreeting ? [] : getAllToolDefinitions(),
             signal: abortSignal,
             ...(isGreeting ? { callSite: "emptyStateGreeting" as const } : {}),
             onEvent: (event) => {

package/src/runtime/routes/channel-route-shared.ts

@@ -29,13 +29,6 @@ export function requiredDecisionKeywords(
 // Callback data parser — format: "apr:<requestId>:<action>"
 // ---------------------------------------------------------------------------
 
-/** Map legacy callback actions to canonical ones for in-flight buttons. */
-const LEGACY_CALLBACK_MAP: Record<string, string> = {
-  approve_10m: "approve_once",
-  approve_conversation: "approve_once",
-  approve_always: "approve_once",
-};
-
 export function parseCallbackData(
   data: string,
   sourceChannel?: string,
@@ -45,8 +38,7 @@ export function parseCallbackData(
     return null;
   }
   const requestId = parts[1];
-  const rawAction = parts.slice(2).join(":");
-  const action = LEGACY_CALLBACK_MAP[rawAction] ?? rawAction;
+  const action = parts.slice(2).join(":");
   if (!requestId || !isApprovalAction(action)) {
     return null;
   }

package/src/runtime/routes/client-routes.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 
 import type { HostProxyCapability } from "../../channels/types.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
+import { listClientConnectionHistory } from "../../persistence/client-connection-events-store.js";
 import { datesToISO } from "../../util/json.js";
 import { getLogger } from "../../util/logger.js";
 import {
@@ -112,6 +113,8 @@ export const ROUTES: RouteDefinition[] = [
             interfaceId: c.interfaceId,
             capabilities: c.capabilities,
             machineName: c.machineName,
+            clientVersion: c.clientVersion,
+            sseWatchdog: c.sseWatchdog,
             connectedAt: c.connectedAt,
             lastActiveAt: c.lastActiveAt,
             degraded: isClientDegraded(
@@ -151,6 +154,79 @@ export const ROUTES: RouteDefinition[] = [
       return { disconnected: count };
     },
   },
+  {
+    operationId: "list_client_history",
+    endpoint: "clients/history",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "List client connection history",
+    description:
+      "Return persisted client subscribe/dispose events and coalesced sessions. Reconnects shorter than 60 seconds are flaps, not outages.",
+    tags: ["clients"],
+    queryParams: [
+      {
+        name: "clientId",
+        type: "string",
+        required: false,
+        description: "Restrict history to one client UUID.",
+      },
+      {
+        name: "interfaceId",
+        type: "string",
+        required: false,
+        description: "Restrict history to one interface (e.g. chrome-extension).",
+      },
+      {
+        name: "since",
+        type: "string",
+        required: false,
+        description:
+          "ISO-8601 or epoch-ms lower bound. Sessions already open at this time are included.",
+      },
+      {
+        name: "limit",
+        type: "string",
+        required: false,
+        description: "Max coalesced sessions to return (1-500, default 50).",
+      },
+    ],
+    responseBody: z.object({
+      sessions: z.array(z.object({}).passthrough()),
+      events: z.array(z.object({}).passthrough()),
+    }),
+    handler: ({ queryParams, headers }) => {
+      const since = parseHistorySince(queryParams?.since);
+      const limit = parseHistoryLimit(queryParams?.limit);
+      const callerPrincipalId = headers?.["x-vellum-actor-principal-id"];
+      const history = listClientConnectionHistory({
+        clientId: queryParams?.clientId?.trim() || undefined,
+        interfaceId: queryParams?.interfaceId?.trim() || undefined,
+        actorPrincipalId: isHttpAuthDisabled()
+          ? undefined
+          : callerPrincipalId || "__none__",
+        since,
+        limit,
+      });
+
+      return {
+        sessions: history.sessions.map((session) => ({
+          ...session,
+          startedAt: new Date(session.startedAt).toISOString(),
+          endedAt:
+            session.endedAt == null
+              ? null
+              : new Date(session.endedAt).toISOString(),
+        })),
+        events: history.events.map((event) => ({
+          ...event,
+          occurredAt: new Date(event.occurredAt).toISOString(),
+        })),
+      };
+    },
+  },
   {
     operationId: "report_client_presence",
     endpoint: "clients/presence",
@@ -342,3 +418,35 @@ export const ROUTES: RouteDefinition[] = [
     },
   },
 ];
+
+function parseHistorySince(raw: string | undefined): number | undefined {
+  if (!raw?.trim()) {
+    return undefined;
+  }
+  const trimmed = raw.trim();
+  if (/^\d+$/.test(trimmed)) {
+    const epoch = Number(trimmed);
+    if (!Number.isFinite(epoch) || epoch < 0) {
+      throw new BadRequestError("since must be a non-negative epoch-ms value");
+    }
+    return epoch;
+  }
+  const parsed = Date.parse(trimmed);
+  if (Number.isNaN(parsed)) {
+    throw new BadRequestError(
+      "since must be an ISO-8601 timestamp or epoch milliseconds",
+    );
+  }
+  return parsed;
+}
+
+function parseHistoryLimit(raw: string | undefined): number | undefined {
+  if (!raw?.trim()) {
+    return undefined;
+  }
+  const parsed = Number(raw.trim());
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new BadRequestError("limit must be a positive integer");
+  }
+  return parsed;
+}

package/src/runtime/routes/conversation-management-routes.ts

@@ -19,7 +19,6 @@
  * POST   /v1/conversations/:id/retry      — retry the last assistant turn
  * POST   /v1/conversations/reorder        — reorder / pin conversations
  */
-
 import { v7 as uuidv7 } from "uuid";
 import { z } from "zod";
 
@@ -43,6 +42,7 @@ import {
   undoLastMessage,
 } from "../../daemon/handlers/conversations.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
+import { bestEffortModeSessionTracking } from "../../daemon/mode-session-tracking.js";
 import { stripConversationIds } from "../../home/feed-writer.js";
 import {
   archiveConversation,
@@ -732,6 +732,9 @@ async function handleRetryLastAssistantTurn({
     if (!discarded) {
       throw new UnprocessableEntityError("No user message to retry from");
     }
+    bestEffortModeSessionTracking("conversation wait invalidation", () =>
+      conversation.modeSessions.invalidateAllStructuralWaits(),
+    );
   } catch (err) {
     if (conversation.abortController === abortController) {
       conversation.abortController = null;

package/src/runtime/routes/conversation-routes.ts

@@ -18,6 +18,7 @@ import {
   createUserMessage,
 } from "../../agent/message-types.js";
 import type { AssistantEvent } from "../../api/index.js";
+import { ModeSessionDescriptorSchema } from "../../api/mode-session.js";
 import {
   BackgroundToolCompletionSchema,
   type ConversationContentBlock,
@@ -44,10 +45,8 @@ import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-fl
 import { getUserSelectableProfilesForProvider } from "../../config/default-profile-catalog.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
-import {
-  mergeConsecutiveAssistantMessages,
-  mergeToolResultsIntoAssistantMessages,
-} from "../../conversations/message-consolidation.js";
+import { isModeSessionRecoveryHealthy } from "../../config/session-groups-gate.js";
+import { consolidateMessageRows } from "../../conversations/message-consolidation.js";
 import { resolveTurnCommitWaitMs } from "../../daemon/abort-watchdog.js";
 import { createApprovalConversationGenerator } from "../../daemon/approval-generators.js";
 import type { Conversation } from "../../daemon/conversation.js";
@@ -113,7 +112,7 @@ import { recordOnboardingEvent } from "../../onboarding/onboarding-events-store.
 import {
   classifyKind,
   getAttachmentById,
-  getAttachmentMetadataForMessage,
+  getAttachmentMetadataForMessages,
   getAttachmentsByIds,
   resolveAttachmentsForPersist,
 } from "../../persistence/attachments-store.js";
@@ -132,6 +131,7 @@ import {
   isSuppressedQueuedMessage,
   isSystemCardMetadata,
   type MessageRow,
+  parseMessageMetadata,
   recordConversationPersistedSeq,
   setConversationInferenceProfile,
 } from "../../persistence/conversation-crud.js";
@@ -139,12 +139,18 @@ import {
   getConversationByKey,
   getOrCreateConversation,
 } from "../../persistence/conversation-key-store.js";
+import { listConversationModeSessionsByIds } from "../../persistence/conversation-mode-sessions.js";
 import { searchConversations } from "../../persistence/conversation-queries.js";
 import {
+  computerUseScreenshotAttachmentIdsFromMetadata,
   isNoResponseMetadata,
   messageMetadataIsAmbientSightKeep,
 } from "../../persistence/conversation-types.js";
 import { linkRequestLogsToMessage } from "../../persistence/llm-request-log-store.js";
+import {
+  mergeMessageMetadata,
+  readModeSessionMetadata,
+} from "../../persistence/message-metadata.js";
 import { assistantTextVisibilityOf } from "../../persistence/user-facing-content.js";
 import { MEMORY_RETROSPECTIVE_FORK_SOURCE } from "../../plugins/defaults/memory/memory-retrospective-constants.js";
 import { normalizeOnboardingContext } from "../../prompts/normalize-onboarding.js";
@@ -879,10 +885,31 @@ function displayRowFilter(conversationId: string): (m: MessageRow) => boolean {
 function consolidateDisplayTurns(rows: MessageRow[]): {
   messages: MessageRow[];
   mergedIdMap: Map<string, string[]>;
+  modeSessionActivityMap: Map<string, { firstAt: number; lastAt: number }>;
 } {
-  return mergeConsecutiveAssistantMessages(
-    mergeToolResultsIntoAssistantMessages(rows),
-  );
+  return consolidateMessageRows(rows);
+}
+
+const MAX_REQUESTED_MODE_SESSION_IDS = 100;
+const MAX_MODE_SESSION_ID_LENGTH = 200;
+
+function parseRequestedModeSessionIds(raw: unknown): string[] {
+  if (raw === undefined) {
+    return [];
+  }
+  if (typeof raw !== "string") {
+    throw new BadRequestError(
+      "modeSessionIds must be a comma-separated string",
+    );
+  }
+  const ids = [...new Set(raw.split(",").map((id) => id.trim()))];
+  if (
+    ids.length > MAX_REQUESTED_MODE_SESSION_IDS ||
+    ids.some((id) => id.length === 0 || id.length > MAX_MODE_SESSION_ID_LENGTH)
+  ) {
+    throw new BadRequestError("modeSessionIds contains an invalid session ID");
+  }
+  return ids;
 }
 
 export async function handleListMessages({
@@ -918,6 +945,9 @@ export async function handleListMessages({
   const beforeTimestampRaw = queryParams?.beforeTimestamp;
   const limitRaw = queryParams?.limit;
   const pageRaw = queryParams?.page;
+  const requestedModeSessionIds = parseRequestedModeSessionIds(
+    queryParams?.modeSessionIds,
+  );
 
   // Validate: reject NaN values with 400
   if (beforeTimestampRaw != null && isNaN(Number(beforeTimestampRaw))) {
@@ -1021,8 +1051,47 @@ export async function handleListMessages({
   // consolidation is deferred to compaction for prefix-cache stability.
   // Merge here at query time so renderHistoryContent produces the same
   // contentOrder shape as streaming (consecutive tool refs grouped together).
-  const { messages: consolidatedMessages, mergedIdMap } =
-    consolidateDisplayTurns(rawMessages);
+  const pageModeSessionIds = rawMessages.flatMap((message) => {
+    const owner = readModeSessionMetadata(message.metadata);
+    return owner ? [owner.id] : [];
+  });
+  const summaries = listConversationModeSessionsByIds(resolvedConversationId, [
+    ...new Set([...pageModeSessionIds, ...requestedModeSessionIds]),
+  ]);
+  const validOwners = new Map(
+    summaries.map((summary) => [summary.id, summary.mode]),
+  );
+  const projectionMessages = rawMessages.map((message) => {
+    const owner = readModeSessionMetadata(message.metadata);
+    if (!owner || validOwners.get(owner.id) === owner.mode) {
+      return message;
+    }
+    return {
+      ...message,
+      metadata: mergeMessageMetadata(message.metadata, {
+        modeSession: undefined,
+      }),
+    };
+  });
+  const {
+    messages: consolidatedMessages,
+    mergedIdMap,
+    modeSessionActivityMap,
+  } = consolidateDisplayTurns(projectionMessages);
+  const liveConversation = findConversation(resolvedConversationId);
+  const modeSessions = summaries
+    .filter(
+      (summary) =>
+        isModeSessionRecoveryHealthy() || summary.status !== "active",
+    )
+    .flatMap((summary) => {
+      const descriptor = liveConversation?.modeSessions
+        ? liveConversation.modeSessions.describeSummary(summary)
+        : summary.status !== "active"
+          ? { summary }
+          : undefined;
+      return descriptor ? [descriptor] : [];
+    });
   const assistantSlackDisplayName = getAssistantName()?.trim() || undefined;
 
   // Parse each row's stored content and per-message metadata. Rendering is
@@ -1150,6 +1219,7 @@ export async function handleListMessages({
       deletedAt,
       clientMessageId: msg.clientMessageId ?? undefined,
       assistantTextVisibility: assistantTextVisibilityOf(msg.metadata),
+      modeSession: readModeSessionMetadata(msg.metadata),
       // The row's raw stored envelope, carried to the render pass below so it
       // can read the row's own `assistantTextVisibility` marker. Never part of
       // the wire payload, which the serializer builds field by field.
@@ -1170,6 +1240,9 @@ export async function handleListMessages({
   const messages: RuntimeMessagePayload[] = await Promise.all(
     parsed.map(async (m) => {
       const mergedMessageIds = m.id ? (mergedIdMap.get(m.id) ?? []) : [];
+      const modeSessionActivity = m.id
+        ? modeSessionActivityMap.get(m.id)
+        : undefined;
 
       // Hydrate the row's attachments from the DB. A metadata-only query avoids
       // loading large base64 blobs for non-image attachments (documents, audio);
@@ -1180,9 +1253,21 @@ export async function handleListMessages({
       let msgAttachments: RuntimeAttachmentMetadata[] = [];
       if (m.id) {
         const idsToQuery = [m.id, ...mergedMessageIds];
-        const linked = idsToQuery.flatMap((id) =>
-          getAttachmentMetadataForMessage(id),
+        const linkedRows = getAttachmentMetadataForMessages(idsToQuery);
+        const computerUseScreenshotIds = new Set(
+          linkedRows.flatMap((row) =>
+            computerUseScreenshotAttachmentIdsFromMetadata(
+              parseMessageMetadata(row.messageMetadata),
+            ),
+          ),
         );
+        const linked = linkedRows.map((row) => {
+          return {
+            ...row.attachment,
+            computerUseScreenshot:
+              computerUseScreenshotIds.has(row.attachment.id) || undefined,
+          };
+        });
         if (linked.length > 0) {
           msgAttachments = await Promise.all(
             linked.map(async (a) => {
@@ -1221,6 +1306,9 @@ export async function handleListMessages({
                   ? { thumbnailData: a.thumbnailBase64 }
                   : {}),
                 fileBacked: true,
+                ...(a.computerUseScreenshot
+                  ? { computerUseScreenshot: true }
+                  : {}),
               };
             }),
           );
@@ -1333,6 +1421,8 @@ export async function handleListMessages({
       return {
         id: m.id ?? "",
         ...(mergedMessageIds.length > 0 ? { mergedMessageIds } : {}),
+        ...(m.modeSession ? { modeSession: m.modeSession } : {}),
+        ...(modeSessionActivity ? { modeSessionActivity } : {}),
         ...(m.clientMessageId ? { clientMessageId: m.clientMessageId } : {}),
         role: m.role,
         timestamp: new Date(displayTimestamp).toISOString(),
@@ -1422,6 +1512,7 @@ export async function handleListMessages({
         oldestMessageId: oldestMessageId ?? null,
         seq: persistedSeq,
         processing,
+        ...(modeSessions.length > 0 ? { modeSessions } : {}),
       };
     }
 
@@ -1432,10 +1523,16 @@ export async function handleListMessages({
       ...(oldestMessageId != null ? { oldestMessageId } : {}),
       seq: persistedSeq,
       processing,
+      ...(modeSessions.length > 0 ? { modeSessions } : {}),
     };
   }
 
-  return { messages, seq: persistedSeq, processing };
+  return {
+    messages,
+    seq: persistedSeq,
+    processing,
+    ...(modeSessions.length > 0 ? { modeSessions } : {}),
+  };
 }
 
 /**
@@ -2167,7 +2264,7 @@ export async function handleSendMessage(
           publishConversationMessagesChanged(conversationId, originClientId);
         },
         afterRelease: () => {
-          conversation.warmPromptCache();
+          void conversation.warmPromptCache();
         },
       });
 
@@ -3027,6 +3124,7 @@ export async function handleSendMessage(
           messageId,
           requestId,
           clientMessageId,
+          modeSession: conversation.modeSessions.getTurnOwner(requestId),
         });
         // The row this echo announces was durably persisted above, so advance
         // the snapshot↔stream anchor to the echo's seq (stamped inline by
@@ -3651,6 +3749,13 @@ export const ROUTES: RouteDefinition[] = [
         required: false,
         description: "Maximum number of messages to return.",
       },
+      {
+        name: "modeSessionIds",
+        type: "string",
+        required: false,
+        description:
+          "Comma-separated mode-session IDs to include with summaries for loaded active groups outside this page.",
+      },
     ],
     responseBody: z.object({
       messages: z
@@ -3685,6 +3790,12 @@ export const ROUTES: RouteDefinition[] = [
         .describe(
           "Whether the agent is currently mid-turn for this conversation, sourced authoritatively from the persisted `processing_started_at` column. `true` means a turn is in flight; `false` means the conversation is idle. Clients use this to recover from a dropped SSE stream: if a turn appears to be running locally but the server reports `processing: false`, the turn has ended (or died) and the UI should stop waiting rather than spin indefinitely. Absent on older daemons that predate this field.",
         ),
+      modeSessions: z
+        .array(ModeSessionDescriptorSchema)
+        .optional()
+        .describe(
+          "Conversation-owned mode-session summaries referenced by this page or explicitly requested by ID.",
+        ),
     }),
     handler: (args) => handleListMessages(args),
   },

package/src/runtime/routes/credential-prompt-routes.ts

@@ -177,13 +177,14 @@ async function handleCredentialPrompt({ body = {} }: RouteHandlerArgs) {
           expiresAt: result.collectionExpiresAt,
           service: validated.service,
           field: validated.field,
-          message: `This channel does not support secure input. The credential has NOT been stored yet. Share this one-time link with the user to collect it securely (single-use${expiresInMinutes ? `, expires in ${expiresInMinutes} minutes` : ""}): ${result.collectionUrl}`,
+          message: `${validated.conversationId ? "This channel does not support secure input." : "No conversation is attached to this invocation, so no secure prompt can be shown."} The credential has NOT been stored yet. Share this one-time link with the user to collect it securely (single-use${expiresInMinutes ? `, expires in ${expiresInMinutes} minutes` : ""}): ${result.collectionUrl}`,
         };
       }
       return {
         ok: false,
-        error:
-          "This conversation's channel does not support secure credential entry",
+        error: validated.conversationId
+          ? "This conversation's channel does not support secure credential entry"
+          : "No conversation is attached to this invocation, so no secure prompt can be shown, and a one-time collection link could not be created. Ask the user to add the credential in the app under Settings > Credentials. Never ask them to paste it into chat.",
       };
     }
     // An explicit user cancel is a valid flow, not a failure. Keep it distinct

package/src/runtime/routes/credential-routes.ts

@@ -607,8 +607,7 @@ async function handleCredentialsDelete({ body }: RouteHandlerArgs) {
 }
 
 async function handleCredentialsStatus() {
-  const info = await getActiveBackendInfoAsync();
-  return info;
+  return getActiveBackendInfoAsync();
 }
 
 // ---------------------------------------------------------------------------