@k2b/cloud 0.29.0 → 0.30.0

package/src/ai/chat/messages.ts

@@ -9,6 +9,7 @@ const messages = i18n.define({
       tableLinks: "Links",
       tableOpen: "Open",
       tableEmpty: "No matching rows.",
+      chartUnavailable: "This chart cannot be shown.",
       tableCapped: "Showing the first 100 returned rows. The full tool result remains available in details.",
       tableMore: "More rows are available. Ask for the next page or open the result in the application.",
       assistantTurns: "Assistant turns",
@@ -84,6 +85,7 @@ const messages = i18n.define({
       stepDeliveringFile: "Delivering a file",
       stepPreparingView: "Preparing a view",
       stepPreparingCard: "Preparing a card",
+      stepPreparingChart: "Preparing a chart",
       stepCompacting: "Summarizing the conversation",
       stepTool: "Using a tool",
       stepFailed: "failed",
@@ -95,33 +97,24 @@ const messages = i18n.define({
       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",
-      groupCode: "Worked with code",
-      groupCloud: "Used Cloud integration",
-      groupReadFiles: "Read files",
-      groupWriteFiles: "Wrote files",
-      groupPdf: "Created PDFs",
       groupLoad: "Loaded tools and guidance",
-      groupWeb: "Searched the web",
-      groupMemory: "Used memory",
-      groupDelivered: "Delivered results",
-      groupTools: "Used tools",
       groupFailed: ({ count }: { count: number }) => `${count} failed`,
       groupRejected: ({ count }: { count: number }) => `${count} rejected`,
-      receiptDone: ({ title }: { title: string }) => `${title} done`,
+      receiptDone: ({ title }: { title: string }) => `Done: ${title}`,
       receiptApproved: ({ title }: { title: string }) => `Approved: ${title}`,
+      receiptRunning: ({ title }: { title: string }) => `Running: ${title}`,
       approvalNeeded: ({ title }: { title: string }) => `Approval needed: ${title}`,
       answerReady: "Answer ready",
       receiptRejected: ({ title }: { title: string }) => `Rejected: ${title}`,
       receiptFailed: ({ title }: { title: string }) => `Failed: ${title}`,
       receiptNotRun: ({ title, stopped }: { title: string; stopped: boolean }) => `Not run: ${title}${stopped ? " · stopped" : ""}`,
+      receiptNotRunSentence: ({ sentence, stopped }: { sentence: string; stopped: boolean }) => `${sentence}${stopped ? " · stopped" : ""}`,
       workSteps: "Work steps",
       streamLoginRequired: "Your session has ended. Sign in again to continue this chat.",
       streamAccessDenied: "You no longer have access to this chat.",
       streamNotFound: "This chat is no longer available.",
       assistant: "Assistant",
-      action: "Action",
+      approvalRunsAfter: "Runs only after you approve it",
       approvalRequired: ({ title }: { title: string }) => `Approval required: ${title}`,
       reject: "Reject",
       approved: "Approved",
@@ -300,6 +293,7 @@ const messages = i18n.define({
       tableLinks: "Links",
       tableOpen: "Öffnen",
       tableEmpty: "Keine passenden Zeilen.",
+      chartUnavailable: "Dieses Diagramm kann nicht angezeigt werden.",
       tableCapped:
         "Die ersten 100 zurückgegebenen Zeilen werden angezeigt. Das vollständige Werkzeugergebnis bleibt in den Details verfügbar.",
       tableMore: "Weitere Zeilen sind verfügbar. Frage nach der nächsten Seite oder öffne das Ergebnis in der Anwendung.",
@@ -382,6 +376,7 @@ const messages = i18n.define({
       stepDeliveringFile: "Stellt eine Datei bereit",
       stepPreparingView: "Bereitet eine Ansicht vor",
       stepPreparingCard: "Bereitet eine Karte vor",
+      stepPreparingChart: "Bereitet ein Diagramm vor",
       stepCompacting: "Fasst das Gespräch zusammen",
       stepTool: "Nutzt ein Werkzeug",
       stepFailed: "fehlgeschlagen",
@@ -393,33 +388,24 @@ const messages = i18n.define({
       checkWarnings: ({ count }) => (count === 1 ? "1 Warnung" : `${count} Warnungen`),
       openImage: ({ name }) => `Bild ${name} öffnen`,
       steered: "Richtung geändert",
-      reasoning: "Überlegungen",
-      groupPlan: "Arbeitsplan aktualisiert",
-      groupCode: "Mit Code gearbeitet",
-      groupCloud: "Cloud-Integration verwendet",
-      groupReadFiles: "Dateien gelesen",
-      groupWriteFiles: "Dateien geschrieben",
-      groupPdf: "PDFs erstellt",
       groupLoad: "Werkzeuge und Wissen geladen",
-      groupWeb: "Im Web recherchiert",
-      groupMemory: "Gedächtnis genutzt",
-      groupDelivered: "Ergebnisse bereitgestellt",
-      groupTools: "Werkzeuge verwendet",
       groupFailed: ({ count }) => `${count} fehlgeschlagen`,
       groupRejected: ({ count }) => `${count} abgelehnt`,
-      receiptDone: ({ title }) => `${title} erledigt`,
+      receiptDone: ({ title }) => `Erledigt: ${title}`,
       receiptApproved: ({ title }) => `Freigegeben: ${title}`,
+      receiptRunning: ({ title }) => `Wird ausgeführt: ${title}`,
       approvalNeeded: ({ title }) => `Freigabe nötig: ${title}`,
       answerReady: "Antwort fertig",
       receiptRejected: ({ title }) => `Abgelehnt: ${title}`,
       receiptFailed: ({ title }) => `Fehlgeschlagen: ${title}`,
       receiptNotRun: ({ title, stopped }) => `Nicht ausgeführt: ${title}${stopped ? " · gestoppt" : ""}`,
+      receiptNotRunSentence: ({ sentence, stopped }) => `${sentence}${stopped ? " · gestoppt" : ""}`,
       workSteps: "Arbeitsschritte",
       streamLoginRequired: "Deine Sitzung ist abgelaufen. Melde dich erneut an, um diesen Chat fortzusetzen.",
       streamAccessDenied: "Du hast keinen Zugriff mehr auf diesen Chat.",
       streamNotFound: "Dieser Chat ist nicht mehr verfügbar.",
       assistant: "Assistent",
-      action: "Aktion",
+      approvalRunsAfter: "Wird erst nach deiner Freigabe ausgeführt",
       approvalRequired: ({ title }) => `Freigabe erforderlich: ${title}`,
       reject: "Ablehnen",
       approved: "Freigegeben",

package/src/ai/chat/tool-disclosure.tsx

@@ -1,28 +1,35 @@
 import { Chat, type ChatActivityProps } from "@k2b/ui";
-import { createContext, type JSX, splitProps, useContext } from "solid-js";
+import { createContext, createSignal, type JSX, type Signal, splitProps, useContext } from "solid-js";
 
 export type AiToolDisclosureState = {
   get: (blockId: string) => boolean | undefined;
   set: (blockId: string, open: boolean) => void;
 };
 
+/**
+ * Disclosure choices by block id. Reactive, so a disclosure that its reader opens renders its body at once, also when
+ * nothing else in the turn changes; choices survive a remount and, in session storage, a reload.
+ */
 export const createAiToolDisclosureState = (): AiToolDisclosureState => {
-  const openByBlockId = new Map<string, boolean>();
+  const signals = new Map<string, Signal<boolean | undefined>>();
   const storageKey = (blockId: string) => `cloud.ai.tool-disclosure:${blockId}`;
+  const signal = (blockId: string): Signal<boolean | undefined> => {
+    const existing = signals.get(blockId);
+    if (existing) return existing;
+    let saved: boolean | undefined;
+    try {
+      if (window.sessionStorage.getItem(storageKey(blockId)) === "open") saved = true;
+    } catch {
+      /* SSR and disabled storage keep the in-memory state. */
+    }
+    const created = createSignal(saved);
+    signals.set(blockId, created);
+    return created;
+  };
   return {
-    get: (blockId) => {
-      if (!openByBlockId.has(blockId)) {
-        try {
-          const saved = window.sessionStorage.getItem(storageKey(blockId));
-          if (saved === "open") openByBlockId.set(blockId, true);
-        } catch {
-          /* SSR and disabled storage keep the in-memory state. */
-        }
-      }
-      return openByBlockId.get(blockId);
-    },
+    get: (blockId) => signal(blockId)[0](),
     set: (blockId, open) => {
-      openByBlockId.set(blockId, open);
+      signal(blockId)[1](open);
       try {
         if (open) window.sessionStorage.setItem(storageKey(blockId), "open");
         else window.sessionStorage.removeItem(storageKey(blockId));

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

@@ -1,10 +1,18 @@
+import { aiSkillFilePathFromMount } from "../file-mount";
 import type { AiTurnBlock } from "../protocol";
 import { aiChatMessages } from "./messages";
 
 type Tool = Extract<AiTurnBlock, { kind: "tool" }>;
 type Text = Extract<AiTurnBlock, { kind: "text" }>;
 export type AiWorkEntry = Exclude<AiTurnBlock, { kind: "text" } | { kind: "steer_message" }>;
-export type AiWorkGroup = { kind: "text"; block: Text } | { kind: "steps"; id: string; entries: AiWorkEntry[] };
+/**
+ * One row of the expanded work, all at one indent: an intermediate text, a step, or a group that folds housekeeping
+ * steps and opens in place.
+ */
+export type AiWorkItem =
+  | { kind: "text"; block: Text }
+  | { kind: "step"; entry: AiWorkEntry }
+  | { kind: "housekeeping"; id: string; entries: AiWorkEntry[] };
 
 /** A failed call, including a code run that reported an error. A rejected approval is a decision, not a failure. */
 export function isFailedTool(tool: Tool): boolean {
@@ -20,46 +28,65 @@ export function isFailedTool(tool: Tool): boolean {
   );
 }
 
+const HOUSEKEEPING_TOOLS = new Set([
+  "load_skill",
+  "search_skills",
+  "load_tools",
+  "search_tools",
+  "list_apps",
+  "search_help",
+  "read_help",
+  "search_project",
+  "read_project_knowledge",
+]);
+
+/** Preparation the reader rarely needs: loading tools, skills, and knowledge, and reading a loaded skill's files. */
+export const isHousekeepingTool = (tool: Tool): boolean => {
+  if (HOUSEKEEPING_TOOLS.has(tool.name)) return true;
+  if (tool.name !== "read_file" && tool.name !== "list_files") return false;
+  const path = tool.args !== null && typeof tool.args === "object" && "path" in tool.args ? tool.args.path : undefined;
+  return typeof path === "string" && aiSkillFilePathFromMount(path.trim()) !== null;
+};
+
+const isStep = (entry: AiWorkEntry) => entry.kind === "tool" || entry.kind === "compaction";
+
 /**
- * Split folded work into intermediate texts and the step groups between them. Reasoning stays inside its group so it
- * does not break up the tools around it. A group is keyed by its first tool, whose id is the same live and in history.
+ * The rows of the expanded work, in the original order. A run of at least two housekeeping steps, with the reasoning
+ * between them, folds into one group, unless it would hold all but one of the work's steps: then the steps show
+ * directly, so the work line never opens to a summary of itself. Entries listed in `shown` already show as rows of
+ * their own and never fold into a group, so nothing a reader sees folds away under them. A group is keyed by its first
+ * tool, whose id is the same live and in history.
  */
-export function groupWorkBlocks(blocks: readonly AiTurnBlock[]): AiWorkGroup[] {
-  const groups: AiWorkGroup[] = [];
-  for (const block of blocks) {
-    if (block.kind === "steer_message") continue;
-    if (block.kind === "text") {
-      groups.push({ kind: "text", block });
-      continue;
+export function groupWorkBlocks(blocks: readonly AiTurnBlock[], shown: ReadonlySet<string> = new Set()): AiWorkItem[] {
+  const entries = blocks.filter((block): block is AiWorkEntry | Text => block.kind !== "steer_message");
+  const steps = entries.filter((entry) => entry.kind !== "text" && isStep(entry)).length;
+  const items: AiWorkItem[] = [];
+  let run: AiWorkEntry[] = [];
+  let trailing: AiWorkEntry[] = [];
+  const flush = () => {
+    if (run.length > 0) {
+      const runSteps = run.filter(isStep).length;
+      if (runSteps >= 2 && steps - runSteps >= 2) items.push({ kind: "housekeeping", id: run[0]!.id, entries: run });
+      else for (const entry of run) items.push({ kind: "step", entry });
+    }
+    // Reasoning after the last housekeeping step belongs to what comes next.
+    for (const entry of trailing) items.push({ kind: "step", entry });
+    run = [];
+    trailing = [];
+  };
+  for (const entry of entries) {
+    const foldable = !shown.has(entry.id);
+    if (foldable && entry.kind === "tool" && isHousekeepingTool(entry)) {
+      run.push(...trailing, entry);
+      trailing = [];
+    } else if (foldable && entry.kind === "thinking" && run.length > 0) trailing.push(entry);
+    else {
+      flush();
+      items.push(entry.kind === "text" ? { kind: "text", block: entry } : { kind: "step", entry });
     }
-    const last = groups.at(-1);
-    if (last?.kind === "steps") last.entries.push(block);
-    else groups.push({ kind: "steps", id: block.id, entries: [block] });
-  }
-  for (const group of groups) {
-    if (group.kind === "steps") group.id = (group.entries.find((entry) => entry.kind === "tool") ?? group.entries[0]!).id;
   }
-  return groups;
-}
-
-/** What a group of tools did, in categories; failures and rejections are counted separately. */
-export function summarizeToolGroup(tools: readonly Tool[], locale: string): string {
-  const t = aiChatMessages(locale);
-  const categories = tools.map((tool) => {
-    if (tool.name === "todo_write") return t.groupPlan;
-    if (tool.name === "present" || tool.name === "code_present" || tool.name === "card" || tool.name === "cloud_card")
-      return t.groupDelivered;
-    if (tool.name.startsWith("code_")) return t.groupCode;
-    if (tool.presentation?.kind === "capability" || tool.name === "read_cloud_resource") return t.groupCloud;
-    if (["read_file", "list_files", "view_image"].includes(tool.name)) return t.groupReadFiles;
-    if (tool.name === "write_file") return t.groupWriteFiles;
-    if (["markdown_to_pdf", "html_to_pdf"].includes(tool.name)) return t.groupPdf;
-    if (["load_skill", "load_tools", "search_tools", "list_apps"].includes(tool.name)) return t.groupLoad;
-    if (tool.name.startsWith("web_") || tool.name === "fetch_file") return t.groupWeb;
-    if (tool.name === "memory") return t.groupMemory;
-    return t.groupTools;
-  });
-  return [...new Set(categories)].join(", ");
+  flush();
+  return items;
 }
 
 /** "9 steps · 1 failed · 1 rejected" for a group of steps. */

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

@@ -10,6 +10,7 @@ const toolNames = i18n.define({
     en: {
       calculate: "Calculate",
       card: "Card",
+      chart: "Chart",
       survey: "Survey",
       text_editor: "Text editor",
       local_bash: "Local Bash",
@@ -77,6 +78,7 @@ const toolNames = i18n.define({
     de: {
       calculate: "Rechnen",
       card: "Karte",
+      chart: "Diagramm",
       survey: "Umfrage",
       text_editor: "Texteditor",
       local_bash: "Lokale Bash",

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

@@ -1,7 +1,7 @@
 import { type AiTurnBlock, isRenderableTurnBlock } from "../protocol";
 import type { AiStoredMessage } from "../types";
 import { hasCapabilityTable } from "./capability-result";
-import { isCardToolName, isRecord, isSurveyToolName, isTextEditorToolName } from "./message-utils";
+import { isCardToolName, isChartToolName, isRecord, isSurveyToolName, isTextEditorToolName } from "./message-utils";
 import { isFailedTool } from "./tool-groups";
 
 type ToolBlock = Extract<AiTurnBlock, { kind: "tool" }>;
@@ -69,7 +69,7 @@ const isResult = (block: ToolBlock, phase: AiTurnPhase, codePresentations: boole
   // A running delivery reserves its place once its arguments arrived: a new version of an earlier result must find the
   // earlier place before it takes one of its own.
   const delivered = block.status === "completed" || (live(phase) && block.status === "running" && block.args !== undefined);
-  if (block.name === "present" || isCardToolName(block.name)) return delivered;
+  if (block.name === "present" || isCardToolName(block.name) || isChartToolName(block.name)) return delivered;
   if (block.name === "code_present") return codePresentations && delivered;
   return hasCapabilityTable(block);
 };
@@ -79,9 +79,9 @@ const actionState = (block: ToolBlock, phase: AiTurnPhase): AiTurnActionState |
   if (block.status === "rejected") return "rejected";
   if (isSurveyToolName(block.name) || isTextEditorToolName(block.name)) return isFailedTool(block) ? null : "interaction";
   if (block.name === "code_secret") return block.status === "awaiting_client" ? "interaction" : null;
-  // Effects in Cloud and decided approvals stay visible as receipts, whether or not the model mentions them.
+  // Effects in Cloud and approvals, decided or expired, stay visible as receipts, whether or not the model mentions them.
   const capabilityAction = block.presentation?.kind === "capability" && block.presentation.capabilityKind === "action";
-  if (!capabilityAction && !block.approved) return null;
+  if (!capabilityAction && block.approved === undefined) return null;
   if (block.status === "running" || block.status === "awaiting_client") return live(phase) ? "running" : "not_run";
   return isFailedTool(block) ? "failed" : "done";
 };