@k2b/cloud 0.26.0 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k2b/cloud",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Application platform library for independently deployed Hono and SolidJS services behind a dynamic gateway.",
   "license": "AGPL-3.0-or-later",
   "repository": {
@@ -98,9 +98,9 @@
     "@simplewebauthn/server": "14.0.3",
     "@tabler/icons": "3.48.0",
     "@tailwindcss/typography": "0.5.20",
-    "@k2b/nessi": "0.12.1",
+    "@k2b/nessi": "0.15.0",
     "@k2b/ssr": "0.14.0",
-    "@k2b/ui": "0.16.0",
+    "@k2b/ui": "0.17.0",
     "@k2b/stdlib": "0.27.0",
     "@k2b/sync": "7.0.0",
     "@nats-io/jetstream": "3.4.0",

package/src/_internal/define-app.ts

@@ -40,6 +40,7 @@ import {
   CapabilityOriginSchema,
 } from "../contracts/capabilities";
 import { type BoundNotificationMap, bindNotificationDefinitions, type NotificationDefinitionMap } from "../contracts/notification-types";
+import { type PlatformPermission, PlatformPermissionSchema } from "../contracts/outgoing-mail";
 import { isPwaPartId, PWA_AUTH_PATH, PWA_CANVAS_COLORS, PWA_MANIFEST_PATH, PWA_SHELL_APP_ID } from "../contracts/pwa";
 import type { AppRegistryEntry } from "../contracts/registry";
 import type { AppSettingsMap, KindToType } from "../contracts/settings-types";
@@ -201,6 +202,8 @@ export type AppOptions<S extends AppSettingsMap = {}, N extends NotificationDefi
    * prefix-trie from these strings.
    */
   routes: readonly string[];
+  /** Platform services requested by this application, visible to administrators. */
+  platformPermissions?: readonly PlatformPermission[];
   /**
    * Gateway-relative URL at which this app's OpenAPI 3.x JSON spec is
    * served, e.g. `"/api/notebooks/openapi.json"`. Opt-in: only set this
@@ -471,6 +474,9 @@ export const defineApp = <
   // ── 2. Meta ───────────────────────────────────────────────────────────
   const baseMeta: AppMeta = {
     id: opts.id,
+    platformPermissions: opts.platformPermissions
+      ? opts.platformPermissions.map((permission) => PlatformPermissionSchema.parse(permission))
+      : undefined,
     name: opts.name,
     icon: opts.icon,
     description: opts.description,
@@ -528,7 +534,7 @@ export const defineApp = <
         }
       })());
     try {
-      bindProcessApplicationId(meta.id);
+      bindProcessApplicationId(meta.id, meta.platformPermissions);
       cleanup.unshift(clearProcessApplicationId);
       const startedAt = Date.now();
 
@@ -587,6 +593,7 @@ export const defineApp = <
           ? { href: meta.pwa.href, requiresRoles: meta.pwa.requiresRoles ? [...meta.pwa.requiresRoles] : undefined }
           : undefined,
         widgets: meta.widgets ? meta.widgets.map((w) => ({ ...w })) : undefined,
+        platformPermissions: meta.platformPermissions ? [...meta.platformPermissions] : undefined,
         settingKeys: meta.settingKeys ? [...meta.settingKeys] : undefined,
         openapi: advertiseOpenapi ? opts.openapi : undefined,
         cliModules: cliModules.length > 0 ? cliModules : undefined,

package/src/_internal/process-identity.ts

@@ -1,15 +1,21 @@
+import type { PlatformPermission } from "../contracts/outgoing-mail";
+
 /** Identity of the application started in this process, derived from its declaration. */
 let applicationId: string | undefined;
+let platformPermissions: readonly PlatformPermission[] = [];
+export const getProcessPlatformPermissions = (): readonly PlatformPermission[] => platformPermissions;
 
 export const getProcessApplicationId = (): string | undefined => applicationId;
 
-export const bindProcessApplicationId = (id: string): void => {
+export const bindProcessApplicationId = (id: string, permissions: readonly PlatformPermission[] = []): void => {
   if (applicationId !== undefined && applicationId !== id) {
     throw new Error(`This process already hosts application "${applicationId}"`);
   }
   applicationId = id;
+  platformPermissions = [...permissions];
 };
 
 export const clearProcessApplicationId = (): void => {
   applicationId = undefined;
+  platformPermissions = [];
 };

package/src/_internal/registry-validation.ts

@@ -1,4 +1,5 @@
 import { CLOUD_CLI_MODULE_NAME } from "../cli/plugin";
+import { PlatformPermissionSchema } from "../contracts/outgoing-mail";
 import type { AppRegistryEntry } from "../contracts/registry";
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -118,6 +119,8 @@ export const validateAppRegistryEntry = (value: unknown): string | null => {
       return invalid("widgets", "an array of valid widgets");
     }
   }
+  if (value.platformPermissions !== undefined && !PlatformPermissionSchema.array().safeParse(value.platformPermissions).success)
+    return invalid("platformPermissions", "an array of platform permissions");
   if (value.settingKeys !== undefined && !isStringArray(value.settingKeys)) return invalid("settingKeys", "an array of strings");
   if (
     value.cliModules !== undefined &&

package/src/_internal/runtime-context.ts

@@ -15,6 +15,7 @@ export const buildRuntimeFromRegistry = (entries: AppRegistryEntry[], capabiliti
     const searchTags = searchQueries?.flatMap((query) => query.universalSearch!.tags.flatMap((tag) => [tag.tag, ...(tag.aliases ?? [])]));
     return {
       id: e.id,
+      platformPermissions: e.platformPermissions ? [...e.platformPermissions] : undefined,
       name: e.name,
       icon: e.icon,
       description: e.description,

package/src/ai/admin.ts

@@ -1,5 +1,6 @@
 export { quotaAdminConfig, quotaReport } from "./quota-report";
 export { AiQuotaError, aiQuotas } from "./quotas";
+export { listAiRequestHeaderNames } from "./request-headers";
 /** Server-only AI administration and usage accounting. */
 
 export { type AiModelAccessDraft, type AiModelAccessMap, type AiModelAccessState, aiModelAccess } from "./model-access";

package/src/ai/browser-code-contracts.ts

@@ -23,7 +23,7 @@ export const CodeRunInput = z
     resourceId: id
       .optional()
       .describe(
-        "Optional data context for one-off code. Requires Manage; uses this resource database and shared files/KV without changing its source. Local storage stays temporary.",
+        "Optional data context for one-off code. Requires Manage; uses this resource database and shared files/KV without changing its source. Test runs use real shared and personal data; writes and capability effects keep normal permissions and approvals.",
       ),
     version: z
       .number()
@@ -71,7 +71,10 @@ export const CodeActionInput = z
       .positive()
       .optional()
       .describe("Exact draft revision returned by code_actions({draft:true}); Manage required. Supply this OR publishedVersion."),
-    input: z.json().describe("Action input matching the discovered inputSchema."),
+    input: z
+      .record(z.string(), z.json())
+      .default({})
+      .describe("Action input object matching the discovered inputSchema. Pass the object itself, never JSON text."),
   })
   .strict()
   .refine(
@@ -162,6 +165,15 @@ export const CodeSecretInput = z
   })
   .strict();
 
+/**
+ * A runtime call that did not complete: rejected input, timeout, lost run or host failure.
+ * Hosts return it as data because a client tool result carries no error flag; the managed
+ * server tools report it to the model as a tool error. A run snapshot whose code failed is a
+ * completed call and keeps its own `status` and `error`.
+ */
+export const CodeToolFailure = z.object({ failed: z.literal(true), error: z.string(), guidance: z.string().optional() });
+export type CodeToolFailure = z.infer<typeof CodeToolFailure>;
+
 // Internal bridge envelope. Each model-facing tool receives only its own flat schema.
 export const CodeRuntimeInput = z.discriminatedUnion("operation", [
   CodeRunInput.safeExtend({ operation: z.literal("run") }),

package/src/ai/browser.ts

@@ -1,4 +1,11 @@
-export { CODE_RUNTIME_TOOL_NAMES, CodeActionInput, CodeResourceId, CodeRuntimeInput, parseCodeToolInput } from "./browser-code-contracts";
+export {
+  CODE_RUNTIME_TOOL_NAMES,
+  CodeActionInput,
+  CodeResourceId,
+  CodeRuntimeInput,
+  CodeToolFailure,
+  parseCodeToolInput,
+} from "./browser-code-contracts";
 export { type AiTaskRequest, type AiTaskRequestInput, AiTaskRequestSchema } from "./task-contracts";
 export { type AiTodoPlan, parseAiTodoPlan } from "./todo-contracts";
 

package/src/ai/capabilities.ts

@@ -72,6 +72,16 @@ type AiToolCatalogEntry = AiToolCatalogItem & {
 
 export type AiRememberableCapabilityApprovals = ReadonlyMap<string, string>;
 
+/**
+ * Why `load_tools` could not make a requested name callable:
+ * - `unknown`: no tool has this exact name;
+ * - `not_offered_in_turn`: the tool exists, but this turn's client or task does not provide it;
+ * - `not_allowed`: the conversation's fixed tool scope excludes it;
+ * - `app_offline`: the app operation is not in the live registry now.
+ */
+export const AI_TOOL_UNAVAILABLE_REASONS = ["unknown", "not_offered_in_turn", "not_allowed", "app_offline"] as const;
+export type AiToolUnavailableReason = (typeof AI_TOOL_UNAVAILABLE_REASONS)[number];
+
 const DEFAULT_SEARCH_LIMIT = 10;
 const DEFAULT_APP_LIST_LIMIT = 20;
 const MAX_APP_LIST_LIMIT = 25;
@@ -367,15 +377,16 @@ export const createAiHelpTools = (help: HelpReaderFactory = createHelpReader, lo
   return [search, read];
 };
 
+/** `null` when the registry could not be read. */
 const resolveCapabilityRegistry = async (
   listRegistry: () => Promise<CapabilityRegistryEntry[]>,
   onError?: (error: unknown) => void,
-): Promise<CapabilityRegistryEntry[]> => {
+): Promise<CapabilityRegistryEntry[] | null> => {
   try {
     return await listRegistry();
   } catch (error) {
     onError?.(error);
-    return [];
+    return null;
   }
 };
 
@@ -453,6 +464,9 @@ const ToolCatalogItemSchema = z
 
 type ToolStateStore = Pick<AiConversationService, "loadTools">;
 
+/** `call` is the name to call the tool by; app operations get a provider-safe name. */
+const LoadedToolSchema = z.object({ name: z.string(), call: z.string() }).strict();
+
 export const createAiToolMetaTools = (input: {
   apps: readonly CapabilityRegistryEntry[];
   catalog: readonly AiToolCatalogEntry[];
@@ -461,6 +475,10 @@ export const createAiToolMetaTools = (input: {
   store: ToolStateStore;
   maxLoadedTools?: number;
   unavailableLoadedNames?: readonly string[];
+  /** False when this turn offers no app operations at all. */
+  appOperationsOffered?: boolean;
+  /** Why a requested name that is not in `catalog` cannot be loaded; defaults to `unknown`. */
+  unavailableReason?: (name: string) => AiToolUnavailableReason;
 }): AiRuntimeTool[] => {
   const apps = buildAiCapabilityAppCatalog(input.apps);
   const directoryEntries: string[] = [];
@@ -476,17 +494,17 @@ export const createAiToolMetaTools = (input: {
   const liveAppDirectory =
     directoryEntries.length > 0
       ? ` Live capability apps: ${directoryEntries.join(", ")}${hiddenAppCount > 0 ? `, and ${hiddenAppCount} more` : ""}.`
-      : " No live capability apps are visible in this provider turn; retry discovery later instead of claiming a permanent product limitation.";
+      : input.appOperationsOffered === false
+        ? " App operations are not offered in this turn."
+        : " No Cloud app publishes operations right now. Do not search for app operations again in this turn; tell the user which app is not reachable instead of claiming a permanent product limitation.";
   const unavailableLoadedNames = input.unavailableLoadedNames ?? [];
   const unavailableLoadedNotice =
     unavailableLoadedNames.length > 0
-      ? ` Previously loaded tools currently absent from the live catalog: ${unavailableLoadedNames
-          .slice(-MAX_UNAVAILABLE_LOADED_NAMES)
-          .join(", ")}${
+      ? ` Previously loaded tools that are not available now: ${unavailableLoadedNames.slice(-MAX_UNAVAILABLE_LOADED_NAMES).join(", ")}${
           unavailableLoadedNames.length > MAX_UNAVAILABLE_LOADED_NAMES
             ? `, and ${unavailableLoadedNames.length - MAX_UNAVAILABLE_LOADED_NAMES} more`
             : ""
-        }. Treat them as temporarily unavailable; do not infer a permanent product limitation or search repeatedly.`
+        }. Do not search for them again in this turn; continue without them or tell the user what is missing.`
       : "";
   const search = defineAiTool({
     name: "search_tools",
@@ -524,38 +542,52 @@ export const createAiToolMetaTools = (input: {
   const load = defineAiTool({
     name: "load_tools",
     description:
-      "Load stable capability ids such as mail.conversation.list, or exact built-in names returned by search_tools, as ordinary tools for the next model turn. Skills may name capability ids directly, so load them without searching first.",
+      "Load stable capability ids such as mail.conversation.list, or exact built-in names returned by search_tools, as ordinary tools for the next model turn. Skills may name capability ids directly, so load them without searching first. Call each loaded tool by the `call` name returned for it. `unavailable` gives a reason per name: unknown means no tool has this exact name, so look it up once with search_tools instead of guessing; not_offered_in_turn means this client or task does not provide the tool; not_allowed means this chat's fixed tool scope excludes it; app_offline means its app is not reachable now. For the last three, do not search or load the name again in this turn.",
     inputSchema: z.object({ names: z.array(z.string().trim().min(1)).min(1).max(25) }).strict(),
     outputSchema: z
       .object({
-        loaded: z.array(z.string()),
-        alreadyLoaded: z.array(z.string()),
-        missing: z.array(z.string()),
+        loaded: z.array(LoadedToolSchema),
+        alreadyLoaded: z.array(LoadedToolSchema),
+        unavailable: z.array(z.object({ name: z.string(), reason: z.enum(AI_TOOL_UNAVAILABLE_REASONS) }).strict()),
         evicted: z.array(z.string()),
         titles: z.record(z.string(), z.string()),
       })
       .strict(),
     approval: "never",
   }).server(async ({ names }) => {
-    const available = new Set(input.catalog.map((entry) => entry.name));
+    const catalogByName = new Map(input.catalog.map((entry) => [entry.name, entry]));
+    // A provider name the model saw in an earlier call loads its operation, too.
+    const byProviderName = new Map(input.catalog.flatMap((entry) => (entry.capability ? [[entry.capability.providerName, entry]] : [])));
     const requested = [...new Set(names)];
-    const eager = requested.filter((name) => input.eagerNames.has(name));
-    const valid = requested.filter((name) => available.has(name) && !input.eagerNames.has(name));
-    const missing = requested.filter((name) => !available.has(name));
+    const found = requested.flatMap((name) => {
+      const entry = catalogByName.get(name) ?? byProviderName.get(name);
+      return entry ? [entry.name] : [];
+    });
+    const eager = [...new Set(found.filter((name) => input.eagerNames.has(name)))];
+    const valid = [...new Set(found.filter((name) => !input.eagerNames.has(name)))];
+    const unavailable = requested
+      .filter((name) => !catalogByName.has(name) && !byProviderName.has(name))
+      .map((name) => ({ name, reason: input.unavailableReason?.(name) ?? ("unknown" as const) }));
     const updated = await input.store.loadTools({
       conversationId: input.conversationId,
       names: valid,
       maxLoadedTools: input.maxLoadedTools,
     });
+    const callable = (name: string) => ({ name, call: catalogByName.get(name)?.capability?.providerName ?? name });
     const alreadyLoaded = [...new Set([...eager, ...updated.alreadyLoaded])];
-    const catalogByName = new Map(input.catalog.map((entry) => [entry.name, entry]));
     const titles = Object.fromEntries(
       [...new Set([...updated.loaded, ...alreadyLoaded, ...updated.evicted])].flatMap((name) => {
         const entry = catalogByName.get(name);
         return entry ? [[name, entry.title]] : [];
       }),
     );
-    return { ...updated, alreadyLoaded, missing, titles };
+    return {
+      loaded: updated.loaded.map(callable),
+      alreadyLoaded: alreadyLoaded.map(callable),
+      unavailable,
+      evicted: updated.evicted,
+      titles,
+    };
   });
 
   return [search, load, listApps];
@@ -657,6 +689,8 @@ export const createAiToolResolver =
     actor: RequestActor;
     staticTools: AiRuntimeTool[];
     allowedTools?: readonly string[] | null;
+    /** Built-in tools that exist but that this turn does not offer, such as client tools its client did not declare or tools outside `allowedTools`. */
+    unofferedTools?: readonly string[];
     runtimeContext?: Omit<AiToolPreparationContext, "actor" | "conversationId">;
     store: Pick<AiConversationService, "getLoadedTools" | "loadTools">;
     listRegistry?: () => Promise<CapabilityRegistryEntry[]>;
@@ -675,10 +709,11 @@ export const createAiToolResolver =
     }) => void;
   }): ToolResolver =>
   async (): Promise<Tool[]> => {
-    const [registry, persistedLoadedNames] = await Promise.all([
+    const [liveRegistry, persistedLoadedNames] = await Promise.all([
       input.listRegistry ? resolveCapabilityRegistry(input.listRegistry, input.onCapabilityRegistryError) : [],
       input.store.getLoadedTools({ conversationId: input.conversationId }),
     ]);
+    const registry = liveRegistry ?? [];
     const configuredLimit = Math.floor(input.maxLoadedTools ?? 0);
     const loadedNames = configuredLimit > 0 ? persistedLoadedNames.slice(-configuredLimit) : persistedLoadedNames;
     if (loadedNames.length !== persistedLoadedNames.length) {
@@ -689,18 +724,41 @@ export const createAiToolResolver =
       });
     }
     const allowed = input.allowedTools == null ? null : new Set(input.allowedTools);
-    const capabilityCatalog = buildAiCapabilityCatalog(registry, input.locale).filter((entry) => !allowed || allowed.has(entry.name));
+    const fullCapabilityCatalog = buildAiCapabilityCatalog(registry, input.locale);
+    const capabilityCatalog = fullCapabilityCatalog.filter((entry) => !allowed || allowed.has(entry.name));
     const helpTools = input.help ? createAiHelpTools(input.help, input.locale) : [];
     const resourceTool =
       input.execute && (capabilityCatalog.length > 0 || input.staticTools.some((tool) => tool.def.name === "code_read"))
         ? createAiResourceReaderTool({ apps: registry, catalog: capabilityCatalog, execute: input.execute })
         : null;
-    const builtIns = [...input.staticTools, ...helpTools, ...(resourceTool ? [resourceTool] : [])].filter(
-      (tool) => !allowed || allowed.has(tool.def.name),
-    );
+    const allBuiltIns = [...input.staticTools, ...helpTools, ...(resourceTool ? [resourceTool] : [])];
+    const builtIns = allBuiltIns.filter((tool) => !allowed || allowed.has(tool.def.name));
     const catalog = buildAiToolCatalog(builtIns, capabilityCatalog);
     const catalogNames = new Set(catalog.map((entry) => entry.name));
     const unavailableLoadedNames = loadedNames.filter((name) => !catalogNames.has(name));
+    const outOfScope = new Set([
+      ...allBuiltIns.map((tool) => tool.def.name),
+      ...fullCapabilityCatalog.flatMap((entry) => [entry.name, entry.providerName]),
+      ...(input.unofferedTools ?? []),
+    ]);
+    const unoffered = new Set(input.unofferedTools);
+    // A model may name a loaded operation by the provider name it called it by; app IDs contain no dot.
+    const loadedByProviderName = new Map(
+      persistedLoadedNames.flatMap((id) => {
+        const dot = id.indexOf(".");
+        if (dot < 1) return [];
+        return (["query", "action"] as const).map((kind) => [aiCapabilityToolName(id.slice(0, dot), kind, id.slice(dot + 1)), id] as const);
+      }),
+    );
+    // App operation IDs always contain a dot; built-in names never do.
+    const unavailableReason = (requested: string): AiToolUnavailableReason => {
+      const name = loadedByProviderName.get(requested) ?? requested;
+      if (allowed && outOfScope.has(name) && !allowed.has(name)) return "not_allowed";
+      if (unoffered.has(name)) return "not_offered_in_turn";
+      if (!name.includes(".")) return "unknown";
+      if (!input.listRegistry) return "not_offered_in_turn";
+      return liveRegistry === null || persistedLoadedNames.includes(name) ? "app_offline" : "unknown";
+    };
     const eagerNames = new Set(builtIns.map((tool) => tool.def.name).filter((name) => !CLOUD_AI_DEFERRED_BUILTIN_TOOL_NAMES.has(name)));
     const activeBuiltIns = builtIns.filter((tool) => eagerNames.has(tool.def.name) || loadedNames.includes(tool.def.name));
     const runtimeTools = [
@@ -712,6 +770,8 @@ export const createAiToolResolver =
         store: input.store,
         maxLoadedTools: input.maxLoadedTools,
         unavailableLoadedNames,
+        appOperationsOffered: Boolean(input.listRegistry),
+        unavailableReason,
       }),
       ...activeBuiltIns,
       ...(input.execute

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

@@ -145,6 +145,12 @@ function ListAppsView(props: { block: ToolBlock }) {
   );
 }
 
+/** Entries are `{name}` records; turns stored before #528 hold plain names and a `missing` list. */
+const toolNames = (value: unknown): string[] =>
+  Array.isArray(value)
+    ? value.flatMap((item) => (typeof item === "string" ? [item] : isRecord(item) && typeof item.name === "string" ? [item.name] : []))
+    : [];
+
 function LoadToolsView(props: { block: ToolBlock }) {
   const result = () => (isRecord(props.block.result) ? props.block.result : {});
   const titles = (): Record<string, unknown> => {
@@ -152,31 +158,33 @@ function LoadToolsView(props: { block: ToolBlock }) {
     return isRecord(value) ? value : {};
   };
   const t = useMessages();
-  const groups = () =>
-    (
-      [
-        [t().toolsLoaded, result().loaded],
-        [t().toolsAlreadyLoaded, result().alreadyLoaded],
-        [t().toolsMissing, result().missing],
-        [t().toolsEvicted, result().evicted],
-      ] as const
-    ).flatMap(([label, value]) =>
-      Array.isArray(value) && value.length > 0 ? [{ label, names: value.filter((name): name is string => typeof name === "string") }] : [],
-    );
-  const loadedCount = () => {
-    const value = result().loaded;
-    return Array.isArray(value) ? value.length : 0;
-  };
+  const unavailableLabel = (reason: unknown) =>
+    reason === "not_offered_in_turn"
+      ? t().toolNotOffered
+      : reason === "not_allowed"
+        ? t().toolNotAllowed
+        : reason === "app_offline"
+          ? t().toolAppOffline
+          : t().toolUnknown;
+  const rows = () => [
+    ...toolNames(result().loaded).map((name) => ({ name, label: t().toolsLoaded })),
+    ...toolNames(result().alreadyLoaded).map((name) => ({ name, label: t().toolsAlreadyLoaded })),
+    ...records(result().unavailable).flatMap((item) =>
+      typeof item.name === "string" ? [{ name: item.name, label: unavailableLabel(item.reason) }] : [],
+    ),
+    ...toolNames(result().missing).map((name) => ({ name, label: t().toolUnknown })),
+    ...toolNames(result().evicted).map((name) => ({ name, label: t().toolsEvicted })),
+  ];
   return (
-    <CompletedActivity block={props.block} label={t().loadTools} description={t().loadedCount({ count: loadedCount() })}>
-      <Show when={groups().length > 0}>
+    <CompletedActivity
+      block={props.block}
+      label={t().loadTools}
+      description={t().loadedCount({ count: toolNames(result().loaded).length })}
+    >
+      <Show when={rows().length > 0}>
         <ResultList>
-          <For each={groups()}>
-            {(group) => (
-              <For each={group.names}>
-                {(name) => <ResultRow icon={aiToolIcon(name)} title={text(titles()[name]) || name} meta={group.label} />}
-              </For>
-            )}
+          <For each={rows()}>
+            {(row) => <ResultRow icon={aiToolIcon(row.name)} title={text(titles()[row.name]) || row.name} meta={row.label} />}
           </For>
         </ResultList>
       </Show>

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

@@ -40,7 +40,10 @@ export function PresentToolBlock(props: { block: ToolBlock }) {
         </Show>
       }
     >
-      <div class="inline-flex min-h-7 max-w-full items-center gap-1.5 py-1 text-xs leading-none text-dimmed">
+      <div
+        data-call-id={props.block.callId}
+        class="inline-flex min-h-7 max-w-full items-center gap-1.5 py-1 text-xs leading-none text-dimmed"
+      >
         <i class={`ti ${icon()} shrink-0 text-base leading-none`} aria-hidden="true" />
         <Show
           when={actions.onOpenFile}

package/src/ai/chat/live-turn.browser-harness.tsx

@@ -1,5 +1,5 @@
 import { Chat } from "@k2b/ui";
-import { createMemo } from "solid-js";
+import { createMemo, createSignal } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
 import { render } from "solid-js/web";
 import { emptyProjection, reduceProjection, visibleMessages } from "../client/projection";
@@ -8,11 +8,14 @@ import { AiChatActionsProvider, createAiChatTimeline } from "./presentation";
 
 /**
  * The live chat timeline for a browser test, folded from wire events like the
- * controller does. `window.emit(event)` applies one event, and
- * `window.steer(text)` appends a pending steer as the controller does.
+ * controller does. `window.emit(event)` applies one event,
+ * `window.steer(text)` appends a pending steer as the controller does, and
+ * `window.reconnect(on)` sets whether the stream reconnects.
  */
 const [state, setState] = createStore(emptyProjection());
+const [reconnecting, setReconnecting] = createSignal(false);
 Object.assign(window, {
+  reconnect: (on: boolean) => setReconnecting(on),
   emit: (event: AiWireEvent) => setState(reconcile(reduceProjection(state, event), { key: "id", merge: true })),
   steer: (text: string) =>
     setState("activeTurn", "blocks", (blocks): AiTurnBlock[] => [
@@ -28,7 +31,11 @@ render(
   () => (
     <AiChatActionsProvider actions={{}}>
       {(() => {
-        const items = createAiChatTimeline({ messages: createMemo(() => visibleMessages(state)), activeTurn: () => state.activeTurn });
+        const items = createAiChatTimeline({
+          messages: createMemo(() => visibleMessages(state)),
+          activeTurn: () => state.activeTurn,
+          reconnecting,
+        });
         return <Chat.Timeline items={items()} />;
       })()}
     </AiChatActionsProvider>

package/src/ai/chat/messages.ts

@@ -160,7 +160,10 @@ const messages = i18n.define({
       loadedCount: ({ count }: { count: number }) => `${count} loaded`,
       toolsLoaded: "Loaded",
       toolsAlreadyLoaded: "Already loaded",
-      toolsMissing: "Missing",
+      toolUnknown: "Not found",
+      toolNotOffered: "Not available here",
+      toolNotAllowed: "Not allowed",
+      toolAppOffline: "App not reachable",
       toolsEvicted: "Evicted",
       loadedSkill: ({ name }: { name: string }) => `Loaded skill ${name}`,
       help: "Help",
@@ -347,7 +350,10 @@ const messages = i18n.define({
       loadedCount: ({ count }) => `${count} geladen`,
       toolsLoaded: "Geladen",
       toolsAlreadyLoaded: "Bereits geladen",
-      toolsMissing: "Nicht gefunden",
+      toolUnknown: "Nicht gefunden",
+      toolNotOffered: "Hier nicht verfügbar",
+      toolNotAllowed: "Nicht erlaubt",
+      toolAppOffline: "App nicht erreichbar",
       toolsEvicted: "Entladen",
       loadedSkill: ({ name }) => `Skill ${name} geladen`,
       help: "Hilfe",

package/src/ai/chat/presentation.tsx

@@ -13,7 +13,7 @@ import {
   Show,
 } from "solid-js";
 import type { AiActiveTurn } from "../client/projection";
-import { type AiActiveTurnSegment, splitActiveTurnBlocks } from "../protocol";
+import { type AiActiveTurnSegment, type AiTurnBlock, splitActiveTurnBlocks } from "../protocol";
 import { type AiAssistantTimelineItem, buildAiMessageTimeline } from "../timeline";
 import type { AiConversationTimelineEntry, AiStoredMessage } from "../types";
 import { type AiChatActions, AiChatActionsProvider, createAssistantMessageActions, useAiChatActions } from "./message-actions";
@@ -299,6 +299,7 @@ const activeItems = (
   actions: AiChatActions,
   views: TurnViews,
   duration: Accessor<AiTurnDuration | null>,
+  reconnecting: boolean,
 ): ChatTimelineItem[] => {
   if (!turn) return [];
   const segments = splitActiveTurnBlocks(turn.blocks).flatMap((segment): (AiActiveTurnSegment | SurveySegment)[] =>
@@ -314,6 +315,14 @@ const activeItems = (
   // Until the model takes up the steering message, the segment above it is still the one at work.
   const above = steerTail ? segments.findLastIndex((segment, index) => segment.type === "assistant" && index < lastAssistant) : -1;
   const working = above >= 0 ? above : lastAssistant;
+  const phaseOf = (index: number): AiTurnPhase =>
+    index !== working ? "completed" : turn.status === "waiting_for_action" ? "waiting" : "running";
+  const layoutOf = (blocks: AiTurnBlock[], index: number) =>
+    layoutAiTurn(blocks, { phase: phaseOf(index), codePresentations: Boolean(actions.renderCodePresentation) });
+  // The work line says in place that the turn reconnects. A turn without one yet says it in a row at its end, where a
+  // row that comes and goes moves nothing above it.
+  const workingSegment = segments[working];
+  const reconnectInLine = reconnecting && workingSegment?.type === "assistant" && layoutOf(workingSegment.blocks, working).showWork;
   const segmentId = createSegmentIds();
   let opener = "start";
 
@@ -339,8 +348,8 @@ const activeItems = (
 
     const last = index === lastAssistant;
     const live = index === working;
-    const phase: AiTurnPhase = !live ? "completed" : turn.status === "waiting_for_action" ? "waiting" : "running";
-    const layout = layoutAiTurn(segment.blocks, { phase, codePresentations: Boolean(actions.renderCodePresentation) });
+    const phase = phaseOf(index);
+    const layout = layoutOf(segment.blocks, index);
     // Consecutive steering messages leave empty segments between them; history has none. The last segment stays, since
     // it carries the progress indicator.
     if (!last && isEmptyLayout(layout)) return [];
@@ -358,7 +367,7 @@ const activeItems = (
         layout,
         earlier: !live,
         duration: live ? duration : () => null,
-        retrying: last && turn.providerRetry === true,
+        reconnect: live && reconnectInLine ? "line" : last && reconnecting && !reconnectInLine ? "row" : undefined,
       }),
     };
   });
@@ -367,9 +376,10 @@ const activeItems = (
 /**
  * Work time of the active turn: wall time minus time spent waiting for the user. A state snapshot seeds it after a
  * reconnect; the clock stands while the turn waits for an approval or an answer and continues from the same value
- * afterwards.
+ * afterwards. While `paused`, the shown time stands too and then jumps to the true work time; the clock itself keeps
+ * running, so a step that starts right after the pause is timed from the true work time.
  */
-const createActiveTurnClock = (source: AiChatTimelineSource): Accessor<AiTurnDuration | null> => {
+const createActiveTurnClock = (source: AiChatTimelineSource, paused: Accessor<boolean>): Accessor<AiTurnDuration | null> => {
   const [now, setNow] = createSignal(Date.now());
   const running = createMemo(() => source.activeTurn() !== null);
   createEffect(() => {
@@ -379,7 +389,7 @@ const createActiveTurnClock = (source: AiChatTimelineSource): Accessor<AiTurnDur
     onCleanup(() => window.clearInterval(timer));
   });
   let state: { turnId: string; seed: string; startedAt: number; waitMs: number; waitingSince: number | null } | null = null;
-  return createMemo(() => {
+  const duration = createMemo(() => {
     const turn = source.activeTurn();
     const time = now();
     if (!turn) {
@@ -411,11 +421,19 @@ const createActiveTurnClock = (source: AiChatTimelineSource): Accessor<AiTurnDur
       waitingMs: state.waitingSince === null ? null : Math.max(0, time - state.waitingSince),
     };
   });
+  let shown: AiTurnDuration | null = null;
+  return createMemo(() => {
+    const current = duration();
+    if (!paused() || !shown || !current) shown = current;
+    return shown;
+  });
 };
 
 export type AiChatTimelineSource = {
   messages: Accessor<readonly AiStoredMessage[]>;
   activeTurn: Accessor<AiActiveTurn | null>;
+  /** The conversation stream lost its connection and reconnects, such as `streamStatus() === "reconnecting"`. */
+  reconnecting?: Accessor<boolean>;
 };
 
 /**
@@ -428,9 +446,11 @@ export function createAiChatTimeline(source: AiChatTimelineSource): Accessor<rea
   const locale = useLocale();
   const disclosureState = createAiToolDisclosureState();
   const views = createTurnViews(disclosureState);
-  const clock = createActiveTurnClock(source);
+  // 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));
+  const active = createMemo(() => activeItems(source.activeTurn(), actions, views, clock, reconnecting()));
   return createMemo(() => {
     const items = [...stored(), ...active()];
     views.retain(new Set(items.map((item) => item.id)));