@k2b/cloud 0.6.0-rc.0 → 0.7.0

package/src/ai/client/controller.ts

@@ -4,6 +4,7 @@ import { type AiAttachmentRef, aiAttachmentMarker } from "../attachments";
 import { type AiStreamEvent, type AiTurnBlock, type AiTurnSnapshot, steerMessageBlockId } from "../protocol";
 import { type AiResourceMarker, aiResourceMarker } from "../resource-markers";
 import type {
+  AiClientToolId,
   AiConversation,
   AiConversationTimelineEntry,
   AiDraftContentPart,
@@ -18,6 +19,7 @@ import {
   activeTurnFromSnapshot,
   emptyProjection,
   mergeActiveTurn,
+  messagesWithPendingSend,
   reconcileActiveTurnActions,
   reduceProjection,
   visibleMessages,
@@ -25,6 +27,10 @@ import {
 import { type AiConversationStreamTransport, type AiStreamHandle, aiSseConversationStreamTransport } from "./transport";
 
 type ComposerDraftInput = {
+  draftContent?: AiDraftContentPart[];
+  /** Bind local content to the server draft it was actually based on. */
+  conversationId?: string;
+  expectedDraftRevision?: number;
   message?: string;
   content?: AiUserContentPart[];
   files?: File[];
@@ -36,6 +42,7 @@ export type AiChatRunStatus = "idle" | "streaming" | "waiting_for_action" | "sto
 export type AiStreamStatus = "idle" | "connecting" | "open" | "reconnecting";
 
 export type AiFrontendToolHandler = (request: {
+  conversationId: string;
   name: string;
   callId: string;
   args: unknown;
@@ -99,6 +106,8 @@ export type CreateAiChatControllerOptions = {
   /** Persist owner read state for conversation-list unread indicators. */
   trackViewedState?: boolean;
   frontendTools?: Record<string, AiFrontendToolHandler>;
+  /** Explicitly advertise only client tools with a connected handler. */
+  clientToolIds?: AiClientToolId[];
   /** Overrides the default SSE transport, for example with a shared WebSocket channel. */
   streamTransport?: AiConversationStreamTransport;
 };
@@ -141,6 +150,13 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const [streamStatus, setStreamStatus] = createSignal<AiStreamStatus>("idle");
   const initialProjection = options.initialDetail ? detailToProjection(options.initialDetail) : emptyProjection();
   const [state, setState] = createStore<AiChatProjection>(initialProjection);
+  const completedDuringSend = new Map<string, string>();
+  const [pendingSends, setPendingSends] = createSignal<Record<string, AiStoredMessage | undefined>>({});
+  const clearPendingSend = (conversationId: string) => setPendingSends(current => {
+    const next = { ...current };
+    delete next[conversationId];
+    return next;
+  });
 
   // Cache of projections for conversations opened this session (fast switching).
   const cache = new Map<string, AiChatProjection>();
@@ -207,7 +223,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const error = () => globalError() ?? runError();
 
   const activeTurn = () => state.activeTurn;
-  const messages = createMemo(() => visibleMessages(state));
+  const messages = createMemo(() => messagesWithPendingSend(visibleMessages(state), pendingSends()[activeConversationId() ?? ""]));
   const runStatus = (): AiChatRunStatus => {
     const override = runStatusRaw();
     if (override) return override;
@@ -226,6 +242,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     const next = reduceProjection({ conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn }, event);
     setState(reconcile(next, { key: "id", merge: true }));
     cache.set(conversationId, next);
+    if (event.type === "turn_finished" && pendingSends()[conversationId]?.loopId === event.turnId) clearPendingSend(conversationId);
   };
 
   /**
@@ -241,6 +258,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       setProjection(detailToProjection(detail), session.conversationId);
       setHasMore(session.conversationId, detail.hasMoreMessages ?? false);
       if (detail.timeline) setTimeline(session.conversationId, detail.timeline);
+      if (event.type === "turn_finished" && pendingSends()[session.conversationId]?.loopId === event.turnId) clearPendingSend(session.conversationId);
     } else reduceEvent(session.conversationId, event);
     setRunStatusRaw(null);
     void markConversationViewed(session.conversationId);
@@ -249,6 +267,9 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const applyEvent = (session: AiStreamSession, event: AiStreamEvent) => {
     if (!isCurrentStreamSession(streamSession, session)) return;
     const conversationId = session.conversationId;
+    if (event.type === "turn_finished" && pendingSends()[conversationId]) {
+      completedDuringSend.set(conversationId, event.turnId);
+    }
 
     if (event.type === "state") setHasMore(conversationId, event.hasMoreMessages ?? false);
     const nextRunError = runErrorFromEvent(event, state.activeTurn?.turnId);
@@ -265,7 +286,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
 
     reduceEvent(conversationId, event);
     if (event.type === "state" && loadingConversationId() === conversationId) setLoadingConversationId(null);
-    if (runStatusRaw() && runStatusRaw() !== "stopping") setRunStatusRaw(null);
+    if (runStatusRaw() && (runStatusRaw() !== "stopping" || !state.activeTurn)) setRunStatusRaw(null);
 
     if (event.type === "turn_finished") {
       setRunStatusRaw(null);
@@ -338,7 +359,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       return false;
     }
     try {
-      const result = await handler({ name, callId, args, turnId });
+      const result = await handler({ name, callId, args, turnId, conversationId });
       return submitTurnActionForConversation(conversationId, turnId, callId, { type: "tool_result", result });
     } catch (toolError) {
       return submitTurnActionForConversation(conversationId, turnId, callId, {
@@ -394,6 +415,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     };
     cache.set(conversationId, next);
     setState(reconcile(next, { key: "id", merge: true }));
+    if (!next.activeTurn && runStatusRaw() === "stopping") setRunStatusRaw(null);
   };
 
   const openConversation = async (conversationId: string) => {
@@ -436,15 +458,25 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     return generation === conversationOpenGeneration ? ("failed" as const) : ("stale" as const);
   };
 
+  let conversationRefreshGeneration = 0;
   const refreshActiveConversation = async (): Promise<void> => {
     const conversationId = activeConversationId();
     if (!conversationId) return;
+    const refreshGeneration = ++conversationRefreshGeneration;
+    const openGeneration = conversationOpenGeneration;
     const detail = await request<AiConversationDetail>(
       `/conversations/${conversationId}`,
       { method: "GET" },
       "Failed to refresh conversation",
     );
-    if (!isActiveConversation(conversationId)) return;
+    if (
+      !isActiveConversation(conversationId) ||
+      refreshGeneration !== conversationRefreshGeneration ||
+      openGeneration !== conversationOpenGeneration
+    )
+      return;
+    const currentDraft = state.conversation?.draft;
+    if (currentDraft && currentDraft.revision > detail.conversation.draft.revision) detail.conversation.draft = currentDraft;
     const windowOldest = detail.messages[0]?.seq;
     const preservedOlder = windowOldest === undefined ? [] : state.messages.filter((message) => message.seq < windowOldest);
     setProjection({ ...detailToProjection(detail), messages: [...preservedOlder, ...detail.messages] }, conversationId);
@@ -653,7 +685,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       }
     }
     const content: AiDraftContentPart[] = [
-      ...textParts,
+      ...(input.draftContent ?? textParts),
       ...(input.resources ?? []).map((resource) => ({ type: "resource" as const, ...resource })),
       ...(input.storedFiles ?? []).map((file) => ({ type: "file" as const, ...file })),
       ...uploaded.map((file) => ({ type: "file" as const, ...file })),
@@ -661,10 +693,14 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     try {
       const draft = await request<AiConversation["draft"]>(
         `/conversations/${conversationId}/draft`,
-        { method: "PUT", body: JSON.stringify({ expectedRevision: conversation.draft.revision, content }) },
+        { method: "PUT", body: JSON.stringify({ expectedRevision: input.expectedDraftRevision ?? conversation.draft.revision, content }) },
         "Failed to save conversation draft",
       );
-      const nextConversation = { ...conversation, draft };
+      const current = isActiveConversation(conversationId) ? state.conversation : cache.get(conversationId)?.conversation;
+      const nextConversation = {
+        ...(current ?? conversation),
+        draft: current && current.draft.revision > draft.revision ? current.draft : draft,
+      };
       const projection = isActiveConversation(conversationId)
         ? { conversation: nextConversation, messages: state.messages, activeTurn: state.activeTurn }
         : { ...(cache.get(conversationId) ?? emptyProjection(nextConversation)), conversation: nextConversation };
@@ -687,36 +723,56 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   };
 
   const saveDraft = (input: ComposerDraftInput) => {
-    const targetConversation = ensureConversation();
+    const targetConversation = input.conversationId ? Promise.resolve(input.conversationId) : ensureConversation();
     return queueDraftOperation(async () => persistComposerDraft(input, await targetConversation));
   };
 
+  const queuedAttempts = new Map<string, {key:string;files?:File[];id:string;saved:{revision:number}}>();
+  const queueMessage = (input: ComposerDraftInput & { modelProfileId?: string }): Promise<boolean> => {
+    if (!input.conversationId || !isComposerDraftSendable(input)) return Promise.resolve(false);
+    const conversationId = input.conversationId;
+    const key = JSON.stringify({message:input.message,content:input.content,draftContent:input.draftContent,resources:input.resources,storedFiles:input.storedFiles,model:input.modelProfileId});
+    return queueDraftOperation(async () => {
+      try {
+        const previous = queuedAttempts.get(conversationId);
+        const same = previous?.key === key && (previous.files ?? []).length === (input.files ?? []).length && (previous.files ?? []).every((file,index)=>file === input.files?.[index]);
+        const saved = same ? previous.saved : await persistComposerDraft(input, conversationId);
+        if (!saved) return false;
+        const queueId = same ? previous.id : crypto.randomUUID();
+        queuedAttempts.set(conversationId,{key,files:input.files,id:queueId,saved});
+        await request(`/conversations/${conversationId}/turns`, {method:"POST", body:JSON.stringify({
+          draftRevision:saved.revision, queueId, modelProfileId:input.modelProfileId,
+          clientToolIds:options.clientToolIds?.filter(id => options.frontendTools?.[id]),
+        })}, "Failed to queue message");
+        if (isActiveConversation(conversationId)) {
+          if ((state.conversation?.draft.revision ?? 0) <= saved.revision) setState("conversation", "draft", {content:[],revision:saved.revision+1,updatedAt:new Date().toISOString()});
+        } else invalidateInactiveCache(conversationId);
+        queuedAttempts.delete(conversationId);
+        if (isActiveConversation(conversationId)) setGlobalError(null);
+        return true;
+      } catch (error) {
+        setConversationError(conversationId,error instanceof Error ? error.message : "Failed to queue message");
+        return false;
+      }
+    });
+  };
+
   const send = (input: ComposerDraftInput & { modelProfileId?: string }): Promise<boolean> => {
     if (!isComposerDraftSendable(input)) return Promise.resolve(false);
-    const targetConversation = ensureConversation();
+    const targetConversation = input.conversationId ? Promise.resolve(input.conversationId) : ensureConversation();
     return queueDraftOperation(async () => {
-      const savedDraft = await persistComposerDraft(input, await targetConversation);
-      if (!savedDraft) return false;
-      const conversationId = savedDraft.conversationId;
-      if (isActiveConversation(conversationId) && running()) return false;
-
+      const conversationId = await targetConversation;
+      if (!conversationId || (isActiveConversation(conversationId) && running())) return false;
       if (isActiveConversation(conversationId)) clearErrors();
       const baseProjection = isActiveConversation(conversationId)
         ? { conversation: state.conversation, messages: [...state.messages], activeTurn: state.activeTurn }
         : (cache.get(conversationId) ?? emptyProjection());
-
-      // Optimistic view renders attachments through the same marker format the server persists.
       const optimisticContent: AiUserContentPart[] = [
-        ...savedDraft.content.flatMap((part) => {
-          if (part.type === "text") return [{ type: "text" as const, text: part.text }];
-          if (part.type === "file") return [{ type: "text" as const, text: aiAttachmentMarker(part) }];
-          return [
-            {
-              type: "text" as const,
-              text: aiResourceMarker({ ref: part.ref, title: part.title, icon: part.icon, href: part.href }),
-            },
-          ];
-        }),
+        ...(input.content ?? []),
+        ...(!input.content?.length && input.message ? [{ type: "text" as const, text: input.message }] : []),
+        ...(input.resources ?? []).map(ref => ({ type: "text" as const, text: aiResourceMarker(ref) })),
+        ...(input.storedFiles ?? []).map(file => ({ type: "text" as const, text: aiAttachmentMarker(file) })),
+        ...(input.files ?? []).map(file => ({ type: "text" as const, text: aiAttachmentMarker({ path: `/${file.name}`, mediaType: file.type, size: file.size }) })),
       ];
 
       // Optimistic: show the user message immediately.
@@ -738,39 +794,55 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
         meta: null,
         createdAt: new Date().toISOString(),
       };
-      const optimisticProjection = { ...baseProjection, messages: [...baseProjection.messages, optimistic] };
-      cache.set(conversationId, optimisticProjection);
+      setPendingSends(current => ({ ...current, [conversationId]: optimistic }));
       if (isActiveConversation(conversationId)) {
-        setState("messages", (prev) => [...prev, optimistic]);
         setRunStatusRaw("streaming");
       }
 
       try {
+        const savedDraft = await persistComposerDraft(input, conversationId);
+        if (!savedDraft) {
+          clearPendingSend(conversationId);
+          if (isActiveConversation(conversationId)) setRunStatusRaw("failed");
+          return false;
+        }
+        setPendingSends(current => ({ ...current, [conversationId]: {
+          ...optimistic,
+          meta: { submittedDraftRevision: savedDraft.revision },
+          message: { role: "user", content: savedDraft.content.map(part => ({
+            type: "text", text: part.type === "text" ? part.text : part.type === "file" ? aiAttachmentMarker(part) : part.type === "project-file" ? `Project file: ${part.path}` : aiResourceMarker({ ref: part.ref, title: part.title, icon: part.icon, href: part.href }),
+          })) },
+        } }));
         const result = await request<SubmitTurnResult>(
           `/conversations/${conversationId}/turns`,
           {
             method: "POST",
             body: JSON.stringify({
               draftRevision: savedDraft.revision,
+              clientToolIds: options.clientToolIds?.filter((id) => options.frontendTools?.[id]),
               modelProfileId: input.modelProfileId,
             }),
           },
           "AI request failed",
         );
+        const alreadyFinished = completedDuringSend.get(conversationId) === result.turn.id;
+        completedDuringSend.delete(conversationId);
+        if (alreadyFinished) clearPendingSend(conversationId);
+        else setPendingSends(current => ({ ...current, [conversationId]: result.message }));
         if (invalidateInactiveCache(conversationId)) return true;
         // Replace the optimistic message with the persisted one.
-        setState("messages", (prev) => prev.map((message) => (message.id === optimistic.id ? result.message : message)));
+        setState("messages", (prev) => [...prev.filter(message => message.id !== result.message.id), result.message]);
         setState(
           "activeTurn",
           (current) =>
-            current ?? {
+            current ?? (alreadyFinished ? null : {
               turnId: result.turn.id,
               attempt: 0,
               seq: 0,
               status: "running",
               blocks: [],
               modelProfileId: result.turn.modelProfileId,
-            },
+            }),
         );
         if (state.conversation) {
           setState("conversation", "draft", {
@@ -787,6 +859,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
         }
         return true;
       } catch (sendError) {
+        completedDuringSend.delete(conversationId);
+        clearPendingSend(conversationId);
         if (invalidateInactiveCache(conversationId)) return false;
         setState("messages", (prev) => prev.filter((message) => message.id !== optimistic.id));
         cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
@@ -1157,6 +1231,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     conversation: () => state.conversation,
     setActiveConversationId,
     messages,
+    /** Includes persisted model rounds still represented by live blocks in the timeline. */
+    usageMessages: () => state.messages,
     activeTurn,
     hasMoreHistory,
     loadingOlder: () => isActiveConversationLoading(activeConversationId(), loadingOlderConversationId()),
@@ -1175,6 +1251,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     refreshActiveConversation,
     createConversation,
     saveDraft,
+    queueMessage,
     send,
     steer,
     retrySteer,
@@ -1194,7 +1271,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
 export type AiChatController = ReturnType<typeof createAiChatController>;
 
 const isComposerDraftSendable = (input: ComposerDraftInput): boolean =>
-  Boolean(input.message?.trim() || input.content?.length || input.files?.length || input.resources?.length || input.storedFiles?.length);
+  Boolean(input.draftContent?.length || input.message?.trim() || input.content?.length || input.files?.length || input.resources?.length || input.storedFiles?.length);
 
 export const __aiControllerTest = {
   claimFrontendCall,

package/src/ai/client/file-source.ts

@@ -30,7 +30,7 @@ const bytesToBase64 = (bytes: Uint8Array): string => {
   return btoa(binary);
 };
 
-export const conversationFileSource = (baseUrl: string, conversationId: string): FileSource => {
+export const conversationFileSource = (baseUrl: string, conversationId: string): FileSource & { listFiles(): Promise<AiFileStat[]> } => {
   const filesUrl = (suffix = "", params?: Record<string, string>) => {
     const query = params ? `?${new URLSearchParams(params).toString()}` : "";
     return `${baseUrl}/conversations/${conversationId}/files${suffix}${query}`;
@@ -45,15 +45,19 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
     return (await response.json()) as T;
   };
 
+  const listFiles = async (): Promise<AiFileStat[]> =>
+    (await request<{ files: AiFileStat[] }>(filesUrl(), { method: "GET" }, "Failed to load files")).files;
+
   return {
+    previewPreferencesKey: "assistant.csv-preview",
+    listFiles,
     async list(): Promise<FileTreeEntry[]> {
-      const result = await request<{ files: AiFileStat[] }>(filesUrl(), { method: "GET" }, "Failed to load files");
-      return result.files.map((file) => ({
+      return (await listFiles()).map((file) => ({
         path: file.path,
         size: file.size,
         mediaType: file.mediaType,
         updatedAt: file.updatedAt,
-        badge: file.origin === "user" ? "upload" : undefined,
+        badge: file.dictationRecordedAt ? undefined : file.origin === "user" ? "upload" : undefined,
       }));
     },
 
@@ -62,7 +66,8 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
       if (!response.ok) throw new Error(await readError(response, "Failed to load file"));
       const mediaType = response.headers.get("Content-Type")?.split(";")[0]?.trim() || "application/octet-stream";
       const bytes = new Uint8Array(await response.arrayBuffer());
-      return isTextMediaType(mediaType)
+      const delimited = /\.(csv|tsv)$/i.test(path) || mediaType === "text/csv" || mediaType === "text/tab-separated-values";
+      return isTextMediaType(mediaType) && !delimited
         ? { encoding: "utf8", content: new TextDecoder().decode(bytes), mediaType }
         : { encoding: "base64", content: bytesToBase64(bytes), mediaType };
     },
@@ -79,10 +84,11 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
       await request(filesUrl("/rename"), { method: "POST", body: JSON.stringify({ from, to }) }, "Failed to rename file");
     },
 
-    async upload(_dirPath, files) {
+    async upload(dirPath, files) {
       for (const file of files) {
         const form = new FormData();
         form.append("file", file);
+        form.append("directory", dirPath);
         const response = await fetch(filesUrl(), { method: "POST", body: form });
         if (!response.ok) throw new Error(await readError(response, `Failed to upload ${file.name}`));
       }

package/src/ai/client/live-connection.ts

@@ -63,6 +63,7 @@ export const createAiLiveConnection = (options: CreateAiLiveConnectionOptions):
 
   socket = createLiveWebSocket<AiLiveServerMessage>({
     url: options.url ?? "/api/ai/live",
+    activity: "always",
     initialCursor: options.initialCursor,
     subscribe: (cursor) => ({
       type: AI_LIVE_WS_TYPE.subscribe,

package/src/ai/client/projection.ts

@@ -23,6 +23,15 @@ export const emptyProjection = (conversation: AiConversation | null = null): AiC
   activeTurn: null,
 });
 
+/** A local send is an overlay, never part of a replaceable server snapshot. */
+export const messagesWithPendingSend = (messages: AiStoredMessage[], pending?: AiStoredMessage): AiStoredMessage[] => {
+  if (!pending) return messages;
+  const revision = pending.meta?.submittedDraftRevision;
+  const confirmed = messages.some(message => message.id === pending.id ||
+    (revision !== undefined && message.message.role === "user" && message.meta?.submittedDraftRevision === revision));
+  return confirmed ? messages : [...messages, pending];
+};
+
 const mergeMessages = (existing: AiStoredMessage[], incoming: AiStoredMessage[]): AiStoredMessage[] => {
   if (incoming.length === 0) return existing;
   const byId = new Map(existing.map((message) => [message.id, message]));
@@ -69,19 +78,16 @@ const normalizeCustomApprovalBlocks = (blocks: AiTurnBlock[]): AiTurnBlock[] =>
   return normalized;
 };
 
-/** Never let a same-turn DB/SSE snapshot remove blocks the browser already observed. */
+/** A complete snapshot replaces its baseline; stale snapshots cannot resurrect old block IDs. */
 export const mergeActiveTurn = (previous: AiActiveTurn | null, incoming: AiActiveTurn | null): AiActiveTurn | null => {
   if (!previous || !incoming || previous.turnId !== incoming.turnId) return incoming;
   if (previous.attempt !== incoming.attempt) return incoming.attempt > previous.attempt ? incoming : previous;
-
-  const incomingIsNewer = incoming.seq >= previous.seq;
-  const blocks = incomingIsNewer ? overlayBlocks(previous.blocks, incoming.blocks) : overlayBlocks(incoming.blocks, previous.blocks);
-  return {
-    ...(incomingIsNewer ? incoming : previous),
-    seq: Math.max(previous.seq, incoming.seq),
-    blocks,
-    status: deriveStatus(blocks),
-  };
+  if (incoming.seq < previous.seq) return previous;
+  // Locally submitted steering may not have reached the snapshot yet.
+  const pendingSteers = previous.blocks.filter(block => block.kind === "steer_message" && block.status !== "consumed");
+  const known = new Set(incoming.blocks.map(block => block.id));
+  const blocks = [...incoming.blocks, ...pendingSteers.filter(block => !known.has(block.id))];
+  return { ...incoming, blocks, status: deriveStatus(blocks) };
 };
 
 export const reconcileActiveTurnActions = (
@@ -141,7 +147,7 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
   const active = state.activeTurn;
 
   if (event.type === "turn_started") {
-    if (active && active.turnId === event.turnId && event.attempt < active.attempt) return state;
+    if (active && active.turnId === event.turnId && !isNewerWireEvent(event, active)) return state;
     const pendingSteers =
       active?.turnId === event.turnId ? active.blocks.filter((block) => block.kind === "steer_message" && block.status !== "consumed") : [];
     const blocks = event.blocks ? overlayBlocks(normalizeCustomApprovalBlocks(event.blocks), pendingSteers) : pendingSteers;
@@ -163,6 +169,11 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
     return { ...state, messages: mergeMessages(state.messages, event.messages ?? []), activeTurn: null };
   }
 
+  if (event.type === "message_saved") {
+    if (!active || active.turnId !== event.turnId || !isNewerWireEvent(event, active)) return state;
+    return { ...state, messages: mergeMessages(state.messages, [event.message]), activeTurn: { ...active, seq: event.seq, attempt: event.attempt } };
+  }
+
   // block_set / block_delta
   if (!active || active.turnId !== event.turnId) return state;
   if (!isNewerWireEvent(event, active)) return state;

package/src/ai/client/transport.ts

@@ -21,6 +21,9 @@ const CONNECT_TIMEOUT_MS = 10_000;
 export async function* parseAiSse(response: Response, signal: AbortSignal): AsyncGenerator<AiStreamEvent> {
   const reader = response.body?.getReader();
   if (!reader) return;
+  const cancel = () => { void reader.cancel().catch(() => undefined); };
+  signal.addEventListener("abort", cancel, {once:true});
+  if (signal.aborted) cancel();
   const decoder = new TextDecoder();
   let buffer = "";
   try {
@@ -40,6 +43,7 @@ export async function* parseAiSse(response: Response, signal: AbortSignal): Asyn
       }
     }
   } finally {
+    signal.removeEventListener("abort", cancel);
     await reader.cancel().catch(() => undefined);
   }
 }

package/src/ai/code-capability-routes.ts

@@ -0,0 +1,110 @@
+import { type Context, Hono } from "hono";
+import { z } from "zod";
+import { readBoundedJson } from "../_internal/bounded-json";
+import { dispatchCapability } from "../api/capabilities";
+import { dispatchCapabilityStream } from "../api/capability-streams";
+import { CAPABILITY_MAX_REQUEST_BYTES } from "../contracts/capabilities";
+import { type AuthContext, getLocale, type RequestAuthority } from "../server";
+import { requireInvocation } from "../server/middleware/invocation";
+import { codeCapabilityOperation } from "./code-capability-transport";
+import { aiConversations } from "./store";
+
+const Input = z
+  .object({ input: z.unknown() })
+  .strict()
+  .refine((value) => Object.hasOwn(value, "input"));
+const denied = () => Response.json({ code: "ACCESS_DENIED", message: "Code execution is no longer authorized" }, { status: 403 });
+
+/** Core-only continuation of a foreground code turn, not a general invocation exchange. */
+export function createCodeCapabilityRoutes(
+  dependencies: {
+    invocation?: Parameters<typeof requireInvocation>[1];
+    store?: Pick<typeof aiConversations, "getConversation" | "getActiveTurn" | "getTurnRunConfig">;
+    dispatch?: typeof dispatchCapability;
+    stream?: typeof dispatchCapabilityStream;
+  } = {},
+) {
+  const store = dependencies.store ?? aiConversations;
+  // This Core-only exchange resumes the verified foreground user turn. Ordinary
+  // app invocations remain non-exchangeable; this is not an interactive cookie.
+  const foregroundTurnAuthority = (c: Context<AuthContext>): RequestAuthority => ({
+    actor: c.get("actor"),
+    accessSubject: c.get("accessSubject"),
+    credentialKind: "session",
+    scopes: [],
+  });
+  const invoke = async (c: Context<AuthContext>, review = false) => {
+    const body = await readBoundedJson(c.req.raw, CAPABILITY_MAX_REQUEST_BYTES);
+    const input = body.ok ? Input.safeParse(body.data) : null;
+    if (!input?.success) return Response.json({ code: "VALIDATION_FAILED", message: "Invalid capability input" }, { status: 400 });
+    const conversation = await store.getConversation({ conversationId: c.req.param("conversationId")! });
+    const appId = c.req.param("appId")!;
+    const capabilityId = c.req.param("capabilityId")!;
+    if (conversation?.allowedTools && !conversation.allowedTools.includes(`${appId}.${capabilityId}`)) return denied();
+    return (dependencies.dispatch ?? dispatchCapability)({
+      request: c.req.raw,
+      authority: foregroundTurnAuthority(c),
+      origin: "assistant",
+      continuation: codeCapabilityOperation(c.req.param("conversationId")!, c.req.param("turnId")!),
+      review,
+      kind: review || c.req.param("kind") === "actions" ? "actions" : "queries",
+      appId,
+      capabilityId,
+      input: input.data.input,
+      locale: getLocale(c),
+    });
+  };
+  return new Hono<AuthContext>()
+    .use("/:conversationId/:turnId/*", async (c, next) => {
+      await next();
+      c.header("Cache-Control", "no-store");
+    })
+    .use(
+      "/:conversationId/:turnId/*",
+      requireInvocation((c) => {
+        const conversationId = z.uuid().safeParse(c.req.param("conversationId"));
+        const turnId = z.uuid().safeParse(c.req.param("turnId"));
+        return conversationId.success && turnId.success
+          ? { targetAppId: "core", operation: codeCapabilityOperation(conversationId.data, turnId.data), schemaHash: null }
+          : null;
+      }, dependencies.invocation),
+    )
+    .use("/:conversationId/:turnId/*", async (c, next) => {
+      const actor = c.get("actor");
+      if (actor.kind !== "user" || actor.delegation?.callingAppId !== "assistant" || actor.delegation.credentialKind !== "session")
+        return denied();
+      const conversationId = c.req.param("conversationId")!;
+      const turnId = c.req.param("turnId")!;
+      const [conversation, active, config] = await Promise.all([
+        store.getConversation({ conversationId, ownerUserId: actor.user.id }),
+        store.getActiveTurn({ conversationId }),
+        store.getTurnRunConfig({ conversationId, turnId }),
+      ]);
+      if (
+        !conversation ||
+        conversation.createdByUserId !== actor.user.id ||
+        conversation.archivedAt ||
+        !active ||
+        active.turn.id !== turnId ||
+        active.turn.cancelRequestedAt ||
+        !["running", "waiting_for_action"].includes(active.turn.status) ||
+        !config ||
+        config.kind === "compact" ||
+        config.background ||
+        config.mandate
+      )
+        return denied();
+      await next();
+    })
+    .post("/:conversationId/:turnId/capabilities/v1/actions/:appId/:capabilityId/review", (c) => invoke(c, true))
+    .post("/:conversationId/:turnId/capabilities/v1/:kind{queries|actions}/:appId/:capabilityId", (c) => invoke(c))
+    .post("/:conversationId/:turnId/capabilities/v1/streams/:verb", (c) =>
+      (dependencies.stream ?? dispatchCapabilityStream)(c.req.raw, foregroundTurnAuthority(c), c.req.param("verb"), {
+        continuation: codeCapabilityOperation(c.req.param("conversationId")!, c.req.param("turnId")!),
+        allow: async ({ appId, capabilityId }) => {
+          const conversation = await store.getConversation({ conversationId: c.req.param("conversationId")! });
+          return !!conversation && (!conversation.allowedTools || conversation.allowedTools.includes(`${appId}.${capabilityId}`));
+        },
+      }),
+    );
+}

package/src/ai/code-capability-transport.ts

@@ -0,0 +1,38 @@
+import type { CapabilityCaller } from "../capabilities/server";
+
+export const CODE_CAPABILITY_TOKEN_HEADER = "x-cloud-code-capability-token";
+export const codeCapabilityOperation = (conversationId: string, turnId: string) => `code-capabilities:${conversationId}:${turnId}`;
+export const codeCapabilityPath = (conversationId: string, turnId: string) => `/api/_internal/ai/code/${conversationId}/${turnId}`;
+
+/** Framework-owned callback; tokens stay in the host, never the sandbox or tool arguments. */
+export function createCodeCapabilityTransport(
+  current: () => { conversationId: string; turnId: string; token: string },
+): NonNullable<CapabilityCaller["transport"]> {
+  const configured = process.env.CLOUD_CORE_INTERNAL_ORIGIN;
+  if (!configured) throw new Error("CLOUD_CORE_INTERNAL_ORIGIN is required for the code host");
+  const origin = new URL(configured);
+  if (!["http:", "https:"].includes(origin.protocol)) throw new Error("Invalid Core origin");
+  return async (request) => {
+    const target = new URL(origin);
+    const context = current();
+    if (!context.token) throw new Error("Code capability authority is unavailable");
+    const source = new URL(request.url);
+    if (!source.pathname.startsWith("/api/capabilities/v1/")) throw new Error("Invalid code capability route");
+    target.pathname = codeCapabilityPath(context.conversationId, context.turnId) + source.pathname.slice("/api".length);
+    target.search = "";
+    const headers = new Headers(request.headers);
+    headers.delete("cookie");
+    headers.set("authorization", `Bearer ${context.token}`);
+    return fetch(
+      new Request(target, {
+        method: request.method,
+        headers,
+        body: request.body,
+        signal: request.signal,
+        redirect: "error",
+        // @ts-expect-error Streaming server request bodies require duplex.
+        duplex: request.body ? "half" : undefined,
+      }),
+    );
+  };
+}