@k2b/cloud 0.27.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}`,
@@ -187,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",
@@ -207,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`,
@@ -377,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

@@ -15,9 +15,10 @@ import {
 import type { AiActiveTurn } from "../client/projection";
 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",
@@ -300,6 +344,7 @@ const activeItems = (
   views: TurnViews,
   duration: Accessor<AiTurnDuration | null>,
   reconnecting: boolean,
+  locale: string,
 ): ChatTimelineItem[] => {
   if (!turn) return [];
   const segments = splitActiveTurnBlocks(turn.blocks).flatMap((segment): (AiActiveTurnSegment | SurveySegment)[] =>
@@ -340,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,
       };
@@ -449,8 +494,9 @@ export function createAiChatTimeline(source: AiChatTimelineSource): Accessor<rea
   // 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 stored = createMemo(() => storedItems(source.messages(), actions, views, locale()));
-  const active = createMemo(() => activeItems(source.activeTurn(), actions, views, clock, 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);

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

@@ -1,4 +1,4 @@
-import { announce, Button, ButtonLink, Chat, useLocale } from "@k2b/ui";
+import { announce, Button, ButtonLink, Chat, NoticeCard, useLocale } from "@k2b/ui";
 import {
   type Accessor,
   createEffect,
@@ -16,6 +16,7 @@ import {
 } from "solid-js";
 import { markdown } from "../../shared";
 import { AI_TURN_LEASE_MS, type AiTurnBlock } from "../protocol";
+import type { AiTurnError } from "../types";
 import { ApprovalBlockView, CompactionBlockView, CompactToolRow, SurveyToolView, TextEditorToolView } from "./blocks";
 import { CapabilityTablePreview } from "./capability-table";
 import { PresentToolBlock } from "./file-tools";
@@ -25,6 +26,7 @@ import { aiChatMessages } from "./messages";
 import { AssistantMarkdownBlock } from "./primitives";
 import { AiToolActivity, AiToolDisclosureProvider, type AiToolDisclosureState } from "./tool-disclosure";
 import { type AiWorkEntry, countWorkSteps, groupWorkBlocks, summarizeToolGroup } from "./tool-groups";
+import { aiTurnErrorCanContinue, aiTurnErrorDescription } from "./turn-error";
 import type { AiTurnAction, AiTurnLayout, AiTurnPhase, AiTurnResult } from "./turn-layout";
 import { CloudCardBlock } from "./visual-tools";
 
@@ -53,6 +55,10 @@ export type AiTurnSegment = {
    * it in a row at the end of its last segment.
    */
   reconnect?: "line" | "row";
+  /** Why the turn failed, shown in a notice at its end. Only the last segment of a failed turn carries it. */
+  error?: AiTurnError | null;
+  /** The failed turn is the chat's newest and nothing runs, so a new message can pick up its work. */
+  continuable?: boolean;
 };
 
 const isLive = (phase: AiTurnPhase) => phase === "running" || phase === "waiting";
@@ -121,7 +127,7 @@ const stepPhrase = (block: AiTurnBlock | null, t: Messages, withTargets: boolean
   if (["code_write", "code_create", "code_update", "code_fork", "code_remove", "code_restore"].includes(name))
     return withTarget(t.stepWritingCode);
   if (["code_run", "code_action", "code_sql"].includes(name)) return withTarget(t.stepRunningCode);
-  if (["code_inspect", "code_interact"].includes(name)) return t.stepCheckingApp;
+  if (name === "code_inspect") return t.stepCheckingApp;
   if (name.startsWith("code_")) return t.stepCode;
   if (["markdown_to_pdf", "html_to_pdf"].includes(name)) return withTarget(t.stepPdf);
   if (["load_skill", "load_tools", "search_tools", "list_apps"].includes(name)) return t.stepLoading;
@@ -165,7 +171,8 @@ function AiWorkLine(props: { segment: Accessor<AiTurnSegment> }) {
     const duration = worked();
     const short = duration === null ? "" : formatWorkDuration(duration, t());
     if (segment().phase === "stopped") return t().workedStopped({ duration: short });
-    if (segment().phase === "failed") return t().workedInterrupted({ duration: short });
+    // A failed turn with a stored reason says it in its notice; the line then reads like any finished turn.
+    if (segment().phase === "failed" && !segment().error) return t().workedInterrupted({ duration: short });
     return short ? t().workedFor({ duration: short }) : t().worked;
   };
   const ariaLabel = () => {
@@ -175,7 +182,7 @@ function AiWorkLine(props: { segment: Accessor<AiTurnSegment> }) {
     return t().workedLabel({
       duration: duration === null ? "" : formatWorkDuration(duration, t(), true),
       steps: layout().steps ? steps() : "",
-      ending: phase === "stopped" || phase === "failed" ? phase : null,
+      ending: phase === "stopped" || (phase === "failed" && !segment().error) ? phase : null,
     });
   };
   const trailing = () => {
@@ -522,6 +529,37 @@ function AiTurnActionView(props: { action: Accessor<AiTurnAction | undefined>; t
   );
 }
 
+/**
+ * Why a turn failed and what comes next, at its end. "Continue" sends a visible message through the host's normal
+ * send path, so the person sees what was asked; it is offered only for the chat's newest turn and only when a new
+ * turn can finish the work.
+ */
+function AiTurnErrorNotice(props: { error: AiTurnError; continuable: boolean }) {
+  const locale = useLocale();
+  const t = () => aiChatMessages(locale());
+  const actions = useAiChatActions();
+  const [continuing, setContinuing] = createSignal(false);
+  const canContinue = () => props.continuable && aiTurnErrorCanContinue(props.error) && Boolean(actions.onContinueTurn);
+  const continueTurn = async () => {
+    if (continuing()) return;
+    setContinuing(true);
+    try {
+      await actions.onContinueTurn?.(t().continueTurnMessage);
+    } finally {
+      setContinuing(false);
+    }
+  };
+  return (
+    <NoticeCard tone="danger" class="ai-turn__notice" title={t().turnErrorTitle} detail={aiTurnErrorDescription(props.error, locale())}>
+      <Show when={canContinue()}>
+        <Button variant="text" size="sm" loading={continuing()} disabled={actions.actionDisabled?.()} onClick={() => void continueTurn()}>
+          <i class="ti ti-player-play" aria-hidden="true" /> {t().continueTurn}
+        </Button>
+      </Show>
+    </NoticeCard>
+  );
+}
+
 /**
  * Place 3. Live it is a status that switches in this same element; it keeps its height until the turn ends. A status
  * is not read token by token: screen readers hear each status once it is complete, and that the answer is ready.
@@ -605,6 +643,16 @@ export function AiTurnView(props: { segment: Accessor<AiTurnSegment>; disclosure
   const actions = createMemo(() => new Map(layout().actions.map((action) => [action.id, action])));
   const actionIds = createMemo(() => [...actions().keys()]);
   const live = () => isLive(props.segment().phase);
+  // Screen readers hear once that the turn they followed failed and why; history read later is not announced.
+  createEffect(
+    on(live, (now, before) => {
+      const error = props.segment().error;
+      if (before && !now && error) {
+        const t = aiChatMessages(locale());
+        announce(`${t.turnErrorTitle} ${aiTurnErrorDescription(error, locale())}`);
+      }
+    }),
+  );
   return (
     <AiToolDisclosureProvider state={props.disclosureState}>
       <div class="ai-turn">
@@ -638,6 +686,9 @@ export function AiTurnView(props: { segment: Accessor<AiTurnSegment>; disclosure
           {/* Calm by design: no busy sweep while the turn reconnects. */}
           <Chat.Activity label={aiChatMessages(locale()).reconnecting} icon="ti ti-refresh" />
         </Show>
+        <Show when={props.segment().error}>
+          {(error) => <AiTurnErrorNotice error={error()} continuable={props.segment().continuable === true} />}
+        </Show>
       </div>
     </AiToolDisclosureProvider>
   );