@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/runtime/routes/channel-send-routes.ts

@@ -0,0 +1,85 @@
+/**
+ * Route handler for a model-directed text send to a channel chat.
+ *
+ * POST /v1/channels/send: deliver text to a chat on a channel through the
+ * channel's transport, recorded after acknowledgement. The
+ * messaging tool's channel branch runs the same function in-process; this
+ * route is the door for the CLI and scripts, so the two doors share one
+ * seam and one record.
+ */
+
+import { z } from "zod";
+
+import { CHANNEL_IDS } from "../../channels/types.js";
+import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import {
+  ChannelNotAddressableError,
+  ChannelSendFailedError,
+  sendChannelText,
+} from "../channel-send.js";
+import { BadGatewayError, BadRequestError } from "./errors.js";
+import { parseBody } from "./parse-body.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const ProactiveTargetSchema = z.object({
+  kind: z.literal("chat"),
+  chatId: z.string().min(1).describe("Chat id in the channel's own id space"),
+  threadId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Thread within the chat, in the channel's own id space"),
+});
+
+const ChannelSendRequestSchema = z.object({
+  channel: z.enum(CHANNEL_IDS).describe("Channel to send on"),
+  target: ProactiveTargetSchema,
+  text: z.string().min(1).describe("Text to send"),
+  renderRichly: z
+    .boolean()
+    .optional()
+    .describe("Ask the channel for its rich rendering, where it has one"),
+});
+
+const ChannelSendResponseSchema = z.object({
+  channel: z.enum(CHANNEL_IDS),
+  chatId: z.string(),
+  threadId: z.string().optional(),
+  messageIds: z.array(z.string()),
+  lastMessageId: z.string(),
+  recordedIn: z.string().optional(),
+});
+
+async function handleChannelSend({ body }: RouteHandlerArgs) {
+  const request = parseBody(ChannelSendRequestSchema, body);
+  try {
+    return await sendChannelText(request);
+  } catch (e) {
+    if (e instanceof ChannelNotAddressableError) {
+      throw new BadRequestError(e.message);
+    }
+    if (e instanceof ChannelSendFailedError) {
+      throw new BadGatewayError(e.message);
+    }
+    throw e;
+  }
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "channels_send_post",
+    endpoint: "channels/send",
+    method: "POST",
+    policy: {
+      requiredScopes: ["chat.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Send text to a channel chat",
+    description:
+      "Deliver text to a chat on a channel through the channel's transport, recorded after the channel acknowledges it.",
+    tags: ["channels"],
+    handler: handleChannelSend,
+    requestBody: ChannelSendRequestSchema,
+    responseBody: ChannelSendResponseSchema,
+  },
+];

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

@@ -14,6 +14,7 @@ import { z } from "zod";
 
 import { CHANNEL_IDS } from "../../channels/types.js";
 import { isAssistantInitiatedThreadsEnabled } from "../../config/assistant-initiated-threads-gate.js";
+import { localeFromAcceptLanguage } from "../../i18n/index.js";
 import { channelBindingSchema } from "../../messaging/channel-binding-schema.js";
 import {
   type Confidence,
@@ -244,7 +245,10 @@ function parseEnumQueryParam<const T extends readonly string[]>(
   );
 }
 
-function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
+function handleListConversations({
+  queryParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const limit = Number(queryParams.limit ?? 50);
   const offset = Number(queryParams.offset ?? 0);
   // "background" is the back-compat umbrella (background + scheduled); newer
@@ -365,6 +369,7 @@ function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
         // Checks in-memory flag first (hot path), falls back to the
         // persisted `processing_started_at` column for cold conversations.
         isProcessing: isConversationProcessing(conversation.id),
+        locale: localeFromAcceptLanguage(headers?.["accept-language"]),
       }),
     ),
     nextOffset,
@@ -579,8 +584,14 @@ function handleMarkUnread({ body = {}, headers }: RouteHandlerArgs) {
   }
 }
 
-function handleGetConversation({ pathParams = {} }: RouteHandlerArgs) {
-  const detail = buildConversationDetailResponse(pathParams.id!);
+function handleGetConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
+  const detail = buildConversationDetailResponse(
+    pathParams.id!,
+    localeFromAcceptLanguage(headers?.["accept-language"]),
+  );
   if (!detail) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }

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

@@ -29,6 +29,7 @@ import {
   LatencyBreakdownSchema,
   LLMRequestLogEntrySchema,
 } from "../../api/responses/llm-request-log-entry.js";
+import { scrubNulledAcpAgentLeaves } from "../../config/acp-agent-write.js";
 import {
   catalogEntryFor,
   type InputModalities,
@@ -92,6 +93,7 @@ import {
   log,
 } from "../../daemon/handlers/shared.js";
 import { rescheduleHeartbeatIfTimezoneChanged } from "../../heartbeat/heartbeat-service.js";
+import { overlayWorkspaceMcpForConfigRead } from "../../mcp/workspace-mcp-config.js";
 import {
   getAssistantMessageIdsInTurn,
   getConversation,
@@ -687,6 +689,38 @@ function rejectMcpTransportHeaderWrite(patch: unknown): void {
   );
 }
 
+const MCP_CONFIG_WRITE_MESSAGE =
+  "MCP servers are stored in mcp.json. Use assistant mcp add or assistant mcp remove.";
+
+function stripMcpFromConfigWrite(patch: Record<string, unknown>): void {
+  if (Object.hasOwn(patch, "mcp")) {
+    delete patch.mcp;
+  }
+}
+
+function rejectMcpConfigSetPath(path: string, value: unknown): void {
+  if (path !== "mcp" && !path.startsWith("mcp.")) {
+    return;
+  }
+  const relative =
+    path === "mcp" ? value : nestPath(path.slice("mcp.".length), value);
+  if (patchContainsMcpTransportHeaders({ mcp: relative })) {
+    throw new BadRequestError(
+      "MCP authentication headers must be managed through MCP server add/update APIs, not generic config writes.",
+    );
+  }
+  throw new BadRequestError(MCP_CONFIG_WRITE_MESSAGE);
+}
+
+function nestPath(path: string, value: unknown): unknown {
+  const segments = path.split(".");
+  let current: unknown = value;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    current = { [segments[i]!]: current };
+  }
+  return current;
+}
+
 const WireProfileEntry = ProfileEntry.extend({
   supportsVision: z.boolean().optional(),
   invariant: z.boolean().optional(),
@@ -893,6 +927,7 @@ const ConfigPatchRequestSchema = z
 function handleGetConfig() {
   try {
     const config = applyContextDefaultsToRawConfig(loadRawConfig());
+    overlayWorkspaceMcpForConfigRead(config);
     sanitizeMcpTransportHeadersForSettingsRead(config);
     overlayEffectiveProfilesForWire(config);
     enrichProfilesForWire(config);
@@ -1594,6 +1629,7 @@ async function handlePatchConfig({ body }: RouteHandlerArgs) {
   normalizeManagedProfileWrites(body);
   rejectManagedProfileDeletion(body as Record<string, unknown>);
   rejectMcpTransportHeaderWrite(body);
+  stripMcpFromConfigWrite(body as Record<string, unknown>);
 
   const raw = loadRawConfig();
   const patch = body as Record<string, unknown>;
@@ -1603,11 +1639,13 @@ async function handlePatchConfig({ body }: RouteHandlerArgs) {
   }
   deepMergeOverwrite(raw, patch);
   scrubRemovedServiceModes(raw);
+  scrubNulledAcpAgentLeaves(raw);
   seedSttProviderForSparseBlock(raw);
 
   await commitConfigWrite(raw, "patch");
 
   const merged = applyContextDefaultsToRawConfig(loadRawConfig());
+  overlayWorkspaceMcpForConfigRead(merged);
   sanitizeMcpTransportHeadersForSettingsRead(merged);
   overlayEffectiveProfilesForWire(merged);
   enrichProfilesForWire(merged);
@@ -1670,6 +1708,7 @@ async function handleSetConfig({ body }: RouteHandlerArgs) {
   stripWireOnlyProfileKeys(patchShape);
   normalizeManagedProfileWrites(patchShape);
   rejectManagedProfileDeletion(patchShape);
+  rejectMcpConfigSetPath(path, value);
   rejectMcpTransportHeaderWrite(patchShape);
 
   const raw = loadRawConfig();
@@ -1708,6 +1747,7 @@ async function handleSetConfig({ body }: RouteHandlerArgs) {
       written.source = "managed";
     }
   }
+  scrubNulledAcpAgentLeaves(raw);
   // A SET can create `services.stt` with a leaf like `language` and no
   // `provider`, which SttServiceSchema requires whenever the block exists;
   // the same seeding that guards PATCH keeps this write's persisted block

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

@@ -140,7 +140,10 @@ import {
   getOrCreateConversation,
 } from "../../persistence/conversation-key-store.js";
 import { searchConversations } from "../../persistence/conversation-queries.js";
-import { isNoResponseMetadata } from "../../persistence/conversation-types.js";
+import {
+  isNoResponseMetadata,
+  messageMetadataIsAmbientSightKeep,
+} from "../../persistence/conversation-types.js";
 import { linkRequestLogsToMessage } from "../../persistence/llm-request-log-store.js";
 import { assistantTextVisibilityOf } from "../../persistence/user-facing-content.js";
 import { MEMORY_RETROSPECTIVE_FORK_SOURCE } from "../../plugins/defaults/memory/memory-retrospective-constants.js";
@@ -159,6 +162,7 @@ import {
   getWorkspaceDir,
   getWorkspacePromptPath,
 } from "../../util/platform.js";
+import { safeStringSlice } from "../../util/unicode.js";
 import { assistantEventHub, broadcastMessage } from "../assistant-event-hub.js";
 import { getCurrentSeq } from "../assistant-stream-state.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
@@ -1037,6 +1041,9 @@ export async function handleListMessages({
     let backgroundToolCompletion: ConversationMessage["backgroundToolCompletion"];
     let systemCard: boolean | undefined;
     let noResponse: boolean | undefined;
+    const cameraFrame = messageMetadataIsAmbientSightKeep(msg.metadata)
+      ? true
+      : undefined;
     let reaction: ConversationMessage["reaction"];
     let providerError: ConversationMessage["providerError"];
     let deletedAt: number | undefined;
@@ -1136,6 +1143,7 @@ export async function handleListMessages({
       backgroundToolCompletion,
       systemCard,
       noResponse,
+      cameraFrame,
       reaction,
       providerError,
       slackMessage,
@@ -1353,6 +1361,7 @@ export async function handleListMessages({
           : {}),
         ...(m.systemCard ? { systemCard: true } : {}),
         ...(m.noResponse ? { noResponse: true } : {}),
+        ...(m.cameraFrame ? { cameraFrame: true as const } : {}),
         // The row's own marker, so a client gates per-row presentation on what
         // this row was written with rather than on the live flag.
         ...(m.assistantTextVisibility
@@ -3289,11 +3298,15 @@ async function generateLlmSuggestion(
 ): Promise<string | null> {
   const log = (await import("../../util/logger.js")).getLogger("runtime-http");
   const truncatedAssistant = escapeXmlContent(
-    assistantText.length > 2000 ? assistantText.slice(-2000) : assistantText,
+    assistantText.length > 2000
+      ? safeStringSlice(assistantText, assistantText.length - 2000)
+      : assistantText,
   );
   const truncatedUser =
     priorUserText && priorUserText.length > 500
-      ? escapeXmlContent(priorUserText.slice(-500))
+      ? escapeXmlContent(
+          safeStringSlice(priorUserText, priorUserText.length - 500),
+        )
       : priorUserText
         ? escapeXmlContent(priorUserText)
         : priorUserText;

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

@@ -34,7 +34,6 @@ import { credentialKey } from "../../security/credential-key.js";
 import {
   deleteSecureKeyAsync,
   getActiveBackendInfoAsync,
-  getSecureKeyAsync,
   getSecureKeyResultAsync,
 } from "../../security/secure-keys.js";
 import {
@@ -43,7 +42,7 @@ import {
   deleteCredentialMetadata,
   getCredentialMetadata,
   getCredentialMetadataById,
-  listCredentialMetadata,
+  listCredentialRecordsLive,
 } from "../../tools/credentials/metadata-store.js";
 import type { CredentialInjectionTemplate } from "../../tools/credentials/policy-types.js";
 import {
@@ -228,6 +227,9 @@ function assertNotPlatformManaged(
   }
 }
 
+const CREDENTIAL_STORE_UNREACHABLE =
+  "Credential store is unreachable. Retry in a moment, or check that the credential vault is running.";
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -235,9 +237,14 @@ function assertNotPlatformManaged(
 async function handleCredentialsList({ body }: RouteHandlerArgs) {
   const search = (body as { search?: string } | undefined)?.search;
 
+  const live = await listCredentialRecordsLive();
+  if (live.unreachable) {
+    throw new InternalError(CREDENTIAL_STORE_UNREACHABLE);
+  }
+
   // Platform-provisioned credentials are not the user's to act on, so they
   // never become a Settings row (and never a click-to-reveal).
-  let allMetadata = listCredentialMetadata().filter(
+  let allMetadata = live.records.filter(
     (m) => !isPlatformManagedCredential(m.service, m.field),
   );
 
@@ -272,7 +279,12 @@ async function handleCredentialsList({ body }: RouteHandlerArgs) {
 
   const credentials = await Promise.all(
     allMetadata.map(async (m) => {
-      const secret = await getSecureKeyAsync(credentialKey(m.service, m.field));
+      const { value: secret, unreachable } = await getSecureKeyResultAsync(
+        credentialKey(m.service, m.field),
+      );
+      if (unreachable) {
+        throw new InternalError(CREDENTIAL_STORE_UNREACHABLE);
+      }
       const connection = connectionsByProvider.get(m.service);
       return buildCredentialOutput(m, secret, connection);
     }),
@@ -310,9 +322,7 @@ async function handleCredentialsInspect({ body }: RouteHandlerArgs) {
 
   if (!lookup.metadata && (secret == null || secret.length === 0)) {
     if (unreachable) {
-      throw new InternalError(
-        "Credential store is unreachable — ensure the assistant is running",
-      );
+      throw new InternalError(CREDENTIAL_STORE_UNREACHABLE);
     }
     throw new BadRequestError("Credential not found");
   }
@@ -374,9 +384,7 @@ async function handleCredentialsReveal({ body, headers }: RouteHandlerArgs) {
 
   if (secret == null || secret.length === 0) {
     if (unreachable) {
-      throw new InternalError(
-        "Credential store is unreachable — ensure the assistant is running",
-      );
+      throw new InternalError(CREDENTIAL_STORE_UNREACHABLE);
     }
     throw new BadRequestError("Credential not found");
   }
@@ -552,9 +560,7 @@ async function handleCredentialsDelete({ body }: RouteHandlerArgs) {
 
   const key = credentialKey(service, field);
   const affectedConnections = assertCredentialNotInUse(key, force === true);
-  const existing = await getSecureKeyAsync(key);
-  const deleteResult =
-    existing != null ? await deleteSecureKeyAsync(key) : "not-found";
+  const deleteResult = await deleteSecureKeyAsync(key);
 
   if (deleteResult === "error") {
     throw new InternalError(
@@ -620,7 +626,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "List all credentials with metadata",
     description:
-      "Return all stored credentials with metadata, OAuth connection info, and platform-managed credentials.",
+      "Return credentials from the live credential vault, with OAuth connection info and platform-managed credentials. Fails if the vault is unreachable.",
     tags: ["credentials"],
     requestBody: z.object({
       search: z.string().optional().describe("Filter by substring match"),

package/src/runtime/routes/desktop-setup-routes.test.ts

@@ -0,0 +1,74 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
+import { ROUTES } from "./desktop-setup-routes.js";
+import { NotFoundError } from "./errors.js";
+
+const originalContainerized = process.env.IS_CONTAINERIZED;
+const status = spyOn(desktopDependencyInstaller, "getStatus");
+const start = spyOn(desktopDependencyInstaller, "start");
+
+afterAll(() => {
+  status.mockRestore();
+  start.mockRestore();
+});
+
+beforeEach(() => {
+  process.env.IS_CONTAINERIZED = "true";
+  status.mockReturnValue({ state: "required" });
+  start.mockReturnValue({ state: "installing", stage: "packages" });
+});
+
+afterEach(() => {
+  if (originalContainerized === undefined) {
+    delete process.env.IS_CONTAINERIZED;
+  } else {
+    process.env.IS_CONTAINERIZED = originalContainerized;
+  }
+  setOverridesForTesting({});
+  status.mockClear();
+  start.mockClear();
+});
+
+describe("desktop setup route feature gate", () => {
+  for (const route of ROUTES) {
+    for (const flag of [false, undefined]) {
+      test(`${route.method} refuses a disabled or missing flag (${flag}) without touching setup`, () => {
+        setOverridesForTesting(
+          flag === undefined ? {} : { "assistant-desktop": flag },
+        );
+        expect(() => route.handler({})).toThrow(NotFoundError);
+        expect(status).not.toHaveBeenCalled();
+        expect(start).not.toHaveBeenCalled();
+      });
+    }
+
+    test(`${route.method} refuses non-containerized assistants even with the flag enabled`, () => {
+      process.env.IS_CONTAINERIZED = "false";
+      setOverridesForTesting({ "assistant-desktop": true });
+      expect(() => route.handler({})).toThrow(NotFoundError);
+      expect(status).not.toHaveBeenCalled();
+      expect(start).not.toHaveBeenCalled();
+    });
+
+    test(`${route.method} serves setup only with the flag enabled in a container`, () => {
+      setOverridesForTesting({ "assistant-desktop": true });
+      expect(route.handler({})).toEqual(
+        route.method === "GET"
+          ? { state: "required" }
+          : { state: "installing", stage: "packages" },
+      );
+      expect(route.method === "GET" ? status : start).toHaveBeenCalledTimes(1);
+      expect(route.method === "GET" ? start : status).not.toHaveBeenCalled();
+    });
+  }
+});

package/src/runtime/routes/desktop-setup-routes.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+import { getConfig } from "../../config/loader.js";
+import { desktopDependencyInstaller } from "../../desktop/desktop-dependencies.js";
+import { isAssistantDesktopEnabled } from "../../desktop/desktop-feature.js";
+import { GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
+import { NotFoundError } from "./errors.js";
+import type { RouteDefinition } from "./types.js";
+
+const statusSchema = z.object({
+  state: z.enum(["required", "installing", "ready", "failed", "unsupported"]),
+  stage: z.enum(["packages", "chrome", "checking"]).optional(),
+});
+
+export const ROUTES: RouteDefinition[] = ["GET", "POST"].map((method) => ({
+  operationId:
+    method === "GET" ? "desktop_setup_status" : "desktop_setup_install",
+  endpoint: "desktop/setup",
+  method,
+  policy: { requiredScopes: [], allowedPrincipalTypes: GATEWAY_PRINCIPALS },
+  handler: () => {
+    if (!isAssistantDesktopEnabled(getConfig())) {
+      throw new NotFoundError("Desktop is not available on this assistant");
+    }
+    return method === "GET"
+      ? desktopDependencyInstaller.getStatus()
+      : desktopDependencyInstaller.start();
+  },
+  summary:
+    method === "GET"
+      ? "Get desktop setup status"
+      : "Install desktop components",
+  tags: ["desktop"],
+  responseBody: statusSchema,
+}));

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

@@ -22,7 +22,9 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../providers/provider-send-message.js";
+import { isMaxTokensStopReason } from "../../providers/stop-reasons.js";
 import { getLogger } from "../../util/logger.js";
+import { safeStringSlice } from "../../util/unicode.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -48,7 +50,11 @@ function sanitizeWindowTitle(title: string | undefined): string {
   if (!title) {
     return "";
   }
-  return title.replace(/[<>]/g, "").slice(0, MAX_WINDOW_TITLE_LENGTH);
+  return safeStringSlice(
+    title.replace(/[<>]/g, ""),
+    0,
+    MAX_WINDOW_TITLE_LENGTH,
+  );
 }
 
 interface DictationBody {
@@ -176,9 +182,44 @@ function buildCommandPrompt(body: DictationBody, stylePrompt?: string): string {
   return sections.join("\n");
 }
 
-function computeMaxTokens(inputLength: number): number {
+export function computeMaxTokens(inputLength: number): number {
   const estimatedInputTokens = Math.ceil(inputLength / 3);
-  return Math.max(256, estimatedInputTokens + 128);
+  // The cleanup tool call carries the whole transcript back in its `text`
+  // argument, plus a `reasoning` string and the JSON scaffolding around both,
+  // so the budget has to cover well more than the input alone. `max_tokens` is
+  // a ceiling rather than a target: a call that stops short of it costs no
+  // extra latency.
+  return Math.max(512, estimatedInputTokens * 2 + 256);
+}
+
+export type CleanupRejection = "truncated";
+
+/**
+ * Decide whether the cleanup model's rewrite is safe to use as the payload.
+ *
+ * The rewrite replaces what the user actually said. A token-cap stop means the
+ * tool JSON was cut mid-argument, so however complete the `text` argument
+ * happens to look, it is a fragment; the raw transcript is the safer payload
+ * then. Unpolished beats wrong.
+ *
+ * Whether a shorter rewrite still preserved the meaning is the model's call
+ * (the prompt asks it to drop fillers and tighten phrasing), so there is no
+ * length check here: a deterministic ratio cannot tell a concise cleanup from
+ * a summary.
+ */
+export function resolveCleanedDictation(
+  raw: string,
+  cleaned: string,
+  stopReason: string | null | undefined,
+): { text: string; rejected: CleanupRejection | null } {
+  const trimmed = cleaned.trim();
+  if (!trimmed) {
+    return { text: raw, rejected: null };
+  }
+  if (isMaxTokensStopReason(stopReason)) {
+    return { text: raw, rejected: "truncated" };
+  }
+  return { text: trimmed, rejected: null };
 }
 
 interface DictationResult {
@@ -329,7 +370,23 @@ async function handleDictation(body: DictationBody): Promise<DictationResult> {
             ...profileMeta,
           };
         }
-        const cleanedText = input.text?.trim() || transcription;
+        const { text: cleanedText, rejected } = resolveCleanedDictation(
+          transcription,
+          input.text ?? "",
+          response.stopReason,
+        );
+        if (rejected) {
+          // Lengths only -- transcript content must never be logged.
+          log.warn(
+            {
+              rejected,
+              stopReason: response.stopReason,
+              rawChars: transcription.length,
+              cleanedChars: input.text?.trim().length ?? 0,
+            },
+            "Dictation cleanup rejected, using raw transcription",
+          );
+        }
         const normalizedText = applyDictionary(cleanedText, profile.dictionary);
         return {
           text: normalizedText,

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

@@ -445,6 +445,10 @@ export function handleSubscribeAssistantEvents(
                 ? ["host_cu_window_capture" as const]
                 : []),
               ...(interfaceId === "macos" &&
+              headers?.["x-vellum-cu-sequence"] === "1"
+                ? ["host_cu_sequence" as const]
+                : []),
+              ...(interfaceId === "macos" &&
               headers?.["x-vellum-cu-annotate"] === "1"
                 ? ["host_cu_annotate" as const]
                 : []),

package/src/runtime/routes/host-cu-routes.ts

@@ -36,6 +36,10 @@ const HostCuResultBodySchema = z.object({
   executionError: z.string().optional(),
   secondaryWindows: z.string().optional(),
   userGuidance: z.string().optional(),
+  timings: z
+    .record(z.string(), z.number())
+    .describe("Per-phase helper timings in milliseconds")
+    .optional(),
 });
 
 // ---------------------------------------------------------------------------
@@ -56,6 +60,7 @@ async function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
     executionError,
     secondaryWindows,
     userGuidance,
+    timings,
   } = parseBody(HostCuResultBodySchema, body);
 
   const peeked = pendingInteractions.get(requestId);
@@ -119,6 +124,7 @@ async function handleHostCuResult({ body, headers }: RouteHandlerArgs) {
     executionError,
     secondaryWindows,
     userGuidance,
+    timings,
   });
 
   return { accepted: true };

package/src/runtime/routes/index.ts

@@ -39,6 +39,7 @@ import { ROUTES as CALL_ROUTES } from "./call-routes.js";
 import { ROUTES as CHANNEL_AVAILABILITY_ROUTES } from "./channel-availability-routes.js";
 import { ROUTES as CHANNEL_READINESS_ROUTES } from "./channel-readiness-routes.js";
 import { CHANNEL_ROUTES } from "./channel-route-definitions.js";
+import { ROUTES as CHANNEL_SEND_ROUTES } from "./channel-send-routes.js";
 import { ROUTES as CHANNEL_VERIFICATION_ROUTES } from "./channel-verification-routes.js";
 import { ROUTES as CHATGPT_SUBSCRIPTION_AUTH_ROUTES } from "./chatgpt-subscription-auth-routes.js";
 import { ROUTES as CLIENT_ROUTES } from "./client-routes.js";
@@ -58,10 +59,10 @@ import { ROUTES as CONVERSATIONS_IMPORT_ROUTES } from "./conversations-import-ro
 import { ROUTES as CREDENTIAL_PROMPT_ROUTES } from "./credential-prompt-routes.js";
 import { ROUTES as CREDENTIAL_REQUEST_ROUTES } from "./credential-request-routes.js";
 import { ROUTES as CREDENTIAL_ROUTES } from "./credential-routes.js";
-import { ROUTES as DEBUG_BASH_ROUTES } from "./debug-bash-routes.js";
 import { ROUTES as DEBUG_ROUTES } from "./debug-routes.js";
 import { ROUTES as DEFAULT_PROVIDER_ROUTES } from "./default-provider-routes.js";
 import { ROUTES as DEFER_ROUTES } from "./defer-routes.js";
+import { ROUTES as DESKTOP_SETUP_ROUTES } from "./desktop-setup-routes.js";
 import { ROUTES as DIAGNOSTICS_ROUTES } from "./diagnostics-routes.js";
 import { ROUTES as DISK_PRESSURE_ROUTES } from "./disk-pressure-routes.js";
 import { ROUTES as DOCUMENT_COMMENT_ROUTES } from "./document-comments-routes.js";
@@ -191,6 +192,7 @@ export const ROUTES: RouteDefinition[] = [
   ...CHANNEL_VERIFICATION_ROUTES,
   ...CHANNEL_AVAILABILITY_ROUTES,
   ...CHANNEL_READINESS_ROUTES,
+  ...CHANNEL_SEND_ROUTES,
   ...BROWSER_ROUTES,
   ...BROWSER_TABS_ROUTES,
   ...BTW_ROUTES,
@@ -215,9 +217,9 @@ export const ROUTES: RouteDefinition[] = [
   ...CONVERSATION_QUERY_ROUTES,
   ...CONVERSATION_STARTER_ROUTES,
   ...ACTIVATION_ROUTES,
-  ...DEBUG_BASH_ROUTES,
   ...DEBUG_ROUTES,
   ...DEFAULT_PROVIDER_ROUTES,
+  ...DESKTOP_SETUP_ROUTES,
   ...DIAGNOSTICS_ROUTES,
   ...DISK_PRESSURE_ROUTES,
   ...RESOURCE_PRESSURE_ROUTES,