@k2b/cloud 0.27.0 → 0.29.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,25 @@ 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 === "provider_stopped") return "The model provider ended this answer early.";
+        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}`,
@@ -52,6 +72,7 @@ const messages = i18n.define({
       stepWritingCode: "Writing code",
       stepRunningCode: "Running code",
       stepCheckingApp: "Checking the app",
+      stepCheckingRun: "Checking the run",
       stepCode: "Working with code",
       stepPlan: "Updating the working plan",
       stepPdf: "Creating a PDF",
@@ -68,6 +89,11 @@ const messages = i18n.define({
       stepFailed: "failed",
       stepRejected: "rejected",
       stepWaiting: "waiting",
+      checkPassed: "passed",
+      checkNotPassed: "not passed",
+      checkFindings: ({ count }: { count: number }) => (count === 1 ? "1 finding" : `${count} findings`),
+      checkWarnings: ({ count }: { count: number }) => (count === 1 ? "1 warning" : `${count} warnings`),
+      openImage: ({ name }: { name: string }) => `Open image ${name}`,
       steered: "Conversation steered",
       reasoning: "Reasoning",
       groupPlan: "Updated working plan",
@@ -187,6 +213,87 @@ 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",
+      malformedImage: "This image could not be read. Export it again or choose another file.",
     },
     de: {
       backgroundRun: "Hintergrundlauf",
@@ -207,6 +314,27 @@ 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 === "provider_stopped") return "Der KI-Anbieter hat diese Antwort vorzeitig beendet.";
+        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`,
@@ -242,6 +370,7 @@ const messages = i18n.define({
       stepWritingCode: "Schreibt Code",
       stepRunningCode: "Führt Code aus",
       stepCheckingApp: "Prüft die App",
+      stepCheckingRun: "Prüft den Lauf",
       stepCode: "Arbeitet mit Code",
       stepPlan: "Aktualisiert den Arbeitsplan",
       stepPdf: "Erstellt ein PDF",
@@ -258,6 +387,11 @@ const messages = i18n.define({
       stepFailed: "fehlgeschlagen",
       stepRejected: "abgelehnt",
       stepWaiting: "wartet",
+      checkPassed: "bestanden",
+      checkNotPassed: "nicht bestanden",
+      checkFindings: ({ count }) => (count === 1 ? "1 Befund" : `${count} Befunde`),
+      checkWarnings: ({ count }) => (count === 1 ? "1 Warnung" : `${count} Warnungen`),
+      openImage: ({ name }) => `Bild ${name} öffnen`,
       steered: "Richtung geändert",
       reasoning: "Überlegungen",
       groupPlan: "Arbeitsplan aktualisiert",
@@ -377,6 +511,86 @@ 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",
+      malformedImage: "Dieses Bild konnte nicht gelesen werden. Exportiere es erneut oder wähle eine andere Datei.",
     },
   },
 });

package/src/ai/chat/presentation.tsx

@@ -15,11 +15,12 @@ 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 { type AiTurnLayout, type AiTurnPhase, layoutAiTurn, storedPhase, waitsForUser } from "./turn-layout";
 import { TurnNavigator } from "./turn-navigator";
 import { activeTimelineSeq } from "./turn-navigator-utils";
 import { type AiTurnDuration, type AiTurnSegment, AiTurnView } from "./turn-view";
@@ -101,15 +102,9 @@ const leadingSteerOpener = (blocks: readonly AssistantBlock[]): string | null =>
   return opener;
 };
 
-/** History phase of a finished loop, from how its loop ended. */
-const storedPhase = (entries: readonly AiStoredMessage[]): AiTurnPhase => {
-  const reason = entries.findLast((entry) => entry.loopDoneReason)?.loopDoneReason;
-  if (!reason || reason === "stop") return "completed";
-  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 +157,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 +207,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 +239,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 +261,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 +276,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 +302,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 +311,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 +320,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 +337,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 +378,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 +487,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/tool-names.ts

@@ -0,0 +1,157 @@
+import { i18n } from "@k2b/stdlib";
+
+/**
+ * People-facing names of Cloud's built-in Assistant tools, keyed by tool name. Step rows, receipts, and approvals show
+ * these; a capability tool brings its own translated title instead. A tool test fails when a built-in tool has no entry.
+ */
+const toolNames = i18n.define({
+  baseLocale: "en",
+  messages: {
+    en: {
+      calculate: "Calculate",
+      card: "Card",
+      survey: "Survey",
+      text_editor: "Text editor",
+      local_bash: "Local Bash",
+      todo_write: "Working plan",
+      memory: "Memory",
+      list_files: "List files",
+      read_file: "Read file",
+      write_file: "Write file",
+      fetch_file: "Download file",
+      present: "Deliver file",
+      markdown_to_pdf: "Markdown to PDF",
+      html_to_pdf: "HTML to PDF",
+      view_image: "View image",
+      transcribe_audio: "Transcribe audio",
+      web_search: "Web search",
+      web_extract: "Read web page",
+      search_tools: "Search tools",
+      load_tools: "Load tools",
+      list_apps: "List apps",
+      search_help: "Search help",
+      read_help: "Read help",
+      search_project: "Search project",
+      read_project_knowledge: "Read project knowledge",
+      read_cloud_resource: "Read Cloud item",
+      load_skill: "Load skill",
+      search_skills: "Search skills",
+      code_run: "Run code",
+      code_action: "Run app action",
+      code_inspect: "Inspect run",
+      code_stop: "Stop run",
+      code_open: "Open app",
+      code_export: "Save run output",
+      code_present: "Show app in chat",
+      code_check: "App check",
+      code_secret: "Enter secret",
+      code_database: "App tables",
+      code_files: "List stored files",
+      code_file_stat: "File details",
+      code_file_copy: "Copy file",
+      code_database_export: "Export app database",
+      code_manage_read: "Read app details",
+      code_delete: "Delete app",
+      code_database_read: "Read app database",
+      code_database_clear: "Clear app data",
+      code_database_reset: "Reset app database",
+      code_storage_list: "List app storage",
+      code_storage_delete: "Delete from app storage",
+      code_access_read: "Read app access",
+      code_access_change: "Change app access",
+      code_actions: "List app actions",
+      code_sql: "Query app database",
+      code_versions: "List app versions",
+      code_list: "Find apps",
+      code_read: "Read app source",
+      code_history: "App history",
+      code_fork: "Copy app",
+      code_publish: "Publish app",
+      code_unpublish: "Withdraw app",
+      code_restore: "Restore app version",
+      code_update: "Update app details",
+      code_create: "Create app",
+      code_write: "Save app files",
+      code_remove: "Remove app file",
+    },
+    de: {
+      calculate: "Rechnen",
+      card: "Karte",
+      survey: "Umfrage",
+      text_editor: "Texteditor",
+      local_bash: "Lokale Bash",
+      todo_write: "Arbeitsplan",
+      memory: "Gedächtnis",
+      list_files: "Dateien auflisten",
+      read_file: "Datei lesen",
+      write_file: "Datei schreiben",
+      fetch_file: "Datei herunterladen",
+      present: "Datei bereitstellen",
+      markdown_to_pdf: "Markdown als PDF",
+      html_to_pdf: "HTML als PDF",
+      view_image: "Bild ansehen",
+      transcribe_audio: "Audio transkribieren",
+      web_search: "Websuche",
+      web_extract: "Webseite lesen",
+      search_tools: "Werkzeuge suchen",
+      load_tools: "Werkzeuge laden",
+      list_apps: "Apps auflisten",
+      search_help: "Hilfe durchsuchen",
+      read_help: "Hilfe lesen",
+      search_project: "Projekt durchsuchen",
+      read_project_knowledge: "Projektwissen lesen",
+      read_cloud_resource: "Cloud-Eintrag lesen",
+      load_skill: "Skill laden",
+      search_skills: "Skills suchen",
+      code_run: "Code ausführen",
+      code_action: "App-Aktion ausführen",
+      code_inspect: "Lauf prüfen",
+      code_stop: "Lauf beenden",
+      code_open: "App öffnen",
+      code_export: "Laufergebnis speichern",
+      code_present: "App im Chat zeigen",
+      code_check: "App-Prüfung",
+      code_secret: "Geheimnis eingeben",
+      code_database: "App-Tabellen",
+      code_files: "Gespeicherte Dateien auflisten",
+      code_file_stat: "Dateidetails",
+      code_file_copy: "Datei kopieren",
+      code_database_export: "App-Datenbank exportieren",
+      code_manage_read: "App-Details lesen",
+      code_delete: "App löschen",
+      code_database_read: "App-Datenbank lesen",
+      code_database_clear: "App-Daten leeren",
+      code_database_reset: "App-Datenbank zurücksetzen",
+      code_storage_list: "App-Speicher auflisten",
+      code_storage_delete: "Aus App-Speicher löschen",
+      code_access_read: "App-Zugriff lesen",
+      code_access_change: "App-Zugriff ändern",
+      code_actions: "App-Aktionen auflisten",
+      code_sql: "App-Datenbank abfragen",
+      code_versions: "App-Versionen auflisten",
+      code_list: "Apps suchen",
+      code_read: "App-Quelltext lesen",
+      code_history: "App-Verlauf",
+      code_fork: "App kopieren",
+      code_publish: "App veröffentlichen",
+      code_unpublish: "App zurückziehen",
+      code_restore: "App-Version wiederherstellen",
+      code_update: "App-Details ändern",
+      code_create: "App erstellen",
+      code_write: "App-Dateien speichern",
+      code_remove: "App-Datei entfernen",
+    },
+  },
+});
+
+/** Older chats call the visual tools by their `cloud_` names. */
+const ALIASES: Record<string, string> = { cloud_card: "card", cloud_survey: "survey", cloud_text_editor: "text_editor" };
+
+/** The localized name of a built-in tool, or undefined for a tool Cloud does not ship. */
+export const aiBuiltinToolName = (name: string, locale: string): string | undefined => {
+  const t: Record<string, string> = toolNames.resolve([locale]).t;
+  const key = ALIASES[name] ?? name;
+  return Object.hasOwn(t, key) ? t[key] : undefined;
+};
+
+export const checkAiToolNames = () => toolNames.check();