@k2b/cloud 0.26.0 → 0.27.0

package/src/ai/chat/turn-view.tsx

@@ -15,7 +15,7 @@ import {
   untrack,
 } from "solid-js";
 import { markdown } from "../../shared";
-import type { AiTurnBlock } from "../protocol";
+import { AI_TURN_LEASE_MS, type AiTurnBlock } from "../protocol";
 import { ApprovalBlockView, CompactionBlockView, CompactToolRow, SurveyToolView, TextEditorToolView } from "./blocks";
 import { CapabilityTablePreview } from "./capability-table";
 import { PresentToolBlock } from "./file-tools";
@@ -47,8 +47,12 @@ export type AiTurnSegment = {
   duration: () => AiTurnDuration | null;
   /** Shown above the work of a delivered scheduled result. */
   scheduledTask?: { taskId: string; occurrenceId: string } | null;
-  /** A model call of the live turn waits for its retry. Set on the turn's last segment, so the wait ends the turn. */
-  retrying?: boolean;
+  /**
+   * The live turn cannot reach the model or the server right now: a model call waits for its retry, or the stream
+   * reconnects. The working segment's work line says so while its clock stands; a turn without a work line yet says
+   * it in a row at the end of its last segment.
+   */
+  reconnect?: "line" | "row";
 };
 
 const isLive = (phase: AiTurnPhase) => phase === "running" || phase === "waiting";
@@ -63,6 +67,10 @@ export const formatWorkDuration = (ms: number, t: Messages, long = false): strin
   return long ? t.durationHoursLong({ hours, minutes: minutes % 60 }) : t.durationHours({ hours, minutes: minutes % 60 });
 };
 
+/** Identity of the current step: it changes when another block becomes current or the current call changes state. */
+const stepKey = (block: AiTurnBlock | null): string =>
+  !block ? "start" : `${block.id}:${block.kind === "tool" || block.kind === "compaction" ? block.status : block.kind}`;
+
 /** A running clock: "2:41", "1:02:41". */
 export const formatWorkClock = (ms: number): string => {
   const total = Math.max(0, Math.floor(ms / 1000));
@@ -80,14 +88,25 @@ const toolTarget = (block: ToolBlock): string => {
   return typeof value === "string" ? basename(value.trim()) : "";
 };
 
-/** The current step of a live turn, as a short progressive phrase. */
-export const liveStepLabel = (block: AiTurnBlock | null, t: Messages): string => {
+/** A step that runs longer than this shows its duration, so a long step does not look like a stalled one. */
+export const AI_LONG_STEP_MS = AI_TURN_LEASE_MS;
+
+/**
+ * The current step of a live turn, as a short progressive phrase. A step that runs long shows its duration in place of
+ * its target: "Running code · 3 min".
+ */
+export const liveStepLabel = (block: AiTurnBlock | null, t: Messages, stepMs = 0): string => {
+  if (stepMs < AI_LONG_STEP_MS) return stepPhrase(block, t, true);
+  return `${stepPhrase(block, t, false)} · ${formatWorkDuration(stepMs, t)}`;
+};
+
+const stepPhrase = (block: AiTurnBlock | null, t: Messages, withTargets: boolean): string => {
   if (!block || block.kind === "thinking" || block.kind === "steer_applied" || block.kind === "steer_message") return t.stepThinking;
   if (block.kind === "text") return t.stepWriting;
   if (block.kind === "compaction") return block.status === "running" ? t.stepCompacting : t.stepThinking;
   // A finished call means the model is deciding what to do next.
   if (block.status !== "running" && block.status !== "awaiting_client") return t.stepThinking;
-  const target = toolTarget(block);
+  const target = withTargets ? toolTarget(block) : "";
   const withTarget = (label: string) => (target ? `${label} · ${target}` : label);
   const name = block.name;
   if (block.presentation?.kind === "capability") return withTarget(t.stepUsingApp({ app: block.presentation.appName }));
@@ -117,15 +136,31 @@ function AiWorkLine(props: { segment: Accessor<AiTurnSegment> }) {
   const t = () => aiChatMessages(locale());
   const segment = () => props.segment();
   const layout = () => segment().layout;
-  const waiting = () => segment().phase === "waiting" && layout().waitingFor !== null;
-  const working = () => isLive(segment().phase) && !waiting();
+  const reconnecting = () => isLive(segment().phase) && segment().reconnect === "line";
+  const waiting = () => !reconnecting() && segment().phase === "waiting" && layout().waitingFor !== null;
+  const working = () => isLive(segment().phase) && !waiting() && !reconnecting();
+  // The current step is timed on the work clock, so it stands while the turn reconnects.
+  const currentStep = createMemo(() => (isLive(segment().phase) ? stepKey(layout().current) : null));
+  const step = createMemo(on(currentStep, (key) => (key === null ? null : (untrack(segment().duration)?.workedMs ?? 0))));
+  const stepMs = () => {
+    const startedAt = step();
+    const workedMs = segment().duration()?.workedMs;
+    return startedAt === null || workedMs === undefined ? 0 : workedMs - startedAt;
+  };
+  // Screen readers hear once that the turn reconnects; the line itself is not read while it changes.
+  createEffect(
+    on(reconnecting, (now, before) => {
+      if (now && !before) announce(t().reconnecting);
+    }),
+  );
   const worked = () => {
     const duration = segment().duration();
     return !segment().earlier && duration && duration.workedMs > 0 ? duration.workedMs : null;
   };
   const steps = () => t().steps({ count: layout().steps });
   const label = () => {
-    if (working()) return liveStepLabel(layout().current, t());
+    if (reconnecting()) return t().reconnecting;
+    if (working()) return liveStepLabel(layout().current, t(), stepMs());
     if (waiting()) return layout().waitingFor === "approval" ? t().waitingForApproval : t().waitingForAnswer;
     const duration = worked();
     const short = duration === null ? "" : formatWorkDuration(duration, t());
@@ -145,7 +180,7 @@ function AiWorkLine(props: { segment: Accessor<AiTurnSegment> }) {
   };
   const trailing = () => {
     const duration = segment().duration();
-    if (working() && duration) {
+    if ((working() || reconnecting()) && duration) {
       return (
         <span class="ai-turn-work__meta">
           {formatWorkClock(duration.workedMs)}
@@ -599,8 +634,8 @@ export function AiTurnView(props: { segment: Accessor<AiTurnSegment>; disclosure
         <For each={actionIds()}>
           {(id) => <AiTurnActionView action={() => actions().get(id)} turnId={props.segment().turnId} phase={props.segment().phase} />}
         </For>
-        <Show when={props.segment().retrying}>
-          {/* Calm by design: no busy sweep while the model call waits for its retry. */}
+        <Show when={props.segment().reconnect === "row"}>
+          {/* Calm by design: no busy sweep while the turn reconnects. */}
           <Chat.Activity label={aiChatMessages(locale()).reconnecting} icon="ti ti-refresh" />
         </Show>
       </div>

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,7 +9,10 @@ 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 or a snapshot ends it. */
+  /**
+   * 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;
@@ -98,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 { ...turnTiming(previous), ...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 = (