@k2b/cloud 0.36.0 → 0.38.0

package/src/ai/chart-block.ts

@@ -527,15 +527,38 @@ export type CloudAiChartColumn = { id: string; label: string; numeric: boolean }
 export type CloudAiChartRow = { key: string; cells: Record<string, string>; values: Record<string, string | number> };
 export type CloudAiChartTable = { columns: CloudAiChartColumn[]; rows: CloudAiChartRow[] };
 
+/** The first text column titles the tooltip; the other columns become rows, matching the table in every host. */
+export function cloudAiChartTooltip(
+  columns: CloudAiChartColumn[],
+  row: CloudAiChartRow,
+): { title?: string; rows: { label: string; value: string }[] } {
+  const [first, ...rest] = columns;
+  const named = first && !first.numeric;
+  return {
+    title: named ? row.cells[first.id] : undefined,
+    rows: (named ? rest : columns)
+      .filter((column) => column.id in row.cells)
+      .map((column) => ({ label: column.label, value: row.cells[column.id] ?? "" })),
+  };
+}
+
 /**
  * Builds the data table mark by mark, in the order the renderer emits them, so the chat block fills it from the same
  * drawing that shows the chart.
  */
-export function cloudAiChartRows(input: CloudAiChartInput, locale: string) {
+export function cloudAiChartRows(
+  input: CloudAiChartInput,
+  locale: string,
+  options: { formats?: { x?: (v: number) => string; y?: (v: number) => string; value?: (v: number) => string } } = {},
+) {
   const t = labels.resolve([locale]).t;
   const format = formats(input, locale);
+  const valueFormat = input.tooltip?.format
+    ? cloudAiNumberFormatters(input.tooltip.format, locale).value
+    : (options.formats?.value ?? (input.kind === "histogram" ? undefined : options.formats?.y) ?? format.value);
+  const xFormat = options.formats?.x ?? format.x.value;
   const series = seriesOf(input);
-  const countFormat = cloudAiNumberFormatters(undefined, locale).value;
+  const countFormat = (input.kind === "histogram" ? options.formats?.y : undefined) ?? cloudAiNumberFormatters(undefined, locale).value;
   const percent = new Intl.NumberFormat(locale, { style: "percent", maximumFractionDigits: 1 });
   const unit = "unit" in input && input.unit ? ` ${input.unit}` : "";
   const columns = new Map<string, CloudAiChartColumn>();
@@ -575,26 +598,34 @@ export function cloudAiChartRows(input: CloudAiChartInput, locale: string) {
           "x",
           input.kind === "sparkline" || input.kind === "stat" ? "#" : header,
           value,
-          input.kind === "sparkline" || input.kind === "stat" ? String(value + 1) : format.x.value(value),
+          input.kind === "sparkline" || input.kind === "stat" ? String(value + 1) : xFormat(value),
         );
       } else if (field.key === "y") {
         const header =
+          input.tooltip?.label ??
           (input.kind === "line" || input.kind === "scatter" ? input.yAxis?.label : undefined) ??
           (input.kind === "sparkline" || input.kind === "stat" ? t.value : "Y");
-        cell("y", header, value, format.value(value));
+        cell("y", header, value, valueFormat(value));
       } else if (field.key === "value")
-        cell("value", (input.kind === "bar" ? input.yAxis?.label : undefined) ?? t.value, value, `${format.value(value)}${unit}`);
-      else if (field.key === "delta") cell("delta", t.delta, value, `${value > 0 ? "+" : ""}${format.value(value)}`);
-      else if (field.key === "q1" || field.key === "q2" || field.key === "q3" || field.key === "whiskerLow" || field.key === "whiskerHigh")
-        cell(field.key, t[field.key], value, format.value(value));
-      else if (field.key === "percent") cell("percent", t.share, value, percent.format(value / 100));
-      else if (field.key === "from" || field.key === "to" || field.key === "count" || field.key === "min" || field.key === "max")
         cell(
-          field.key,
-          t[field.key],
+          "value",
+          input.tooltip?.label ?? (input.kind === "bar" ? input.yAxis?.label : undefined) ?? t.value,
           value,
-          `${field.key === "count" ? countFormat(value) : format.value(value)}${field.key === "min" || field.key === "max" ? unit : ""}`,
+          `${valueFormat(value)}${unit}`,
         );
+      else if (field.key === "delta") cell("delta", t.delta, value, `${value > 0 ? "+" : ""}${valueFormat(value)}`);
+      else if (field.key === "q1" || field.key === "q2" || field.key === "q3" || field.key === "whiskerLow" || field.key === "whiskerHigh")
+        cell(field.key, t[field.key], value, valueFormat(value));
+      else if (field.key === "percent") cell("percent", t.share, value, percent.format(value / 100));
+      else if (field.key === "from" || field.key === "to" || field.key === "count" || field.key === "min" || field.key === "max") {
+        const fieldFormat =
+          field.key === "count"
+            ? countFormat
+            : input.kind === "histogram" && (field.key === "from" || field.key === "to") && options.formats?.x
+              ? xFormat
+              : valueFormat;
+        cell(field.key, t[field.key], value, `${fieldFormat(value)}${field.key === "min" || field.key === "max" ? unit : ""}`);
+      }
     }
     const row = { key: cloudAiChartMarkKey(datum), cells, values };
     rows.push(row);

package/src/ai/chat/answer-links.ts

@@ -0,0 +1,8 @@
+/**
+ * Root scheme-less Cloud resource links in sanitized Assistant answer HTML.
+ * Normalized links stay root-relative under /app/ or /open/ and can never change origin.
+ */
+export function rootResourceLinks(html: string): string {
+  // sanitize-html emits double-quoted attributes with ", <, and > escaped in values.
+  return html.replace(/<a\b[^>]*>/g, (tag) => tag.replace(/(\shref=")((?:app|open)\/)/g, "$1/$2"));
+}

package/src/ai/chat/chart-block.tsx

@@ -9,7 +9,6 @@ import {
 } from "@k2b/ui";
 import { createMemo, createUniqueId, Index, type JSX, Show } from "solid-js";
 import {
-  type CloudAiChartColumn,
   type CloudAiChartRow,
   type CloudAiChartTable,
   cloudAiChartLegend,
@@ -17,21 +16,13 @@ import {
   cloudAiChartReferenceMark,
   cloudAiChartRenderOptions,
   cloudAiChartRows,
+  cloudAiChartTooltip,
   cloudAiChartXValueFormat,
 } from "../chart-block";
 import type { CloudAiChartInput } from "../default-tool-contracts";
 import { type CloudAiGroupView, parseCloudAiChartToolView } from "../view-block";
 import { aiChatMessages } from "./messages";
 
-const tooltip = (columns: CloudAiChartColumn[], row: CloudAiChartRow) => {
-  const [first, ...rest] = columns;
-  const named = first && !first.numeric;
-  return {
-    title: named ? row.cells[first.id] : undefined,
-    rows: (named ? rest : columns).map((column) => ({ label: column.label, value: row.cells[column.id] ?? "" })),
-  };
-};
-
 type Kind = CloudAiChartInput["kind"];
 type DrawnChart = { input: CloudAiChartInput; table: CloudAiChartTable; snapshot: ChartSnapshot; legend: ChartLegendEntry[] };
 
@@ -44,7 +35,7 @@ const drawChart = (input: CloudAiChartInput, locale: string): DrawnChart | null
       key: ({ datum }) => cloudAiChartMarkKey(datum),
       tooltip: ({ datum }) => {
         const row = rows.add(datum);
-        return tooltip(rows.columns(), row);
+        return cloudAiChartTooltip(rows.columns(), row);
       },
       reference: ({ datum }) => cloudAiChartReferenceMark(input, datum),
     });

package/src/ai/chat/messages.ts

@@ -34,6 +34,7 @@ const messages = i18n.define({
       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 === "tool_failed") return "A step failed, and the model stopped without an 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")
@@ -136,6 +137,11 @@ const messages = i18n.define({
       revokeFailed: "Could not revoke. Try again.",
       revokeWebsiteFor: ({ host }: { host: string }) => `Revoke the approval for ${host}`,
       websiteRevoked: "Revoked. The next request asks again.",
+      fetchingFile: ({ name }: { name: string }) => `Fetching ${name}`,
+      fetchedFile: ({ name }: { name: string }) => `Fetched ${name}`,
+      fetchSource: "Source",
+      fetchSavedAs: "Saved as",
+      fetchReadableCopy: "Readable copy",
       details: "Details",
       hideDetails: "Hide details",
       moreOptions: ({ title }: { title: string }) => `More options for ${title}`,
@@ -336,6 +342,7 @@ const messages = i18n.define({
       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 === "tool_failed") return "Ein Schritt ist fehlgeschlagen, und das Modell hat danach 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")
@@ -444,6 +451,11 @@ const messages = i18n.define({
       revokeFailed: "Konnte nicht entzogen werden. Versuche es erneut.",
       revokeWebsiteFor: ({ host }: { host: string }) => `Freigabe für ${host} entziehen`,
       websiteRevoked: "Entzogen. Der nächste Abruf fragt wieder.",
+      fetchingFile: ({ name }) => `Lädt herunter: ${name}`,
+      fetchedFile: ({ name }) => `Heruntergeladen: ${name}`,
+      fetchSource: "Quelle",
+      fetchSavedAs: "Gespeichert als",
+      fetchReadableCopy: "Lesbare Kopie",
       details: "Details",
       hideDetails: "Details ausblenden",
       moreOptions: ({ title }) => `Weitere Optionen für ${title}`,

package/src/ai/chat/primitives.tsx

@@ -1,4 +1,5 @@
 import { createEffect, onCleanup, onMount } from "solid-js";
+import { rootResourceLinks } from "./answer-links";
 import { useAiChatActions } from "./message-actions";
 
 export function AssistantMarkdownBlock(props: { html: string }) {
@@ -41,5 +42,5 @@ export function AssistantMarkdownBlock(props: { html: string }) {
     element.addEventListener("click", handleClick);
     onCleanup(() => element.removeEventListener("click", handleClick));
   });
-  return <div ref={element} class="assistant-markdown-block" innerHTML={props.html} />;
+  return <div ref={element} class="assistant-markdown-block" innerHTML={rootResourceLinks(props.html)} />;
 }

package/src/ai/chat/web-tools.tsx

@@ -136,15 +136,22 @@ export function WebExtractToolBlock(props: { block: ToolBlock }) {
   );
 }
 
-type FetchFileResult = { path: string; size: number; mediaType: string; url: string };
+type FetchFileResult = { path: string; size: number; mediaType: string; url: string; readablePath?: string };
 
+/** Results stored before readable copies existed have no `readable` field and still render. */
 const fetchFileResult = (value: unknown): FetchFileResult | null =>
   isRecord(value) &&
   typeof value.path === "string" &&
   typeof value.size === "number" &&
   typeof value.mediaType === "string" &&
   typeof value.url === "string"
-    ? { path: value.path, size: value.size, mediaType: value.mediaType, url: value.url }
+    ? {
+        path: value.path,
+        size: value.size,
+        mediaType: value.mediaType,
+        url: value.url,
+        ...(isRecord(value.readable) && typeof value.readable.path === "string" ? { readablePath: value.readable.path } : {}),
+      }
     : null;
 
 const filenameOf = (value: string): string => {
@@ -158,6 +165,8 @@ const filenameOf = (value: string): string => {
 
 /** Imported web file: source identity, useful metadata, and chat path without raw tool JSON. */
 export function FetchFileToolBlock(props: { block: ToolBlock }) {
+  const locale = useLocale();
+  const t = () => aiChatMessages(locale());
   const sourceUrl = () => (isRecord(props.block.args) && typeof props.block.args.url === "string" ? props.block.args.url : "");
   const result = () => fetchFileResult(props.block.result);
   const displayName = () => filenameOf(result()?.path ?? sourceUrl()) || "file";
@@ -172,7 +181,7 @@ export function FetchFileToolBlock(props: { block: ToolBlock }) {
       when={props.block.status === "completed" && result()}
       fallback={
         <Chat.Activity
-          label={`Fetching ${displayName()}`}
+          label={t().fetchingFile({ name: displayName() })}
           description={domainOf(sourceUrl())}
           leading={<Favicon url={sourceUrl()} fallbackIcon="ti ti-world-download" />}
           busy
@@ -183,19 +192,27 @@ export function FetchFileToolBlock(props: { block: ToolBlock }) {
         <AiToolActivity
           blockId={props.block.id}
           leading={<Favicon url={sourceUrl() || file().url} fallbackIcon="ti ti-world-download" />}
-          label={`Fetched ${displayName()}`}
+          label={t().fetchedFile({ name: displayName() })}
           description={description()}
           bodyInset={false}
         >
           <dl class="grid w-full min-w-0 grid-cols-[max-content_minmax(0,1fr)] gap-x-3 gap-y-1 rounded-md bg-zinc-100/70 px-2 py-1.5 text-xs [box-shadow:var(--ui-control-recess)] dark:bg-zinc-950/70">
-            <dt class="font-medium text-dimmed">Source</dt>
+            <dt class="font-medium text-dimmed">{t().fetchSource}</dt>
             <dd class="min-w-0 truncate">
               <a href={file().url} target="_blank" rel="noreferrer noopener" class="text-secondary hover:text-primary">
                 {file().url}
               </a>
             </dd>
-            <dt class="font-medium text-dimmed">Saved as</dt>
+            <dt class="font-medium text-dimmed">{t().fetchSavedAs}</dt>
             <dd class="min-w-0 truncate text-secondary">{file().path}</dd>
+            <Show when={file().readablePath}>
+              {(readablePath) => (
+                <>
+                  <dt class="font-medium text-dimmed">{t().fetchReadableCopy}</dt>
+                  <dd class="min-w-0 truncate text-secondary">{readablePath()}</dd>
+                </>
+              )}
+            </Show>
           </dl>
         </AiToolActivity>
       )}

package/src/ai/chat-tasks.ts

@@ -16,11 +16,15 @@ import {
   updateMandatePolicy,
   validateMandateIssueAuthority,
 } from "../services/mandates";
-import { parsePgJsonValue } from "../services/postgres";
+import { parsePgJsonValue, toPgUuidArray } from "../services/postgres";
 import { withAiShortIdForDb } from "./short-id";
 import { aiConversations } from "./store";
 import type { AiChatTurnRunConfig, AiStoredMessage, AiTurnStatus } from "./types";
 
+/** Run history and transcripts are operational evidence; 90 days matches capability execution history.
+ * Fixed platform constant, not configurable. */
+export const AI_CHAT_TASK_RUN_RETENTION_DAYS = 90;
+
 export type AiChatTaskState = "active" | "paused" | "completed" | "needs_attention";
 export type AiChatTaskSchedule = { kind: "once"; runAt: string } | { kind: "cron"; cron: string };
 export type AiChatTask = {
@@ -914,6 +918,66 @@ export const aiChatTasks = {
     return occurrences;
   },
 
+  /** Removes expired runs and their evidence, preserving current once slot rows as dedupe guards. */
+  pruneExpiredRuns: async (input: { now?: Date; limit?: number } = {}): Promise<number> => {
+    const cutoff = new Date((input.now ?? new Date()).getTime() - AI_CHAT_TASK_RUN_RETENTION_DAYS * 86_400_000);
+    const limit = Math.min(Math.max(input.limit ?? 100, 1), 500);
+    return sql.begin(async (tx) => {
+      // Keep the current once slot row as a dedupe guard while its turn and transcript expire.
+      const occurrences = await tx<{ id: string; turn_id: string | null; keep: boolean }[]>`
+        SELECT occurrence.id, occurrence.turn_id, EXISTS (
+          SELECT 1 FROM ai.chat_tasks task WHERE task.id = occurrence.task_id
+            AND task.schedule_kind = 'once' AND task.run_at = occurrence.scheduled_for
+        ) AS keep
+        FROM ai.chat_task_occurrences occurrence
+        WHERE occurrence.state IN ('completed', 'failed') AND occurrence.completed_at < ${cutoff}
+          AND (occurrence.turn_id IS NOT NULL OR NOT EXISTS (
+            SELECT 1 FROM ai.chat_tasks task WHERE task.id = occurrence.task_id
+              AND task.schedule_kind = 'once' AND task.run_at = occurrence.scheduled_for
+          ))
+          AND NOT EXISTS (
+            SELECT 1 FROM ai.turns turn WHERE turn.id = occurrence.turn_id
+              AND turn.status NOT IN ('completed', 'failed', 'aborted')
+          )
+        ORDER BY occurrence.completed_at, occurrence.id
+        LIMIT ${limit}
+        FOR UPDATE OF occurrence SKIP LOCKED
+      `;
+      if (occurrences.length > 0) {
+        const occurrenceIds = toPgUuidArray(occurrences.filter((occurrence) => !occurrence.keep).map((occurrence) => occurrence.id));
+        const turnIds = toPgUuidArray(occurrences.flatMap((occurrence) => (occurrence.turn_id ? [occurrence.turn_id] : [])));
+        await tx`DELETE FROM ai.task_messages WHERE loop_id = ANY(${turnIds}::text[])`;
+        await tx`
+          DELETE FROM ai.turns WHERE id = ANY(${turnIds}::uuid[])
+            AND status IN ('completed', 'failed', 'aborted') AND run_config ? 'background'
+        `;
+        await tx`DELETE FROM ai.chat_task_occurrences WHERE id = ANY(${occurrenceIds}::uuid[])`;
+      }
+      const remaining = limit - occurrences.length;
+      if (remaining === 0) return occurrences.length;
+      const orphanedTurns = await tx<{ id: string }[]>`
+        SELECT turn.id FROM ai.turns turn
+        WHERE turn.run_config ? 'background' AND turn.status IN ('completed', 'failed', 'aborted')
+          AND turn.completed_at < ${cutoff}
+          AND NOT EXISTS (
+            SELECT 1 FROM ai.chat_task_occurrences occurrence WHERE occurrence.turn_id = turn.id
+          )
+        ORDER BY turn.completed_at, turn.id
+        LIMIT ${remaining}
+        FOR UPDATE OF turn SKIP LOCKED
+      `;
+      if (orphanedTurns.length === 0) return occurrences.length;
+      const orphanedTurnIds = toPgUuidArray(orphanedTurns.map((turn) => turn.id));
+      await tx`DELETE FROM ai.task_messages WHERE loop_id = ANY(${orphanedTurnIds}::text[])`;
+      const removedTurns = await tx<{ id: string }[]>`
+        DELETE FROM ai.turns WHERE id = ANY(${orphanedTurnIds}::uuid[])
+          AND status IN ('completed', 'failed', 'aborted') AND run_config ? 'background'
+        RETURNING id
+      `;
+      return occurrences.length + removedTurns.length;
+    });
+  },
+
   listQueuedOccurrences: async (limit = 100): Promise<Array<{ occurrence: AiChatTaskOccurrence; task: AiChatTask }>> => {
     const rows = await sql<(OccurrenceRow & TaskRow)[]>`
       SELECT occurrence.id, occurrence.short_id, occurrence.task_id, occurrence.scheduled_for, occurrence.trigger,

package/src/ai/default-tool-contracts.ts

@@ -59,6 +59,9 @@ export const cloudAiChartKindSchema = () =>
 
 const chartParts = (limits = true) => {
   const ChartLabel = limits ? z.string().trim().min(1).max(80) : z.union([z.string(), z.number().transform(String)]);
+  const ChartTooltip = z
+    .strictObject({ label: ChartLabel.optional(), format: cloudAiNumberFormatSchema().optional() })
+    .describe("All kinds: what tooltips and the data table call the value and how they format it; axes keep their own format.");
   // Missing observations stay numeric so the renderer can omit them with its finite-value checks.
   const ChartNumber = limits
     ? z.number()
@@ -96,6 +99,7 @@ const chartParts = (limits = true) => {
   );
   return {
     ChartLabel,
+    ChartTooltip,
     ChartNumber,
     list,
     ChartReferences,
@@ -148,6 +152,7 @@ const chartKinds = (limits = true) => {
     ChartBins,
     ChartCategory,
     ChartCommon,
+    ChartTooltip,
     ChartLabel,
     ChartPoints,
     ChartSeries,
@@ -159,11 +164,12 @@ const chartKinds = (limits = true) => {
     ChartCell,
     ChartBarGauge,
   } = chartParts(limits);
+  const ChartKindCommon = { ...ChartCommon, tooltip: ChartTooltip.optional() };
   const numberFormat = cloudAiNumberFormatSchema();
   return z.discriminatedUnion("kind", [
     z.object({
       kind: z.literal("bar"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       data: list(ChartCategory, 1, CLOUD_AI_CHART_MAX_VALUES),
       yAxis: ChartAxis.optional(),
       colorByBar: z.boolean().optional(),
@@ -173,7 +179,7 @@ const chartKinds = (limits = true) => {
     }),
     z.object({
       kind: z.literal("line"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       series: list(
         ChartSeries(
           limits
@@ -192,7 +198,7 @@ const chartKinds = (limits = true) => {
     }),
     z.object({
       kind: z.literal("scatter"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       series: list(ChartSeries(limits ? ChartPoints.min(1) : ChartPoints), 1, CLOUD_AI_CHART_MAX_SERIES),
       xAxis: ChartAxis.optional(),
       yAxis: ChartAxis.optional(),
@@ -201,7 +207,7 @@ const chartKinds = (limits = true) => {
     }),
     z.object({
       kind: z.enum(["pie", "donut"]),
-      ...ChartCommon,
+      ...ChartKindCommon,
       data: list(ChartSlice, 1, CLOUD_AI_CHART_MAX_VALUES),
       legend: z.boolean().optional(),
       showLabels: z.boolean().optional(),
@@ -209,14 +215,14 @@ const chartKinds = (limits = true) => {
     }),
     z.object({
       kind: z.literal("histogram"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       data: list(ChartNumber, 1, CLOUD_AI_CHART_MAX_VALUES),
       bins: ChartBins.optional(),
       references: ChartReferences.optional(),
     }),
     z.object({
       kind: z.literal("gauge"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       value: ChartNumber,
       min: z.number().optional(),
       max: z.number().optional(),
@@ -227,20 +233,20 @@ const chartKinds = (limits = true) => {
     }),
     z.object({
       kind: z.literal("sparkline"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       data: list(ChartNumber, 2, CLOUD_AI_CHART_MAX_VALUES),
       area: z.boolean().optional(),
     }),
     z.object({
       kind: z.literal("boxplot"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       data: list(ChartBox, 1, CLOUD_AI_CHART_MAX_VALUES),
       yAxis: ChartAxis.optional(),
       references: ChartReferences.optional(),
     }),
     z.object({
       kind: z.literal("heatmap"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       data: list(ChartCell, 1, CLOUD_AI_VIEW_MAX_MARKS),
       format: numberFormat.optional(),
       showValues: z.boolean().optional(),
@@ -249,7 +255,7 @@ const chartKinds = (limits = true) => {
     }),
     z.object({
       kind: z.literal("barGauge"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       // The shared renderer draws 280 units high and a bar gauge row is 28 units, so 8 rows fit without a taller drawing.
       data: list(ChartBarGauge, 1, CLOUD_AI_CHART_MAX_SERIES, `Use at most ${CLOUD_AI_CHART_MAX_SERIES} bar gauge items.`),
       min: z.number().optional(),
@@ -260,7 +266,7 @@ const chartKinds = (limits = true) => {
     }),
     z.object({
       kind: z.literal("stat"),
-      ...ChartCommon,
+      ...ChartKindCommon,
       value: ChartNumber,
       format: numberFormat.optional(),
       unit: ChartUnit.optional(),
@@ -336,11 +342,22 @@ export const cloudAiGroupSchema = () => {
 };
 
 const flatChartSchema = () => {
-  const { ChartAxis, ChartBins, ChartCommon, ChartLabel, ChartPoints, ChartSeries, ChartReferences, ChartThresholds, ChartUnit } =
-    chartParts();
+  const {
+    ChartAxis,
+    ChartBins,
+    ChartCommon,
+    ChartLabel,
+    ChartPoints,
+    ChartSeries,
+    ChartReferences,
+    ChartThresholds,
+    ChartUnit,
+    ChartTooltip,
+  } = chartParts();
   return z.object({
     kind: cloudAiChartKindSchema().optional().describe("Single charts: kind. Omit for groups."),
     ...ChartCommon,
+    tooltip: ChartTooltip.optional(),
     // One item object preserves every kind's fields before canonical validation; unions would strip overlapping items.
     data: z
       .union([

package/src/ai/executor.ts

@@ -23,6 +23,7 @@ import { CODE_RUNTIME_TOOL_NAMES } from "./browser-code-contracts";
 import { type AiCapabilityCatalogEntry, createAiToolResolver, createRunToolStore } from "./capabilities";
 import { AiCapabilityExecutionError, executeAiCapability, resolveAiCapabilityActor, reviewAiCapability } from "./capability-execution";
 import { aiChatMessages } from "./chat/messages";
+import { isFailedTool } from "./chat/tool-groups";
 import { aiTurnErrorText } from "./chat/turn-error";
 import { AiChatTaskAuthorityError, aiChatTasks } from "./chat-tasks";
 import { createCloudCompactFn } from "./compaction";
@@ -134,6 +135,17 @@ const toolRoundState = (messages: AiStoredMessage[]): { issued: number; complete
   };
 };
 
+const lastToolRoundFailed = (messages: AiStoredMessage[], blocks: AiTurnBlock[]): boolean => {
+  const latest = messages.findLast(({ message }) => message.role === "assistant")?.message;
+  if (latest?.role !== "assistant") return false;
+  const callIds = new Set(latest.content.flatMap((block) => (block.type === "tool_call" ? [block.id] : [])));
+  // A worker may have stored a malformed call but crashed before its error result; load repairs that result without an event.
+  return (
+    [...callIds].some(isMalformedToolCallId) ||
+    blocks.some((block) => block.kind === "tool" && callIds.has(block.callId) && isFailedTool(block))
+  );
+};
+
 const indexConversationResources = async (input: Parameters<typeof aiConversations.indexConversationResources>[0]): Promise<void> => {
   try {
     await aiConversations.indexConversationResources(input);
@@ -1500,6 +1512,7 @@ export class AiTurnExecutor {
     const outcome = await this.driveChatLoop({
       loop,
       pipeline,
+      initialRoundFailed: lastToolRoundFailed(turnMessages, turnBlocks),
       conversationId,
       turnId,
       abortController,
@@ -1572,6 +1585,7 @@ export class AiTurnExecutor {
   private async driveChatLoop(input: {
     loop: NessiLoop;
     pipeline: StreamPipeline;
+    initialRoundFailed: boolean;
     conversationId: string;
     turnId: string;
     abortController: AbortController;
@@ -1613,6 +1627,10 @@ export class AiTurnExecutor {
     } = input;
     const stopHeartbeat = this.startHeartbeat(conversationId, turnId, abortController);
     let lastIssueMessage: string | null = null;
+    let lastResponse: AssistantMessage | undefined;
+    let roundFailed = input.initialRoundFailed;
+    let followedFailedRound = false;
+    const malformedCallIds = new Set<string>();
 
     try {
       for await (const event of loop) {
@@ -1672,6 +1690,7 @@ export class AiTurnExecutor {
             .noteToolCompleted({ turnId, callId: event.callId, isError: event.isError })
             .catch(() => log.warn("AI tool audit write failed", { code: "tool_audit_complete_failed", turnId, callId: event.callId }));
           const toolBlock = pipeline.blocks.find((block) => block.kind === "tool" && block.callId === event.callId);
+          if (toolBlock?.kind === "tool" && isFailedTool(toolBlock)) roundFailed = true;
           // The policy keys calls by the name the model called, as the persisted calls it seeds from.
           noteToolCall(
             toolBlock?.kind === "tool"
@@ -1687,20 +1706,44 @@ export class AiTurnExecutor {
             result: event.result,
             isError: event.isError === true,
           });
-        } else if (event.type === "turn_end" && !abortController.signal.aborted && isToolRound(event.message)) {
-          noteToolRound();
+        } else if (event.type === "turn_end") {
+          lastResponse = event.message;
+          followedFailedRound = roundFailed;
+          const calls = new Set(event.message.content.flatMap((block) => (block.type === "tool_call" ? [block.id] : [])));
+          // nessi closes a round after executing its tools. Malformed calls have stored failed blocks,
+          // but are added by Cloud's store wrapper, so they are absent from the event's message.
+          roundFailed = pipeline.blocks.some(
+            (block) => block.kind === "tool" && (calls.has(block.callId) || malformedCallIds.has(block.callId)) && isFailedTool(block),
+          );
+          malformedCallIds.clear();
+          if (!abortController.signal.aborted && isToolRound(event.message)) noteToolRound();
         } else if (event.type === "issue") {
+          if (event.issue.kind === "malformed_tool_call" && event.issue.callId) malformedCallIds.add(event.issue.callId);
           lastIssueMessage = event.issue.message;
           log.warn("AI turn issue", { conversationId, turnId, kind: event.issue.kind, message: event.issue.message });
         } else if (event.type === "loop_end") {
+          const stoppedAfterFailure =
+            event.reason === "stop" &&
+            !abortController.signal.aborted &&
+            followedFailedRound &&
+            lastResponse !== undefined &&
+            !lastResponse.content.some((block) => block.type === "tool_call" || (block.type === "text" && block.text.trim() !== ""));
+          const doneReason = stoppedAfterFailure ? "error" : event.reason;
           const aggregate = await withDurableTurnTiming(turnId, event.aggregate);
           if (aggregate.assistantMessageCount > 0) {
             await aiConversations
-              .setLatestAssistantLoopAggregate({ conversationId, loopId: turnId, aggregate, doneReason: event.reason })
+              .setLatestAssistantLoopAggregate({ conversationId, loopId: turnId, aggregate, doneReason })
               .catch(() => undefined);
           }
           const timing = aggregate.timing;
           if (event.reason === "aborted") return { kind: "finished", status: "aborted", failure: null, timing };
+          if (stoppedAfterFailure)
+            return {
+              kind: "finished",
+              status: "failed",
+              failure: { error: { code: "tool_failed" }, detail: "The model stopped without an answer after a failed tool call." },
+              timing,
+            };
           if (event.reason === "stop") return { kind: "finished", status: "completed", failure: null, timing };
           const detail = lastIssueMessage ?? `AI turn ended: ${event.reason}`;
           const reason: AiTurnFailureReason =