@vellumai/assistant 0.6.0 → 0.6.2

package/src/providers/anthropic/client.ts

@@ -206,143 +206,6 @@ function hasOrderedToolResultPrefix(
  * regular content — they are self-paired within the assistant message and must
  * not be separated by the cross-message pairing logic.
  */
-
-/**
- * Expand collapsed multi-turn assistant messages. During agentic tool use, the
- * daemon stores multiple thinking→tool_use→tool_result cycles in a single
- * assistant message. The Anthropic API rejects thinking blocks between
- * tool_use blocks ("tool_use without tool_result immediately after") and
- * requires thinking blocks in the latest assistant message to remain exactly
- * as generated.
- *
- * This function splits collapsed messages at each "thinking/redacted_thinking
- * after tool_use" boundary, recreating the original multi-turn structure.
- * It also distributes tool_result blocks from the following user message to
- * match each segment's tool_use blocks, creating proper assistant→user pairs.
- */
-function expandCollapsedAssistantTurns(
-  messages: Anthropic.MessageParam[],
-): Anthropic.MessageParam[] {
-  const result: Anthropic.MessageParam[] = [];
-
-  for (let mi = 0; mi < messages.length; mi++) {
-    const msg = messages[mi];
-    if (msg.role !== "assistant") {
-      result.push(msg);
-      continue;
-    }
-
-    const content = Array.isArray(msg.content) ? msg.content : [];
-
-    // Check if this message has thinking blocks between tool_use blocks
-    let hasThinkingAfterToolUse = false;
-    let seenToolUse = false;
-    for (const block of content) {
-      if (isToolUseBlock(block)) {
-        seenToolUse = true;
-      } else if (seenToolUse) {
-        const type = (block as { type: string }).type;
-        if (type === "thinking" || type === "redacted_thinking") {
-          hasThinkingAfterToolUse = true;
-          break;
-        }
-      }
-    }
-
-    if (!hasThinkingAfterToolUse) {
-      result.push(msg);
-      continue;
-    }
-
-    // Split at each "thinking after tool_use" boundary into separate segments
-    const segments: Anthropic.ContentBlockParam[][] = [];
-    let current: Anthropic.ContentBlockParam[] = [];
-    let segmentHasToolUse = false;
-
-    for (const block of content) {
-      const type = (block as { type: string }).type;
-      const isThinking = type === "thinking" || type === "redacted_thinking";
-
-      if (isThinking && segmentHasToolUse) {
-        segments.push(current);
-        current = [block];
-        segmentHasToolUse = false;
-      } else {
-        current.push(block);
-        if (isToolUseBlock(block)) {
-          segmentHasToolUse = true;
-        }
-      }
-    }
-    if (current.length > 0) {
-      segments.push(current);
-    }
-
-    // Build a map of tool_results from the following user message (if any)
-    const nextMsg = messages[mi + 1];
-    const nextIsUser = nextMsg && nextMsg.role === "user";
-    const nextContent =
-      nextIsUser && Array.isArray(nextMsg.content) ? nextMsg.content : [];
-    const toolResultMap = new Map<string, Anthropic.ContentBlockParam>();
-    const nonToolResultContent: Anthropic.ContentBlockParam[] = [];
-    for (const block of nextContent) {
-      if (isToolResultBlock(block)) {
-        toolResultMap.set(block.tool_use_id, block);
-      } else {
-        nonToolResultContent.push(block);
-      }
-    }
-
-    // Emit each segment as assistant→user pairs, distributing tool_results
-    for (let si = 0; si < segments.length; si++) {
-      const segment = segments[si];
-      const segToolUseIds = getOrderedToolUseIds(segment);
-      const isLastSegment = si === segments.length - 1;
-
-      result.push({ role: "assistant" as const, content: segment });
-
-      if (segToolUseIds.length > 0 && !isLastSegment) {
-        // Intermediate segment: pair with matching tool_results
-        const segResults = segToolUseIds.map(
-          (id) => toolResultMap.get(id) ?? buildSyntheticToolResult(id),
-        );
-        // Remove matched results from the map
-        for (const id of segToolUseIds) toolResultMap.delete(id);
-        result.push({ role: "user" as const, content: segResults });
-      }
-    }
-
-    // For the last segment, let ensureToolPairing handle pairing with the
-    // (now reduced) user message. Rebuild the user message without the
-    // tool_results that were already distributed to intermediate segments.
-    if (nextIsUser) {
-      const remainingResults = Array.from(toolResultMap.values());
-      const rebuiltUserContent = [...remainingResults, ...nonToolResultContent];
-      // Replace the original user message with the rebuilt one. When all
-      // tool_results were distributed to intermediate segments (empty rebuilt
-      // content), skip the synthetic placeholder if the next message is already
-      // a user turn — ensureToolPairing will pair the last assistant segment
-      // with that next user message naturally.
-      if (rebuiltUserContent.length > 0) {
-        result.push({ role: "user" as const, content: rebuiltUserContent });
-      } else {
-        const nextAfterUser = messages[mi + 2];
-        if (!nextAfterUser || nextAfterUser.role !== "user") {
-          result.push({
-            role: "user" as const,
-            content: [
-              { type: "text" as const, text: SYNTHETIC_CONTINUATION_TEXT },
-            ],
-          });
-        }
-      }
-      mi++; // skip the original user message
-    }
-  }
-
-  return result;
-}
-
 function splitAssistantForToolPairing(content: Anthropic.ContentBlockParam[]): {
   pairedContent: Anthropic.ContentBlockParam[];
   carryoverContent: Anthropic.ContentBlockParam[];
@@ -716,6 +579,7 @@ export class AnthropicProvider implements Provider {
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const { config, onEvent, signal } = options ?? {};
+    const cacheTtl: "5m" | "1h" = ((config as Record<string, unknown> | undefined)?.cacheTtl as "5m" | "1h") ?? "1h";
     let sentMessages: Anthropic.MessageParam[] | undefined;
     try {
       const formatted = messages
@@ -819,58 +683,13 @@ export class AnthropicProvider implements Provider {
         }
       }
 
-      // Strip thinking/redacted_thinking blocks from historical assistant
-      // messages. These blocks carry cryptographic signatures tied to their
-      // original API response. Consolidated messages (from multi-step tool use)
-      // combine thinking blocks from different responses, making signature
-      // validation fail with "thinking blocks cannot be modified". Stripping is
-      // safe: the API allows it for all historical messages, and new responses
-      // generate fresh thinking blocks.
-      //
-      // The latest assistant turn is preserved: the API requires the most recent
-      // assistant message's thinking blocks to be passed back unmodified when
-      // sending tool results during in-progress tool-use loops.
-      let lastAssistantIdx = -1;
-      for (let i = formatted.length - 1; i >= 0; i--) {
-        if (formatted[i].role === "assistant") {
-          lastAssistantIdx = i;
-          break;
-        }
-      }
-      for (let i = 0; i < formatted.length; i++) {
-        const msg = formatted[i];
-        if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-        if (i === lastAssistantIdx) continue;
-        const stripped = msg.content.filter(
-          (b) =>
-            (b as { type: string }).type !== "thinking" &&
-            (b as { type: string }).type !== "redacted_thinking",
-        );
-        if (stripped.length < msg.content.length) {
-          // Ensure the message isn't empty after stripping
-          msg.content =
-            stripped.length > 0
-              ? stripped
-              : [
-                  {
-                    type: "text" as const,
-                    text: PLACEHOLDER_BLOCKS_OMITTED,
-                  },
-                ];
-        }
-      }
+      // Thinking blocks are stripped at rest by DB migration 209 so
+      // historical messages are clean when loaded. Within a turn,
+      // assistant messages have original thinking with valid signatures
+      // — the API accepts them. No provider-side stripping needed.
 
-      // Expand collapsed multi-turn assistant messages. When agentic tool use
-      // produces multiple thinking→tool_use cycles in a single stored message,
-      // the API rejects thinking blocks between tool_use blocks. Split such
-      // messages at each "thinking after tool_use" boundary to recreate the
-      // original multi-turn structure. With thinking blocks stripped above, the
-      // expansion is typically a no-op, but is kept as a safety net for edge
-      // cases where stripping is incomplete.
-      const expanded = expandCollapsedAssistantTurns(formatted);
-
-      sentMessages = ensureToolPairing(repairOrphanedServerToolUse(expanded));
-      const { effort, speed, output_config, ...restConfig } = (config ??
+      sentMessages = ensureToolPairing(repairOrphanedServerToolUse(formatted));
+      const { effort, speed, output_config, cacheTtl: _cacheTtl, ...restConfig } = (config ??
         {}) as Record<string, unknown> & {
         effort?: Anthropic.OutputConfig["effort"];
         speed?: "standard" | "fast";
@@ -914,12 +733,12 @@ export class AnthropicProvider implements Provider {
             {
               type: "text" as const,
               text: staticBlock,
-              cache_control: { type: "ephemeral" as const, ttl: "1h" as const },
+              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
             },
             {
               type: "text" as const,
               text: dynamicBlock,
-              cache_control: { type: "ephemeral" as const, ttl: "1h" as const },
+              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
             },
           ];
         } else {
@@ -927,7 +746,7 @@ export class AnthropicProvider implements Provider {
             {
               type: "text" as const,
               text: systemPrompt,
-              cache_control: { type: "ephemeral" as const, ttl: "1h" as const },
+              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
             },
           ];
         }
@@ -944,7 +763,12 @@ export class AnthropicProvider implements Provider {
             description: t.description,
             input_schema: t.input_schema as Anthropic.Tool["input_schema"],
             ...(i === otherTools.length - 1
-              ? { cache_control: { type: "ephemeral" as const, ttl: "1h" as const } }
+              ? {
+                  cache_control: {
+                    type: "ephemeral" as const,
+                    ttl: cacheTtl,
+                  },
+                }
               : {}),
           }));
           const webSearchTool: Anthropic.WebSearchTool20250305 = {
@@ -959,41 +783,98 @@ export class AnthropicProvider implements Provider {
             description: t.description,
             input_schema: t.input_schema as Anthropic.Tool["input_schema"],
             ...(i === tools.length - 1
-              ? { cache_control: { type: "ephemeral" as const, ttl: "1h" as const } }
+              ? {
+                  cache_control: {
+                    type: "ephemeral" as const,
+                    ttl: cacheTtl,
+                  },
+                }
               : {}),
           }));
         }
       }
 
-      // Place a cache breakpoint on the second-to-last user turn so the
-      // conversation prefix is cached between agent-loop iterations.
-      //
-      // Why second-to-last, not last?  The last user message is always new
-      // (either the initial message with fresh temporal context, or a tool
-      // result appended by the agent loop) so its breakpoint never produces
-      // a cache hit.  The second-to-last user turn is stable between
-      // iterations and caching up to it saves re-processing the full
-      // conversation prefix.
-      //
-      // We use only 1 user-turn breakpoint to stay within the Anthropic
-      // API limit of 4 cache_control blocks total:
-      //   system-static (1) + system-dynamic (2) + last-tool (3) + user (4)
-      const userIndices: number[] = [];
-      for (let i = 0; i < params.messages.length; i++) {
-        if (params.messages[i].role === "user") userIndices.push(i);
+      // Manual cache breakpoint on the turn-starting user message.
+      // This is the stable anchor for the current turn — everything up to
+      // and including it won't change during tool-use iterations, so a long
+      // TTL is appropriate. Walk backwards to find the last user message
+      // with a real text block (skipping tool_result-only messages and
+      // synthetic continuation placeholders injected by ensureToolPairing).
+      let turnStartIdx = -1;
+      for (let i = sentMessages.length - 1; i >= 0; i--) {
+        const msg = sentMessages[i];
+        if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+        const hasText = msg.content.some(
+          (b) =>
+            typeof b !== "string" &&
+            b.type === "text" &&
+            b.text !== SYNTHETIC_CONTINUATION_TEXT,
+        );
+        if (!hasText) continue;
+        const lastBlock = msg.content[msg.content.length - 1];
+        if (typeof lastBlock !== "string") {
+          (lastBlock as unknown as Record<string, unknown>).cache_control = {
+            type: "ephemeral",
+            ttl: cacheTtl,
+          };
+        }
+        turnStartIdx = i;
+        break;
       }
-      // slice(-2, -1) gives the second-to-last; empty array if < 2 user turns.
-      for (const idx of userIndices.slice(-2, -1)) {
-        const content = params.messages[idx].content;
-        if (Array.isArray(content) && content.length > 0) {
-          (
-            content[content.length - 1] as unknown as {
-              cache_control?: { type: string; ttl?: string };
+
+      // Advancing tail: place a short-lived 5m cache breakpoint on the last
+      // block of the last message when it falls after the turn-starting user
+      // message (i.e. tool-use loop content). This caches the growing tail
+      // cheaply without conflicting with the 1h breakpoints above.
+      // Skip thinking/redacted_thinking blocks — Anthropic doesn't allow
+      // cache_control on those types.
+      let tailBreakpointApplied = false;
+      if (turnStartIdx >= 0 && turnStartIdx < sentMessages.length - 1) {
+        const lastMsg = sentMessages[sentMessages.length - 1];
+        if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
+          const NON_CACHEABLE_TYPES = new Set(["thinking", "redacted_thinking"]);
+          let tailBlock: (typeof lastMsg.content)[number] | undefined;
+          for (let j = lastMsg.content.length - 1; j >= 0; j--) {
+            const block = lastMsg.content[j];
+            if (
+              typeof block !== "string" &&
+              !NON_CACHEABLE_TYPES.has((block as { type: string }).type)
+            ) {
+              tailBlock = block;
+              break;
             }
-          ).cache_control = { type: "ephemeral", ttl: "1h" };
+          }
+          if (tailBlock && typeof tailBlock !== "string") {
+            (tailBlock as unknown as Record<string, unknown>).cache_control = {
+              type: "ephemeral",
+              ttl: "5m",
+            };
+            tailBreakpointApplied = true;
+          }
         }
       }
 
+      // Enforce Anthropic API maximum of 4 cache_control blocks.
+      // When the system prompt boundary splits into 2 cached blocks AND
+      // tools + turn-start + advancing-tail breakpoints are all present,
+      // we'd have 5.  Drop the static system block's breakpoint — it's
+      // small (<1K tokens) so the re-read cost is negligible, while the
+      // dynamic block (workspace context) rarely changes mid-session and
+      // benefits more from caching.
+      const hasTailBreakpoint = tailBreakpointApplied;
+      const hasToolCacheBreakpoint =
+        params.tools?.some(
+          (t) => "cache_control" in t && t.cache_control != null,
+        ) ?? false;
+      if (
+        hasTailBreakpoint &&
+        Array.isArray(params.system) &&
+        params.system.length === 2 &&
+        hasToolCacheBreakpoint
+      ) {
+        delete (params.system[0] as unknown as Record<string, unknown>).cache_control;
+      }
+
       const { signal: timeoutSignal, cleanup: cleanupTimeout } =
         createStreamTimeout(this.streamTimeoutMs, signal);
 
@@ -1010,8 +891,7 @@ export class AnthropicProvider implements Provider {
       }
 
       // Fast mode: use the beta endpoint with speed: "fast" for Opus 4.6
-      const useFastMode =
-        speed === "fast" && effectiveModel.includes("opus");
+      const useFastMode = speed === "fast" && effectiveModel.includes("opus");
 
       // Collect required betas: extended cache TTL for 1h system prompt caching,
       // 1M context window, and fast-mode when applicable.
@@ -1198,6 +1078,14 @@ export class AnthropicProvider implements Provider {
             "Anthropic 400: tool_use/tool_result pairing error — dumping message structure",
           );
         }
+        log.error(
+          {
+            status: error.status,
+            message: error.message,
+            headers: Object.fromEntries(error.headers?.entries() ?? []),
+          },
+          `Anthropic API error (${error.status})`,
+        );
         const retryAfterMs = extractRetryAfterMs(error.headers);
         throw new ProviderError(
           `Anthropic API error (${error.status}): ${error.message}`,

package/src/runtime/assistant-event-hub.ts

@@ -156,6 +156,28 @@ export class AssistantEventHub {
     }
   }
 
+  /**
+   * Returns true when at least one active subscriber would receive the given
+   * event based on the same assistant/conversation matching rules as publish().
+   */
+  hasSubscribersForEvent(
+    event: Pick<AssistantEvent, "assistantId" | "conversationId">,
+  ): boolean {
+    for (const entry of this.subscribers) {
+      if (!entry.active) continue;
+      if (entry.filter.assistantId !== event.assistantId) continue;
+      if (
+        event.conversationId != null &&
+        entry.filter.conversationId != null &&
+        entry.filter.conversationId !== event.conversationId
+      ) {
+        continue;
+      }
+      return true;
+    }
+    return false;
+  }
+
   /** Number of currently active subscribers (useful for tests and caps). */
   subscriberCount(): number {
     return this.subscribers.size;

package/src/runtime/auth/route-policy.ts

@@ -130,6 +130,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "conversations", scopes: ["chat.read"] },
   { endpoint: "conversations:POST", scopes: ["chat.write"] },
   { endpoint: "conversations/fork", scopes: ["chat.write"] },
+  { endpoint: "conversations/analyze", scopes: ["chat.write"] },
   { endpoint: "conversations/switch", scopes: ["chat.write"] },
   { endpoint: "conversations/name", scopes: ["chat.write"] },
   { endpoint: "conversations/cancel", scopes: ["chat.write"] },
@@ -374,6 +375,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Message content
   { endpoint: "messages/content", scopes: ["chat.read"] },
   { endpoint: "messages/llm-context", scopes: ["chat.read"] },
+  { endpoint: "llm-request-logs/payload", scopes: ["chat.read"] },
   { endpoint: "messages/tts", scopes: ["chat.read"] },
 
   // Queued message deletion
@@ -479,6 +481,10 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Tools
   { endpoint: "tools", scopes: ["settings.read"] },
   { endpoint: "tools/simulate-permission", scopes: ["settings.read"] },
+
+  // Permission mode
+  { endpoint: "permission-mode:GET", scopes: ["settings.read"] },
+  { endpoint: "permission-mode", scopes: ["settings.write"] },
 ];
 
 for (const { endpoint, scopes } of ACTOR_ENDPOINTS) {
@@ -531,3 +537,20 @@ registerPolicy("admin/rollback-migrations", {
   requiredScopes: ["internal.write"],
   allowedPrincipalTypes: ["svc_gateway"],
 });
+
+// Profiler management: gateway-only control-plane endpoints
+registerPolicy("profiler/runs", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
+registerPolicy("profiler/runs/export", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
+// User-defined routes under /x/*
+registerPolicy("x", {
+  requiredScopes: ["settings.read"],
+  allowedPrincipalTypes: ["actor", "svc_gateway", "svc_daemon", "local"],
+});

package/src/runtime/auth/token-service.ts

@@ -171,6 +171,14 @@ export function isSigningKeyInitialized(): boolean {
   return _authSigningKey !== undefined;
 }
 
+/**
+ * Reset the signing key to undefined. **Test-only** — used to simulate a
+ * fresh CLI subprocess where initAuthSigningKey() was never called.
+ */
+export function _resetSigningKeyForTesting(): void {
+  _authSigningKey = undefined;
+}
+
 /**
  * Returns a short hex fingerprint of the current signing key.
  * Used by assistant_status to let clients detect instance switches.

package/src/runtime/http-server.ts

@@ -52,6 +52,7 @@ import { resolveConversationId } from "../memory/conversation-key-store.js";
 import {
   countConversations,
   listConversations,
+  listPinnedConversations,
 } from "../memory/conversation-queries.js";
 import type { ExternalConversationBinding } from "../memory/external-conversation-store.js";
 import * as externalConversationStore from "../memory/external-conversation-store.js";
@@ -126,6 +127,7 @@ import {
   contactCatchAllRouteDefinitions,
   contactRouteDefinitions,
 } from "./routes/contact-routes.js";
+import { conversationAnalysisRouteDefinitions } from "./routes/conversation-analysis-routes.js";
 import { conversationAttentionRouteDefinitions } from "./routes/conversation-attention-routes.js";
 import {
   type ConversationManagementDeps,
@@ -171,6 +173,7 @@ import {
   handlePairingStatus,
   pairingRouteDefinitions,
 } from "./routes/pairing-routes.js";
+import { profilerRouteDefinitions } from "./routes/profiler-routes.js";
 import { recordingRouteDefinitions } from "./routes/recording-routes.js";
 import { scheduleRouteDefinitions } from "./routes/schedule-routes.js";
 import { secretRouteDefinitions } from "./routes/secret-routes.js";
@@ -185,6 +188,7 @@ import { trustRulesRouteDefinitions } from "./routes/trust-rules-routes.js";
 import { ttsRouteDefinitions } from "./routes/tts-routes.js";
 import { upgradeBroadcastRouteDefinitions } from "./routes/upgrade-broadcast-routes.js";
 import { usageRouteDefinitions } from "./routes/usage-routes.js";
+import { userRouteDefinitions } from "./routes/user-routes.js";
 import { watchRouteDefinitions } from "./routes/watch-routes.js";
 import { workItemRouteDefinitions } from "./routes/work-items-routes.js";
 import { workspaceCommitRouteDefinitions } from "./routes/workspace-commit-routes.js";
@@ -826,6 +830,7 @@ export class RuntimeHttpServer {
       title: conversation.title ?? "Untitled",
       createdAt: conversation.createdAt,
       updatedAt: conversation.updatedAt,
+      lastMessageAt: conversation.lastMessageAt,
       conversationType: conversation.conversationType ?? "standard",
       source: conversation.source ?? "user",
       ...(conversation.scheduleJobId
@@ -961,6 +966,7 @@ export class RuntimeHttpServer {
       ...notificationRouteDefinitions(),
       ...diagnosticsRouteDefinitions(),
       ...logExportRouteDefinitions(),
+      ...profilerRouteDefinitions(),
       ...documentRouteDefinitions(),
       ...workItemRouteDefinitions(
         this.sendMessageDeps
@@ -1025,8 +1031,18 @@ export class RuntimeHttpServer {
           const offset = Number(url.searchParams.get("offset") ?? 0);
           const backgroundOnly =
             url.searchParams.get("conversationType") === "background";
-          const rows = listConversations(limit, backgroundOnly, offset);
+          let rows = listConversations(limit, backgroundOnly, offset);
           const totalCount = countConversations(backgroundOnly);
+          // On the first page, ensure all pinned conversations are included
+          // even if they fall outside the paginated window.
+          if (offset === 0 && !backgroundOnly) {
+            const pinned = listPinnedConversations();
+            const seen = new Set(rows.map((c) => c.id));
+            const missing = pinned.filter((c) => !seen.has(c.id));
+            if (missing.length > 0) {
+              rows = [...rows, ...missing];
+            }
+          }
           const conversationIds = rows.map((c) => c.id);
           const displayMeta = getDisplayMetaForConversations(conversationIds);
           const bindings =
@@ -1036,6 +1052,7 @@ export class RuntimeHttpServer {
           const attentionStates =
             getAttentionStateByConversationIds(conversationIds);
           const parentCache = new Map<string, ConversationRow | null>();
+          const nextOffset = offset + limit;
           const response: Record<string, unknown> = {
             conversations: rows.map((conversation) =>
               this.serializeConversationSummary({
@@ -1046,7 +1063,8 @@ export class RuntimeHttpServer {
                 parentCache,
               }),
             ),
-            hasMore: offset + rows.length < totalCount,
+            nextOffset,
+            hasMore: nextOffset < totalCount,
           };
           // Include groups array on first page only
           if (offset === 0) {
@@ -1067,6 +1085,14 @@ export class RuntimeHttpServer {
         ? conversationManagementRouteDefinitions(conversationManagementDeps)
         : []),
 
+      ...(this.sendMessageDeps
+        ? conversationAnalysisRouteDefinitions({
+            sendMessageDeps: this.sendMessageDeps,
+            buildConversationDetailResponse: (id) =>
+              this.buildConversationDetailResponse(id),
+          })
+        : []),
+
       ...groupRouteDefinitions(),
 
       {
@@ -1305,6 +1331,10 @@ export class RuntimeHttpServer {
       ...traceEventRouteDefinitions(),
       ...migrationRouteDefinitions(),
 
+      // User-defined routes under /x/* — must be LAST so built-in routes
+      // always take priority.
+      ...userRouteDefinitions(),
+
       // Internal OAuth callback (gateway -> runtime)
       {
         endpoint: "internal/oauth/callback",

package/src/runtime/http-types.ts

@@ -5,6 +5,7 @@ import type { ChannelId, InterfaceId } from "../channels/types.js";
 import type { CesClient } from "../credential-execution/client.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import type { ConversationCreateOptions } from "../daemon/handlers/shared.js";
 import type { SkillOperationContext } from "../daemon/handlers/skills.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type {
@@ -150,7 +151,10 @@ export type MessageProcessor = (
  * Hub publishing wires outbound events to the SSE stream.
  */
 export interface SendMessageDeps {
-  getOrCreateConversation: (conversationId: string) => Promise<Conversation>;
+  getOrCreateConversation: (
+    conversationId: string,
+    options?: ConversationCreateOptions,
+  ) => Promise<Conversation>;
   assistantEventHub: AssistantEventHub;
   resolveAttachments: (attachmentIds: string[]) => Array<{
     id: string;
@@ -274,4 +278,11 @@ export interface RuntimeMessagePayload {
   textSegments?: string[];
   thinkingSegments?: string[];
   contentOrder?: string[];
+  subagentNotification?: {
+    subagentId: string;
+    label: string;
+    status: string;
+    error?: string;
+    conversationId?: string;
+  };
 }