@vellumai/assistant 0.6.0 → 0.6.1

package/src/prompts/templates/UPDATES.md

@@ -28,3 +28,11 @@ If your user finds proactive check-ins unwanted, they can disable it by setting
 The default checklist focuses on your user relationship, not generic tasks like weather or news. You can customize it by editing HEARTBEAT.md in your workspace.
 <!-- /vellum-update-release:heartbeat-default -->
 
+<!-- vellum-update-release:corrupted-attachment-cleanup -->
+## Corrupted image attachments cleaned up
+
+Some Slack image attachments were stored incorrectly due to a missing OAuth scope — the files contained error pages instead of actual image data. This caused conversations with those images to fail with "The AI provider rejected the request" on every subsequent message.
+
+This has been fixed automatically: the corrupted attachments were removed from affected conversations during this update, and the OAuth scope issue has been resolved so new image uploads work correctly. If your user mentions missing images from earlier conversations, this is why — the images were never successfully received in the first place.
+<!-- /vellum-update-release:corrupted-attachment-cleanup -->
+

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/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/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;
+  };
 }