@k2b/cloud 0.25.0 → 0.27.0

package/src/ai/client/controller.ts

@@ -2,7 +2,7 @@ import { type Accessor, createMemo, createSignal, onCleanup } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
 import { type AiAttachmentRef, aiAttachmentMarker } from "../attachments";
 import { aiChatMessages } from "../chat/messages";
-import { type AiStreamEvent, type AiTurnBlock, type AiTurnSnapshot, steerMessageBlockId } from "../protocol";
+import { AI_TURN_LEASE_MS, type AiStreamEvent, type AiTurnBlock, type AiTurnSnapshot, steerMessageBlockId } from "../protocol";
 import { type AiResourceMarker, aiResourceMarker } from "../resource-markers";
 import type {
   AiClientToolId,
@@ -201,6 +201,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const abortRequests = new Map<string, Promise<boolean>>();
   let stream: AiStreamHandle | null = null;
   let streamSession: AiStreamSession | null = null;
+  let silenceTimer: ReturnType<typeof setTimeout> | undefined;
   /** The chat error left by a stream that ended for good, until a stream opens again. */
   let streamError: string | null = null;
   let streamGeneration = 0;
@@ -294,8 +295,32 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     void markConversationViewed(session.conversationId);
   };
 
+  const clearSilenceTimer = () => {
+    if (silenceTimer) clearTimeout(silenceTimer);
+    silenceTimer = undefined;
+  };
+
+  /**
+   * A running turn whose open stream delivers nothing for one worker lease either works silently or lost an update,
+   * such as its end. The stream then starts again from the turn's saved state. The wait starts with the stream's
+   * first event, so a slow first state is never cut off. A turn that waits for an action in this browser is not
+   * silent, and a stream that reconnects brings a fresh state anyway.
+   */
+  const watchSilence = (session: AiStreamSession) => {
+    clearSilenceTimer();
+    silenceTimer = setTimeout(() => {
+      silenceTimer = undefined;
+      if (!isCurrentStreamSession(streamSession, session)) return;
+      const status = streamStatus();
+      if (state.activeTurn?.status !== "running" || status === "connecting" || status === "reconnecting") return watchSilence(session);
+      closeStream();
+      openStream(session.conversationId);
+    }, AI_TURN_LEASE_MS);
+  };
+
   const applyEvent = (session: AiStreamSession, event: AiStreamEvent) => {
     if (!isCurrentStreamSession(streamSession, session)) return;
+    watchSilence(session);
     const conversationId = session.conversationId;
     if (event.type === "turn_finished" && pendingSends()[conversationId]) {
       completedDuringSend.set(conversationId, event.turnId);
@@ -327,6 +352,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   };
 
   const closeStream = () => {
+    clearSilenceTimer();
     stream?.close();
     stream = null;
     streamSession = null;
@@ -400,15 +426,15 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       console.warn(`No frontend handler registered for AI tool "${name}" — leaving the action request pending.`);
       return false;
     }
+    let result: unknown;
     try {
-      const result = await handler({ name, callId, args, turnId, conversationId });
-      return submitTurnActionForConversation(conversationId, turnId, callId, { type: "tool_result", result });
+      result = await handler({ name, callId, args, turnId, conversationId });
     } catch (toolError) {
-      return submitTurnActionForConversation(conversationId, turnId, callId, {
-        type: "tool_result",
-        result: { error: toolError instanceof Error ? toolError.message : "Frontend tool failed" },
-      });
+      result = { error: toolError instanceof Error ? toolError.message : "Frontend tool failed" };
     }
+    const submitted = await submitTurnActionForConversation(conversationId, turnId, callId, { type: "tool_result", result });
+    if (submitted) showActionResolved(conversationId, turnId, { type: "tool_result", callId, result });
+    return submitted;
   };
 
   // ---- conversation loading --------------------------------------------
@@ -1258,6 +1284,28 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     }
   };
 
+  /**
+   * Shows an action the server accepted as resolved, so the turn runs on before the stream confirms it. A turn that
+   * runs is watched for silence again, which heals a confirmation that never arrives.
+   */
+  const showActionResolved = (
+    conversationId: string,
+    turnId: string,
+    action: { type: "approval_response"; callId: string; approved: boolean } | { type: "tool_result"; callId: string; result: unknown },
+  ) => {
+    if (!isActiveConversation(conversationId) || state.activeTurn?.turnId !== turnId) return;
+    const waitingStatus = action.type === "approval_response" ? "awaiting_approval" : "awaiting_client";
+    setState("activeTurn", (current) => {
+      if (!current || current.turnId !== turnId) return current;
+      const pending = current.blocks.some(
+        (block) => block.kind === "tool" && block.callId === action.callId && block.status === waitingStatus,
+      );
+      if (!pending) return current;
+      return reconcileActiveTurnActions(current, [{ callId: action.callId, resolvedEvent: action }]);
+    });
+    cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
+  };
+
   const submitTurnAction = (
     turnId: string,
     callId: string,
@@ -1277,18 +1325,9 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       approved: input.approved,
       remember: input.remember,
     });
-    if (!submitted || !isActiveConversation(conversationId) || state.activeTurn?.turnId !== request.turnId) return submitted;
-    const action = { type: "approval_response" as const, callId: request.callId, approved: input.approved };
-    setState("activeTurn", (current) => {
-      if (!current || current.turnId !== request.turnId) return current;
-      const pending = current.blocks.some(
-        (block) => block.kind === "tool" && block.callId === request.callId && block.status === "awaiting_approval",
-      );
-      if (!pending) return current;
-      return reconcileActiveTurnActions(current, [{ callId: request.callId, resolvedEvent: action }]);
-    });
-    cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
-    return true;
+    if (submitted)
+      showActionResolved(conversationId, request.turnId, { type: "approval_response", callId: request.callId, approved: input.approved });
+    return submitted;
   };
 
   const submitFrontendToolResult = async (request: { turnId: string; callId: string }, result: unknown) => {
@@ -1299,18 +1338,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       type: "tool_result",
       result,
     });
-    if (!submitted || !isActiveConversation(conversationId) || state.activeTurn?.turnId !== request.turnId) return submitted;
-    const action = { type: "tool_result" as const, callId: request.callId, result };
-    setState("activeTurn", (current) => {
-      if (!current || current.turnId !== request.turnId) return current;
-      const pending = current.blocks.some(
-        (block) => block.kind === "tool" && block.callId === request.callId && block.status === "awaiting_client",
-      );
-      if (!pending) return current;
-      return reconcileActiveTurnActions(current, [{ callId: request.callId, resolvedEvent: action }]);
-    });
-    cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
-    return true;
+    if (submitted) showActionResolved(conversationId, request.turnId, { type: "tool_result", callId: request.callId, result });
+    return submitted;
   };
 
   if (options.initialConversationId) {

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

@@ -30,7 +30,14 @@ const bytesToBase64 = (bytes: Uint8Array): string => {
   return btoa(binary);
 };
 
-export const conversationFileSource = (baseUrl: string, conversationId: string): FileSource & { listFiles(): Promise<AiFileStat[]> } => {
+export type ConversationFileSource = FileSource & {
+  /** Files below `prefix` (default `/`); with `page`, at most `page.limit` files by path after `page.after`. */
+  listFiles(prefix?: string, page?: { limit: number; after?: string }): Promise<AiFileStat[]>;
+  /** Delete a folder with everything below it. */
+  removeFolder(path: string): Promise<void>;
+};
+
+export const conversationFileSource = (baseUrl: string, conversationId: string): ConversationFileSource => {
   const filesUrl = (suffix = "", params?: Record<string, string>) => {
     const query = params ? `?${new URLSearchParams(params).toString()}` : "";
     return `${baseUrl}/conversations/${conversationId}/files${suffix}${query}`;
@@ -45,8 +52,14 @@ 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;
+  const listFiles = async (prefix?: string, page?: { limit: number; after?: string }): Promise<AiFileStat[]> => {
+    const params: Record<string, string> = {
+      ...(prefix ? { prefix } : {}),
+      ...(page ? { limit: String(page.limit), ...(page.after ? { after: page.after } : {}) } : {}),
+    };
+    const url = Object.keys(params).length ? filesUrl("", params) : filesUrl();
+    return (await request<{ files: AiFileStat[] }>(url, { method: "GET" }, "Failed to load files")).files;
+  };
 
   return {
     previewPreferencesKey: "assistant.csv-preview",
@@ -80,6 +93,10 @@ export const conversationFileSource = (baseUrl: string, conversationId: string):
       await request(filesUrl("", { path }), { method: "DELETE" }, "Failed to delete file");
     },
 
+    async removeFolder(path) {
+      await request(filesUrl("", { path, recursive: "true" }), { method: "DELETE" }, "Failed to delete folder");
+    },
+
     async rename(from, to) {
       await request(filesUrl("/rename"), { method: "POST", body: JSON.stringify({ from, to }) }, "Failed to rename file");
     },

package/src/ai/client/projection.ts

@@ -9,6 +9,17 @@ export type AiActiveTurn = {
   status: "running" | "waiting_for_action";
   blocks: AiTurnBlock[];
   modelProfileId: string | null;
+  /**
+   * A model call failed transiently and waits for its retry. Live only: the next turn event ends it, and so does a
+   * snapshot that has moved past the retry.
+   */
+  providerRetry?: boolean;
+  /** Server start of the turn, known from a state snapshot. */
+  createdAt?: string;
+  /** Time already spent waiting for answered user actions, from the last state snapshot. */
+  actionWaitMs?: number;
+  /** Start of the user action the turn waited for at the last state snapshot. */
+  waitingSince?: string | null;
 };
 
 export type AiChatProjection = {
@@ -90,7 +101,9 @@ export const mergeActiveTurn = (previous: AiActiveTurn | null, incoming: AiActiv
   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) };
+  // A snapshot never carries a provider retry. One at the retry's own position has seen nothing after it, so the wait goes on.
+  const retry = previous.providerRetry && incoming.seq === previous.seq ? { providerRetry: true } : {};
+  return { ...turnTiming(previous), ...incoming, ...retry, blocks, status: deriveStatus(blocks) };
 };
 
 export const reconcileActiveTurnActions = (
@@ -112,9 +125,22 @@ export const activeTurnFromSnapshot = (snapshot: AiTurnSnapshot | null): AiActiv
     status: snapshot.status === "waiting_for_action" ? "waiting_for_action" : "running",
     blocks: normalizeCustomApprovalBlocks(snapshot.blocks),
     modelProfileId: snapshot.modelProfileId,
+    createdAt: snapshot.createdAt,
+    ...(snapshot.actionWaitMs !== undefined ? { actionWaitMs: snapshot.actionWaitMs } : {}),
+    ...(snapshot.waitingSince !== undefined ? { waitingSince: snapshot.waitingSince } : {}),
   };
 };
 
+/** Snapshot timing survives later attempts of the same turn, which carry no timing of their own. */
+const turnTiming = (turn: AiActiveTurn | null | undefined): Pick<AiActiveTurn, "createdAt" | "actionWaitMs" | "waitingSince"> =>
+  turn
+    ? {
+        ...(turn.createdAt !== undefined ? { createdAt: turn.createdAt } : {}),
+        ...(turn.actionWaitMs !== undefined ? { actionWaitMs: turn.actionWaitMs } : {}),
+        ...(turn.waitingSince !== undefined ? { waitingSince: turn.waitingSince } : {}),
+      }
+    : {};
+
 /**
  * Fold one stream event into the projection. Pure and total: the client and any
  * test converge on the same state for the same ordered event sequence.
@@ -125,6 +151,7 @@ export const activeTurnFromSnapshot = (snapshot: AiTurnSnapshot | null): AiActiv
  *   stale attempts are ignored. Older senders without a baseline reset to only
  *   locally pending steering blocks.
  * - block events apply only when strictly newer than the active turn's cursor.
+ * - `provider_retry` marks the active turn until its next event.
  * - `turn_finished` folds the turn's persisted messages in and clears the active turn.
  */
 export const reduceProjection = (state: AiChatProjection, event: AiStreamEvent): AiChatProjection => {
@@ -146,6 +173,8 @@ export const reduceProjection = (state: AiChatProjection, event: AiStreamEvent):
   return reduceWireEvent(state, event);
 };
 
+const withoutProviderRetry = ({ providerRetry: _, ...turn }: AiActiveTurn): AiActiveTurn => turn;
+
 export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): AiChatProjection => {
   const active = state.activeTurn;
 
@@ -163,6 +192,7 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
         status: deriveStatus(blocks),
         blocks,
         modelProfileId: event.modelProfileId,
+        ...turnTiming(active?.turnId === event.turnId ? active : null),
       },
     };
   }
@@ -172,20 +202,26 @@ export const reduceWireEvent = (state: AiChatProjection, event: AiWireEvent): Ai
     return { ...state, messages: mergeMessages(state.messages, event.messages ?? []), activeTurn: null };
   }
 
+  if (!active || active.turnId !== event.turnId || !isNewerWireEvent(event, active)) return state;
+
+  if (event.type === "provider_retry") {
+    return { ...state, activeTurn: { ...active, seq: event.seq, attempt: event.attempt, providerRetry: true } };
+  }
+
   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 },
+      activeTurn: { ...withoutProviderRetry(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;
   const blocks = applyWireEventToBlocks(active.blocks, event);
-  return { ...state, activeTurn: { ...active, attempt: event.attempt, seq: event.seq, blocks, status: deriveStatus(blocks) } };
+  return {
+    ...state,
+    activeTurn: { ...withoutProviderRetry(active), attempt: event.attempt, seq: event.seq, blocks, status: deriveStatus(blocks) },
+  };
 };
 
 /** Assistant/tool messages of the active turn are represented by live blocks; hide them. */