@k2b/cloud 0.26.0 → 0.28.0

package/src/ai/chat/messages.ts

@@ -1,4 +1,5 @@
 import { i18n } from "@k2b/stdlib";
+import type { AiTurnError } from "../types";
 
 const messages = i18n.define({
   baseLocale: "en",
@@ -21,6 +22,24 @@ const messages = i18n.define({
       thinking: "Thinking",
       showReasoning: "Show reasoning",
       reconnecting: "Reconnecting",
+      turnErrorTitle: "The answer was interrupted.",
+      turnErrorReason: ({ code, limitMinutes }: AiTurnError) => {
+        if (code === "model_unavailable") return "The model service did not answer.";
+        if (code === "quota_exhausted") return "Your AI usage limit for this period is reached. You can continue once it resets.";
+        if (code === "context_full") return "This chat is too long for the model. Start a new chat to continue; this one stays as it is.";
+        if (code === "time_limit")
+          return limitMinutes ? `The run time limit of ${limitMinutes} minutes was reached.` : "The run time limit was reached.";
+        if (code === "step_limit") return "The model reached its step limit for one answer.";
+        if (code === "wait_expired") return "The approval or answer did not arrive in time.";
+        if (code === "interrupted") return "The work was interrupted several times and could not be resumed.";
+        if (code === "not_allowed")
+          return "This chat may no longer use its model, project, or apps. Choose another model or ask your administrator.";
+        return "Something went wrong.";
+      },
+      turnErrorKept: "The results so far are kept.",
+      turnErrorContinueHint: "Send a new message to continue.",
+      continueTurn: "Continue",
+      continueTurnMessage: "Continue where you left off.",
       byteRange: ({ start, end }: { start: string; end: string }) => `Bytes ${start}–${end}`,
       worked: "Worked",
       workedFor: ({ duration }: { duration: string }) => `Worked ${duration}`,
@@ -160,7 +179,10 @@ const messages = i18n.define({
       loadedCount: ({ count }: { count: number }) => `${count} loaded`,
       toolsLoaded: "Loaded",
       toolsAlreadyLoaded: "Already loaded",
-      toolsMissing: "Missing",
+      toolUnknown: "Not found",
+      toolNotOffered: "Not available here",
+      toolNotAllowed: "Not allowed",
+      toolAppOffline: "App not reachable",
       toolsEvicted: "Evicted",
       loadedSkill: ({ name }: { name: string }) => `Loaded skill ${name}`,
       help: "Help",
@@ -184,6 +206,86 @@ const messages = i18n.define({
       calculate: "Calculate",
       inspectImage: ({ name }: { name: string }) => `Inspect image: ${name}`,
       readResource: ({ ref }: { ref: string }) => `Read resource: ${ref}`,
+      actionHelpful: "Helpful",
+      actionHelpfulRemove: "Remove positive feedback",
+      actionImprove: "Needs improvement",
+      actionImproveRemove: "Remove negative feedback",
+      actionMessageInfo: "Response details",
+      actionCopy: "Copy",
+      actionFork: "Continue in a new chat",
+      actionTryAgain: "Try again",
+      actionMoreDetailed: "More detailed",
+      actionMoreConcise: "More concise",
+      actionEditPrompt: "Edit and try again",
+      actionRetryGuidance: "Send guidance again",
+      cancel: "Cancel",
+      forkTitle: "Continue in a new chat",
+      forkConfirm: "Create chat",
+      forkName: "Chat name",
+      forkDefaultName: "Continued chat",
+      retryTitle: "Edit and try again",
+      retryPrompt: "Message",
+      retryPromptHint: "Attachments from the original message stay attached.",
+      retryFailed: "Could not try again. Your changes are still here.",
+      retrying: "Trying again",
+      feedbackTitle: "Help improve this response",
+      feedbackIntro: "What should be better? Choose all that apply or leave a short note.",
+      feedbackDetails: "Anything else",
+      feedbackDetailsHint: "Optional. Please leave out confidential information.",
+      feedbackSend: "Send feedback",
+      feedbackIncorrect: "Incorrect",
+      feedbackIncorrectHint: "Facts or conclusions were wrong.",
+      feedbackIgnoredRequest: "Did not do what I asked",
+      feedbackIgnoredRequestHint: "Important instructions were missed.",
+      feedbackIncomplete: "Incomplete",
+      feedbackIncompleteHint: "Important information or work was missing.",
+      feedbackWrongApp: "Used the wrong app or tool",
+      feedbackWrongAppHint: "Something was missing, unnecessary, or used badly.",
+      feedbackSlow: "Too slow",
+      feedbackSlowHint: "The answer took too long for the result.",
+      feedbackOther: "Something else",
+      feedbackOtherHint: "Something else should be better.",
+      infoSubtitle: "Technical details of this answer",
+      infoDetails: "Details",
+      infoProviderModel: "Provider model",
+      infoModelProfile: "Model",
+      infoLoopId: "Run ID",
+      infoFinished: "Ended",
+      infoEndCompleted: "Completed",
+      infoEndStopped: "Stopped",
+      infoEndFailed: "Failed",
+      infoEndInterrupted: "Interrupted",
+      infoEndStepLimit: "Step limit reached",
+      infoEndUsageLimit: "Usage limit reached",
+      infoEndContextFull: "Context window full",
+      infoEndLengthLimit: "Answer length limit reached",
+      infoCreated: "Created",
+      infoUnknown: "Unknown",
+      infoLegacy: "Older message",
+      infoTiming: "Time",
+      infoWorked: "Worked",
+      infoWorkedHint: "writing and tools",
+      infoGeneration: "Writing",
+      infoToolTime: "Tools",
+      infoWaiting: "Waiting for you",
+      infoWaitingHint: "approvals and answers",
+      infoWallClock: "Total time",
+      infoSpeed: "Writing speed",
+      infoTokensPerSecond: ({ value }: { value: string }) => `${value} tokens/s`,
+      infoUsage: "Usage",
+      infoInputTokens: "Input tokens",
+      infoOutputTokens: "Output tokens",
+      infoTotalTokens: "Total tokens",
+      infoTools: "Tools",
+      infoToolsHint: "Tools this answer used.",
+      infoIssueErrors: "errors",
+      infoIssueStream: "connection problems",
+      infoIssueMalformed: "malformed",
+      infoIssueCancelled: "cancelled",
+      compactedCount: ({ count, date }: { count: number; date: string }) =>
+        `${count === 1 ? "1 message" : `${count} messages`} summarized · ${date}`,
+      compactedHint: "From here on, the model sees this summary instead of the messages above.",
+      compactedEmpty: "No visible content",
     },
     de: {
       backgroundRun: "Hintergrundlauf",
@@ -204,6 +306,26 @@ const messages = i18n.define({
       thinking: "Denkt nach",
       showReasoning: "Denkprozess anzeigen",
       reconnecting: "Verbindung wird wiederhergestellt",
+      turnErrorTitle: "Die Antwort wurde abgebrochen.",
+      turnErrorReason: ({ code, limitMinutes }) => {
+        if (code === "model_unavailable") return "Der KI-Dienst hat nicht geantwortet.";
+        if (code === "quota_exhausted")
+          return "Dein KI-Kontingent für diesen Zeitraum ist aufgebraucht. Du kannst weiterarbeiten, sobald es sich erneuert.";
+        if (code === "context_full")
+          return "Dieser Chat ist zu lang für das Modell. Starte einen neuen Chat, um weiterzuarbeiten; dieser bleibt erhalten.";
+        if (code === "time_limit")
+          return limitMinutes ? `Das Laufzeitlimit von ${limitMinutes} Minuten ist erreicht.` : "Das Laufzeitlimit ist erreicht.";
+        if (code === "step_limit") return "Das Modell hat sein Schrittlimit für eine Antwort erreicht.";
+        if (code === "wait_expired") return "Die Freigabe oder Antwort kam nicht rechtzeitig.";
+        if (code === "interrupted") return "Die Arbeit wurde mehrmals unterbrochen und konnte nicht fortgesetzt werden.";
+        if (code === "not_allowed")
+          return "Dieser Chat darf sein Modell, sein Projekt oder seine Apps nicht mehr nutzen. Wähle ein anderes Modell oder wende dich an deine Administration.";
+        return "Etwas ist schiefgelaufen.";
+      },
+      turnErrorKept: "Die bisherigen Ergebnisse bleiben erhalten.",
+      turnErrorContinueHint: "Mit einer neuen Nachricht geht es weiter.",
+      continueTurn: "Weiterarbeiten",
+      continueTurnMessage: "Mach an der Stelle weiter, an der du aufgehört hast.",
       byteRange: ({ start, end }) => `Bytes ${start}–${end}`,
       worked: "Gearbeitet",
       workedFor: ({ duration }) => `${duration} gearbeitet`,
@@ -347,7 +469,10 @@ const messages = i18n.define({
       loadedCount: ({ count }) => `${count} geladen`,
       toolsLoaded: "Geladen",
       toolsAlreadyLoaded: "Bereits geladen",
-      toolsMissing: "Nicht gefunden",
+      toolUnknown: "Nicht gefunden",
+      toolNotOffered: "Hier nicht verfügbar",
+      toolNotAllowed: "Nicht erlaubt",
+      toolAppOffline: "App nicht erreichbar",
       toolsEvicted: "Entladen",
       loadedSkill: ({ name }) => `Skill ${name} geladen`,
       help: "Hilfe",
@@ -371,6 +496,85 @@ const messages = i18n.define({
       calculate: "Berechnen",
       inspectImage: ({ name }) => `Bild prüfen: ${name}`,
       readResource: ({ ref }) => `Ressource lesen: ${ref}`,
+      actionHelpful: "Hilfreich",
+      actionHelpfulRemove: "Positive Bewertung entfernen",
+      actionImprove: "Verbesserungswürdig",
+      actionImproveRemove: "Negative Bewertung entfernen",
+      actionMessageInfo: "Details zur Antwort",
+      actionCopy: "Kopieren",
+      actionFork: "In neuem Chat fortsetzen",
+      actionTryAgain: "Noch einmal versuchen",
+      actionMoreDetailed: "Ausführlicher",
+      actionMoreConcise: "Kürzer",
+      actionEditPrompt: "Bearbeiten und neu senden",
+      actionRetryGuidance: "Hinweis erneut senden",
+      cancel: "Abbrechen",
+      forkTitle: "In neuem Chat fortsetzen",
+      forkConfirm: "Chat erstellen",
+      forkName: "Name des Chats",
+      forkDefaultName: "Fortgesetzter Chat",
+      retryTitle: "Bearbeiten und neu senden",
+      retryPrompt: "Nachricht",
+      retryPromptHint: "Die Anhänge der ursprünglichen Nachricht bleiben erhalten.",
+      retryFailed: "Das hat nicht geklappt. Deine Änderungen sind noch da.",
+      retrying: "Wird gesendet",
+      feedbackTitle: "Hilf, diese Antwort zu verbessern",
+      feedbackIntro: "Was sollte besser sein? Wähle alles Passende aus oder schreib eine kurze Notiz.",
+      feedbackDetails: "Sonst noch etwas",
+      feedbackDetailsHint: "Optional. Bitte keine vertraulichen Daten angeben.",
+      feedbackSend: "Feedback senden",
+      feedbackIncorrect: "Falsch",
+      feedbackIncorrectHint: "Fakten oder Schlussfolgerungen stimmten nicht.",
+      feedbackIgnoredRequest: "Hat nicht getan, worum ich gebeten habe",
+      feedbackIgnoredRequestHint: "Wichtige Anweisungen wurden übersehen.",
+      feedbackIncomplete: "Unvollständig",
+      feedbackIncompleteHint: "Wichtige Informationen oder Arbeitsschritte fehlten.",
+      feedbackWrongApp: "Falsche App oder falsches Werkzeug",
+      feedbackWrongAppHint: "Etwas fehlte, war unnötig oder wurde falsch genutzt.",
+      feedbackSlow: "Zu langsam",
+      feedbackSlowHint: "Die Antwort hat für das Ergebnis zu lange gedauert.",
+      feedbackOther: "Etwas anderes",
+      feedbackOtherHint: "Etwas anderes sollte besser werden.",
+      infoSubtitle: "Technische Angaben zu dieser Antwort",
+      infoDetails: "Details",
+      infoProviderModel: "Modell beim Anbieter",
+      infoModelProfile: "Modell",
+      infoLoopId: "Durchlauf-ID",
+      infoFinished: "Beendet",
+      infoEndCompleted: "Abgeschlossen",
+      infoEndStopped: "Gestoppt",
+      infoEndFailed: "Fehlgeschlagen",
+      infoEndInterrupted: "Unterbrochen",
+      infoEndStepLimit: "Schrittlimit erreicht",
+      infoEndUsageLimit: "Nutzungslimit erreicht",
+      infoEndContextFull: "Kontextfenster voll",
+      infoEndLengthLimit: "Maximale Antwortlänge erreicht",
+      infoCreated: "Erstellt",
+      infoUnknown: "Unbekannt",
+      infoLegacy: "Ältere Nachricht",
+      infoTiming: "Zeit",
+      infoWorked: "Gearbeitet",
+      infoWorkedHint: "Schreiben und Werkzeuge",
+      infoGeneration: "Schreiben",
+      infoToolTime: "Werkzeuge",
+      infoWaiting: "Wartezeit auf dich",
+      infoWaitingHint: "Freigaben und Antworten",
+      infoWallClock: "Gesamtdauer",
+      infoSpeed: "Schreibtempo",
+      infoTokensPerSecond: ({ value }) => `${value} Token/s`,
+      infoUsage: "Verbrauch",
+      infoInputTokens: "Eingabe-Token",
+      infoOutputTokens: "Ausgabe-Token",
+      infoTotalTokens: "Token gesamt",
+      infoTools: "Werkzeuge",
+      infoToolsHint: "Werkzeuge, die diese Antwort genutzt hat.",
+      infoIssueErrors: "Fehler",
+      infoIssueStream: "Verbindungsprobleme",
+      infoIssueMalformed: "fehlerhaft",
+      infoIssueCancelled: "abgebrochen",
+      compactedCount: ({ count, date }) => `${count === 1 ? "1 Nachricht" : `${count} Nachrichten`} zusammengefasst · ${date}`,
+      compactedHint: "Ab hier sieht das Modell diese Zusammenfassung statt der Nachrichten darüber.",
+      compactedEmpty: "Kein sichtbarer Inhalt",
     },
   },
 });

package/src/ai/chat/presentation.tsx

@@ -13,11 +13,12 @@ import {
   Show,
 } from "solid-js";
 import type { AiActiveTurn } from "../client/projection";
-import { type AiActiveTurnSegment, splitActiveTurnBlocks } from "../protocol";
+import { type AiActiveTurnSegment, type AiTurnBlock, splitActiveTurnBlocks } from "../protocol";
 import { type AiAssistantTimelineItem, buildAiMessageTimeline } from "../timeline";
-import type { AiConversationTimelineEntry, AiStoredMessage } from "../types";
+import type { AiConversationTimelineEntry, AiStoredMessage, AiTurnError } from "../types";
 import { type AiChatActions, AiChatActionsProvider, createAssistantMessageActions, useAiChatActions } from "./message-actions";
 import { isRecord, isSurveyToolName, textFromMessage } from "./message-utils";
+import { aiChatMessages } from "./messages";
 import { type AiToolDisclosureState, createAiToolDisclosureState } from "./tool-disclosure";
 import { type AiTurnLayout, type AiTurnPhase, layoutAiTurn, waitsForUser } from "./turn-layout";
 import { TurnNavigator } from "./turn-navigator";
@@ -108,8 +109,9 @@ const storedPhase = (entries: readonly AiStoredMessage[]): AiTurnPhase => {
   return reason === "aborted" ? "stopped" : "failed";
 };
 
-/** Responses with a work line or rich places span the message column so their right edges align. */
-const isWideLayout = (layout: AiTurnLayout) => layout.showWork || layout.results.length > 0 || layout.actions.length > 0;
+/** Responses with a work line, rich places, or a failure notice span the message column so their right edges align. */
+const isWideLayout = (layout: AiTurnLayout, error?: AiTurnError) =>
+  layout.showWork || layout.results.length > 0 || layout.actions.length > 0 || Boolean(error);
 
 const isEmptyLayout = (layout: AiTurnLayout) => !isWideLayout(layout) && layout.text.length === 0;
 
@@ -162,13 +164,49 @@ const storedItems = (
   actions: AiChatActions,
   views: TurnViews,
   locale: string,
+  idle: boolean,
 ): ChatTimelineItem[] => {
   const timeline = buildAiMessageTimeline([...messages]);
   const lastItemOfLoop = new Map<string, number>();
+  // A failed turn's notice ends its last item, which is its user message when the model never answered.
+  const lastEntryOfLoop = new Map<string, number>();
   timeline.forEach((item, index) => {
-    if (item.type === "assistant" && item.loopId) lastItemOfLoop.set(item.loopId, index);
+    const loopId = item.type === "summary" ? null : item.type === "user" ? item.entry.loopId : item.loopId;
+    if (!loopId) return;
+    lastEntryOfLoop.set(loopId, index);
+    if (item.type === "assistant") lastItemOfLoop.set(loopId, index);
   });
+  const turnErrors = new Map<string, AiTurnError>();
+  for (const message of messages) if (message.loopId && message.meta?.turnError) turnErrors.set(message.loopId, message.meta.turnError);
+  // Only the chat's newest turn can be continued, and only while no other turn runs.
+  const newestLoop = idle ? (messages.at(-1)?.loopId ?? null) : null;
   const segmentId = createSegmentIds();
+  // The model never answered: the notice stands where the live turn showed its progress, under the same id.
+  const unansweredNotice = (entry: AiStoredMessage, itemIndex: number): ChatTimelineItem[] => {
+    const loopId = entry.loopId;
+    const error = loopId && lastEntryOfLoop.get(loopId) === itemIndex ? turnErrors.get(loopId) : undefined;
+    if (!loopId || !error) return [];
+    const id = segmentId(loopId, "start");
+    return [
+      {
+        kind: "message",
+        id,
+        role: "assistant",
+        createdAt: entry.createdAt,
+        class: "ai-chat-message-wide",
+        content: views.content({
+          id,
+          turnId: loopId,
+          phase: "failed",
+          layout: layoutAiTurn([], { phase: "failed" }),
+          earlier: false,
+          duration: () => null,
+          error,
+          continuable: newestLoop === loopId,
+        }),
+      },
+    ];
+  };
   return timeline.flatMap((item, itemIndex): ChatTimelineItem | ChatTimelineItem[] => {
     if (item.type === "user") {
       const text = aiUserMessageText(item.entry);
@@ -176,7 +214,7 @@ const storedItems = (
       if (agentMessage) {
         const separator = text.indexOf("\n\n");
         const forwardedText = separator >= 0 ? text.slice(separator + 2) : text;
-        return {
+        const systemItem: ChatTimelineItem = {
           kind: "message",
           id: item.id,
           role: "system",
@@ -208,18 +246,20 @@ const storedItems = (
           ),
           anchorId: item.entry.seq,
         };
+        return [systemItem, ...unansweredNotice(item.entry, itemIndex)];
       }
-      return {
+      const userItem: ChatTimelineItem = {
         kind: "message",
         id: item.id,
         role: "user",
         createdAt: item.entry.createdAt,
         content: text ? <p class="whitespace-pre-wrap">{text}</p> : undefined,
         attachments: aiUserMessageAttachments(item.entry, actions),
-        actions: createAiUserMessageActions(item.entry, actions),
+        actions: createAiUserMessageActions(item.entry, actions, locale),
         actionDisplay: "menu",
         anchorId: item.entry.seq,
       };
+      return [userItem, ...unansweredNotice(item.entry, itemIndex)];
     }
 
     if (item.type === "summary") {
@@ -228,16 +268,14 @@ const storedItems = (
       return {
         kind: "activity",
         id: item.id,
-        label: "Context compacted",
-        description: count ? `${count} message${count === 1 ? "" : "s"} summarized · ${date}` : date,
+        label: aiChatMessages(locale).compacted,
+        description: count ? aiChatMessages(locale).compactedCount({ count, date }) : date,
         icon: "ti ti-brain",
         tone: "ai",
         content: (
           <div>
-            <p class="mb-1 text-[10px] font-medium uppercase tracking-wide text-dimmed">
-              The model now sees this summary instead of the messages above
-            </p>
-            <p class="whitespace-pre-wrap">{textFromMessage(item.entry.message) || "No visible content"}</p>
+            <p class="mb-1 text-dimmed">{aiChatMessages(locale).compactedHint}</p>
+            <p class="whitespace-pre-wrap">{textFromMessage(item.entry.message) || aiChatMessages(locale).compactedEmpty}</p>
           </div>
         ),
       };
@@ -245,9 +283,12 @@ const storedItems = (
 
     const actionEntry = item.actionEntry?.compactedAt ? null : item.actionEntry;
     const lastOfLoop = !item.loopId || lastItemOfLoop.get(item.loopId) === itemIndex;
-    const phase = lastOfLoop ? storedPhase(item.entries) : "completed";
+    const turnError = item.loopId && lastOfLoop ? turnErrors.get(item.loopId) : undefined;
+    const phase = turnError ? "failed" : lastOfLoop ? storedPhase(item.entries) : "completed";
     const segments = splitSurveyResults(item.blocks);
-    if (segments.length === 0) segments.push({ type: "assistant", blocks: [] });
+    // A turn that failed after an accepted answer ends with its notice where the live turn showed its progress, below
+    // the answer and under the same id, as activeItems() places it.
+    if (segments.length === 0 || (turnError && segments.at(-1)?.type === "survey")) segments.push({ type: "assistant", blocks: [] });
     const lastAssistant = segments.findLastIndex((segment) => segment.type === "assistant");
     const scheduledTask = item.entries.find((entry) => entry.meta?.scheduledTask)?.meta?.scheduledTask ?? null;
     let firstSegment = true;
@@ -268,7 +309,8 @@ const storedItems = (
           : undefined;
       const task = firstSegment ? scheduledTask : null;
       firstSegment = false;
-      if (isEmptyLayout(layout) && !messageActions && !task) return [];
+      const error = last ? turnError : undefined;
+      if (isEmptyLayout(layout) && !messageActions && !task && !error) return [];
       const id = item.loopId ? segmentId(item.loopId, segmentOpener) : `${item.id}:${index}`;
       return [
         {
@@ -276,7 +318,7 @@ const storedItems = (
           id,
           role: "assistant",
           createdAt: actionEntry?.createdAt ?? item.entries.at(-1)?.createdAt,
-          class: isWideLayout(layout) ? "ai-chat-message-wide" : undefined,
+          class: isWideLayout(layout, error) ? "ai-chat-message-wide" : undefined,
           content: views.content({
             id,
             turnId,
@@ -285,6 +327,8 @@ const storedItems = (
             earlier: !last,
             duration: last ? () => ({ workedMs: item.workedMs, waitingMs: null }) : () => null,
             scheduledTask: task,
+            error,
+            continuable: Boolean(error) && newestLoop === item.loopId,
           }),
           actions: messageActions,
           actionDisplay: "inline",
@@ -299,6 +343,8 @@ const activeItems = (
   actions: AiChatActions,
   views: TurnViews,
   duration: Accessor<AiTurnDuration | null>,
+  reconnecting: boolean,
+  locale: string,
 ): ChatTimelineItem[] => {
   if (!turn) return [];
   const segments = splitActiveTurnBlocks(turn.blocks).flatMap((segment): (AiActiveTurnSegment | SurveySegment)[] =>
@@ -314,6 +360,14 @@ const activeItems = (
   // Until the model takes up the steering message, the segment above it is still the one at work.
   const above = steerTail ? segments.findLastIndex((segment, index) => segment.type === "assistant" && index < lastAssistant) : -1;
   const working = above >= 0 ? above : lastAssistant;
+  const phaseOf = (index: number): AiTurnPhase =>
+    index !== working ? "completed" : turn.status === "waiting_for_action" ? "waiting" : "running";
+  const layoutOf = (blocks: AiTurnBlock[], index: number) =>
+    layoutAiTurn(blocks, { phase: phaseOf(index), codePresentations: Boolean(actions.renderCodePresentation) });
+  // The work line says in place that the turn reconnects. A turn without one yet says it in a row at its end, where a
+  // row that comes and goes moves nothing above it.
+  const workingSegment = segments[working];
+  const reconnectInLine = reconnecting && workingSegment?.type === "assistant" && layoutOf(workingSegment.blocks, working).showWork;
   const segmentId = createSegmentIds();
   let opener = "start";
 
@@ -331,7 +385,7 @@ const activeItems = (
         role: "user",
         status: block.status === "pending" ? "pending" : block.status === "failed" ? "error" : "complete",
         content: <p class="whitespace-pre-wrap">{aiSteerMessageText(block)}</p>,
-        actions: createAiSteerMessageActions(block, actions),
+        actions: createAiSteerMessageActions(block, actions, locale),
         actionDisplay: "menu",
         anchorId: turn.seq,
       };
@@ -339,8 +393,8 @@ const activeItems = (
 
     const last = index === lastAssistant;
     const live = index === working;
-    const phase: AiTurnPhase = !live ? "completed" : turn.status === "waiting_for_action" ? "waiting" : "running";
-    const layout = layoutAiTurn(segment.blocks, { phase, codePresentations: Boolean(actions.renderCodePresentation) });
+    const phase = phaseOf(index);
+    const layout = layoutOf(segment.blocks, index);
     // Consecutive steering messages leave empty segments between them; history has none. The last segment stays, since
     // it carries the progress indicator.
     if (!last && isEmptyLayout(layout)) return [];
@@ -358,7 +412,7 @@ const activeItems = (
         layout,
         earlier: !live,
         duration: live ? duration : () => null,
-        retrying: last && turn.providerRetry === true,
+        reconnect: live && reconnectInLine ? "line" : last && reconnecting && !reconnectInLine ? "row" : undefined,
       }),
     };
   });
@@ -367,9 +421,10 @@ const activeItems = (
 /**
  * Work time of the active turn: wall time minus time spent waiting for the user. A state snapshot seeds it after a
  * reconnect; the clock stands while the turn waits for an approval or an answer and continues from the same value
- * afterwards.
+ * afterwards. While `paused`, the shown time stands too and then jumps to the true work time; the clock itself keeps
+ * running, so a step that starts right after the pause is timed from the true work time.
  */
-const createActiveTurnClock = (source: AiChatTimelineSource): Accessor<AiTurnDuration | null> => {
+const createActiveTurnClock = (source: AiChatTimelineSource, paused: Accessor<boolean>): Accessor<AiTurnDuration | null> => {
   const [now, setNow] = createSignal(Date.now());
   const running = createMemo(() => source.activeTurn() !== null);
   createEffect(() => {
@@ -379,7 +434,7 @@ const createActiveTurnClock = (source: AiChatTimelineSource): Accessor<AiTurnDur
     onCleanup(() => window.clearInterval(timer));
   });
   let state: { turnId: string; seed: string; startedAt: number; waitMs: number; waitingSince: number | null } | null = null;
-  return createMemo(() => {
+  const duration = createMemo(() => {
     const turn = source.activeTurn();
     const time = now();
     if (!turn) {
@@ -411,11 +466,19 @@ const createActiveTurnClock = (source: AiChatTimelineSource): Accessor<AiTurnDur
       waitingMs: state.waitingSince === null ? null : Math.max(0, time - state.waitingSince),
     };
   });
+  let shown: AiTurnDuration | null = null;
+  return createMemo(() => {
+    const current = duration();
+    if (!paused() || !shown || !current) shown = current;
+    return shown;
+  });
 };
 
 export type AiChatTimelineSource = {
   messages: Accessor<readonly AiStoredMessage[]>;
   activeTurn: Accessor<AiActiveTurn | null>;
+  /** The conversation stream lost its connection and reconnects, such as `streamStatus() === "reconnecting"`. */
+  reconnecting?: Accessor<boolean>;
 };
 
 /**
@@ -428,9 +491,12 @@ export function createAiChatTimeline(source: AiChatTimelineSource): Accessor<rea
   const locale = useLocale();
   const disclosureState = createAiToolDisclosureState();
   const views = createTurnViews(disclosureState);
-  const clock = createActiveTurnClock(source);
-  const stored = createMemo(() => storedItems(source.messages(), actions, views, locale()));
-  const active = createMemo(() => activeItems(source.activeTurn(), actions, views, clock));
+  // While the stream reconnects or a model call waits for its retry, the live turn says so and its clock stands.
+  const reconnecting = createMemo(() => source.activeTurn()?.providerRetry === true || source.reconnecting?.() === true);
+  const clock = createActiveTurnClock(source, reconnecting);
+  const idle = createMemo(() => source.activeTurn() === null);
+  const stored = createMemo(() => storedItems(source.messages(), actions, views, locale(), idle()));
+  const active = createMemo(() => activeItems(source.activeTurn(), actions, views, clock, reconnecting(), locale()));
   return createMemo(() => {
     const items = [...stored(), ...active()];
     views.retain(new Set(items.map((item) => item.id)));

package/src/ai/chat/tool-groups.ts

@@ -12,7 +12,7 @@ export function isFailedTool(tool: Tool): boolean {
   if (tool.isError || tool.status === "failed") return true;
   const result = tool.result;
   return (
-    ["code_run", "code_inspect", "code_interact"].includes(tool.name) &&
+    ["code_run", "code_inspect"].includes(tool.name) &&
     result !== null &&
     typeof result === "object" &&
     "status" in result &&

package/src/ai/chat/turn-error.ts

@@ -0,0 +1,21 @@
+import type { AiTurnError } from "../types";
+import { aiChatMessages } from "./messages";
+
+/**
+ * Whether a new message can pick up the work. A full context, a used-up quota, or lost access would fail the next
+ * turn the same way; the reason then names the next step itself.
+ */
+export const aiTurnErrorCanContinue = (error: AiTurnError): boolean =>
+  error.code !== "context_full" && error.code !== "quota_exhausted" && error.code !== "not_allowed";
+
+/** What the chat shows under the title: the reason, and that the results so far are kept when the work can go on. */
+export const aiTurnErrorDescription = (error: AiTurnError, locale: string): string => {
+  const t = aiChatMessages(locale);
+  return aiTurnErrorCanContinue(error) ? `${t.turnErrorReason(error)} ${t.turnErrorKept}` : t.turnErrorReason(error);
+};
+
+/** The turn's stored error for readers without the chat view, such as `cld`: the description and how to go on. */
+export const aiTurnErrorText = (error: AiTurnError, locale: string): string =>
+  aiTurnErrorCanContinue(error)
+    ? `${aiTurnErrorDescription(error, locale)} ${aiChatMessages(locale).turnErrorContinueHint}`
+    : aiTurnErrorDescription(error, locale);