@k2b/cloud 0.6.0 → 0.7.0

package/src/ai/capabilities.ts

@@ -1,13 +1,10 @@
+import { createHelpReader, type HelpReaderFactory } from "../services/help";
+import { createCodeSourceTool } from "./code-source-tools";
+import { CODE_SOURCE_TOOLS } from "./code-source-contracts";
 import { createHash } from "node:crypto";
 import type { Tool, ToolContext, ToolResolver } from "@k2b/nessi";
 import { z } from "zod";
-import {
-  createHelpCatalog,
-  HELP_READ_MAX_CHARS,
-  HELP_SEARCH_MAX_LIMIT,
-  readHelpCatalog,
-  searchHelpCatalog,
-} from "../_internal/help-catalog";
+import { HELP_READ_MAX_CHARS, HELP_SEARCH_MAX_LIMIT, readHelpArticle } from "../_internal/help-catalog";
 import {
   type CapabilityActionManifest,
   type CapabilityActionReview,
@@ -16,8 +13,9 @@ import {
   cloudResourceRefAppId,
   resolveCapabilityResourceReader,
 } from "../contracts/capabilities";
-import type { CapabilityRegistryEntry, HelpRegistryEntry } from "../contracts/registry";
+import type { CapabilityRegistryEntry } from "../contracts/registry";
 import type { RequestActor } from "../server";
+import { recordRejectedAiCapability } from "./capability-execution";
 import { CLOUD_AI_DEFERRED_BUILTIN_TOOL_NAMES } from "./default-tools";
 import { type AiToolPreparationContext, defineAiTool, type PreparedAiTools, prepareAiTools } from "./tools";
 import type { AiConversationService, AiRuntimeTool, AiToolPresentation } from "./types";
@@ -304,14 +302,14 @@ const AiHelpDocumentSchema = AiHelpCatalogItemSchema.extend({
   truncated: z.boolean(),
 }).strict();
 
-/** Search and read the live Help snapshot without loading one tool per article. */
-export const createAiHelpTools = (registry: readonly HelpRegistryEntry[], locale = "en"): AiRuntimeTool[] => {
-  const documents = createHelpCatalog(registry, locale);
+/** Search and read published Help without loading one tool per article. */
+export const createAiHelpTools = (help: HelpReaderFactory = createHelpReader, locale = "en"): AiRuntimeTool[] => {
+  const reader = help(locale);
 
   const search = defineAiTool({
     name: "search_help",
     description:
-      "Search installed Cloud app Help when product behavior, settings, workflows, permissions, or app errors are unclear. Use 1-3 concise English product terms and scope appId when known. Returns compact document ids for read_help; skip this tool for straightforward live-data requests.",
+      "Search installed Cloud app Help when product behavior, settings, workflows, permissions, or app errors are unclear. Use concise product terms in the request language and scope appId when known. Returns compact document ids for read_help; skip this tool for straightforward live-data requests.",
     inputSchema: z
       .object({
         query: z.string().trim().min(1).max(200).describe("Product task or concept to find."),
@@ -322,7 +320,7 @@ export const createAiHelpTools = (registry: readonly HelpRegistryEntry[], locale
     outputSchema: z.object({ documents: z.array(AiHelpCatalogItemSchema).max(HELP_SEARCH_MAX_LIMIT) }).strict(),
     approval: "never",
   }).server(async ({ query, appId, limit }) => ({
-    documents: searchHelpCatalog(documents, { query, appId, limit: boundedLimit(limit, DEFAULT_SEARCH_LIMIT, HELP_SEARCH_MAX_LIMIT) }),
+    documents: await reader.search({ query, appId, limit: boundedLimit(limit, DEFAULT_SEARCH_LIMIT, HELP_SEARCH_MAX_LIMIT) }),
   }));
 
   const read = defineAiTool({
@@ -338,25 +336,14 @@ export const createAiHelpTools = (registry: readonly HelpRegistryEntry[], locale
       .strict(),
     outputSchema: z.object({ document: AiHelpDocumentSchema.nullable() }).strict(),
     approval: "never",
-  }).server(async ({ appId, documentId, query }) => ({
-    document: readHelpCatalog(documents, { appId, documentId, query }),
-  }));
+  }).server(async ({ appId, documentId, query }) => {
+    const document = await reader.read({ appId, documentId });
+    return { document: document ? readHelpArticle(document, query) : null };
+  });
 
   return [search, read];
 };
 
-const resolveHelpRegistry = async (
-  listRegistry: () => Promise<HelpRegistryEntry[]>,
-  onError?: (error: unknown) => void,
-): Promise<HelpRegistryEntry[]> => {
-  try {
-    return await listRegistry();
-  } catch (error) {
-    onError?.(error);
-    return [];
-  }
-};
-
 const resolveCapabilityRegistry = async (
   listRegistry: () => Promise<CapabilityRegistryEntry[]>,
   onError?: (error: unknown) => void,
@@ -554,7 +541,9 @@ export const createAiToolMetaTools = (input: {
 export const createLoadedAiCapabilityTools = (input: {
   catalog: readonly AiCapabilityCatalogEntry[];
   loadedNames: readonly string[];
+  actor: RequestActor;
   review?: (entry: AiCapabilityCatalogEntry, args: unknown, context: ToolContext) => Promise<CapabilityActionReview | null>;
+  authorizeBackground?: (entry: AiCapabilityCatalogEntry, args: unknown) => Promise<void>;
   onReview?: (callId: string, review: CapabilityActionReview) => void;
   execute: (entry: AiCapabilityCatalogEntry, args: unknown, context: ToolContext) => Promise<unknown>;
 }): AiRuntimeTool[] => {
@@ -573,12 +562,18 @@ export const createLoadedAiCapabilityTools = (input: {
         // live review has resolved. The review may supply an app-owned scope.
         approval: "never",
       }).server(async (args, context) => {
-        if (entry.kind === "action") {
+        await input.authorizeBackground?.(entry, args);
+        if (!input.authorizeBackground && entry.kind === "action" && (entry.operation as CapabilityActionManifest).approval !== "none") {
           const review = (await input.review?.(entry, args, context)) ?? null;
           if (review && context.callId) input.onReview?.(context.callId, review);
           const message =
             review?.message ?? `${entry.appName}: ${entry.title}\nReview the validated arguments below before running this Action.`;
-          if (!(await context.requestApproval(message))) throw new Error("Capability Action was rejected by the user.");
+          if (!(await context.requestApproval(message))) {
+            if (input.actor.kind === "user") {
+              await recordRejectedAiCapability({ entry, actor: input.actor, args }).catch(() => undefined);
+            }
+            throw new Error("Capability Action was rejected by the user.");
+          }
         }
         return input.execute(entry, args, context);
       }),
@@ -599,6 +594,11 @@ export const createAiResourceReaderTool = (input: {
     outputSchema: z.unknown(),
     approval: "never",
   }).server(async (ref, context) => {
+    if (ref.type === "assistant.artifact") {
+      const tool = createCodeSourceTool("code_read");
+      if (tool.location !== "server") throw new Error("Code reader must execute on the server.");
+      return tool.run(CODE_SOURCE_TOOLS.code_read.input.parse({ id: ref.id }), context);
+    }
     const appId = cloudResourceRefAppId(ref);
     const app = input.apps.find((candidate) => candidate.appId === appId);
     const reader = app ? resolveCapabilityResourceReader(app.manifest, ref) : null;
@@ -611,6 +611,24 @@ export const createAiResourceReaderTool = (input: {
   });
 
 /** Nessi resolver: one registry/load-state snapshot drives discovery, loading, schemas, and execution per model turn. */
+/** Background discovery belongs to one run, never the interactive conversation. */
+export const createRunToolStore = (initialNames: readonly string[]): Pick<AiConversationService, "getLoadedTools" | "loadTools"> => {
+  let current = [...new Set(initialNames)];
+  return {
+    getLoadedTools: async () => [...current],
+    loadTools: async ({ names, maxLoadedTools }) => {
+      const requested = [...new Set(names.map((name) => name.trim()).filter(Boolean))];
+      const alreadyLoaded = requested.filter((name) => current.includes(name));
+      const added = requested.filter((name) => !current.includes(name));
+      const combined = [...current, ...added];
+      const limit = Math.floor(maxLoadedTools ?? 0);
+      const evicted = limit > 0 ? combined.slice(0, Math.max(0, combined.length - limit)) : [];
+      current = combined.slice(evicted.length);
+      return { loaded: added.filter((name) => current.includes(name)), alreadyLoaded, evicted };
+    },
+  };
+};
+
 export const createAiToolResolver =
   (input: {
     conversationId: string;
@@ -621,12 +639,12 @@ export const createAiToolResolver =
     store: Pick<AiConversationService, "getLoadedTools" | "loadTools">;
     listRegistry?: () => Promise<CapabilityRegistryEntry[]>;
     onCapabilityRegistryError?: (error: unknown) => void;
-    listHelpRegistry?: () => Promise<HelpRegistryEntry[]>;
-    onHelpRegistryError?: (error: unknown) => void;
+    help?: HelpReaderFactory;
     locale?: string;
     maxLoadedTools?: number;
     execute?: (entry: AiCapabilityCatalogEntry, args: unknown, context: ToolContext) => Promise<unknown>;
     review?: (entry: AiCapabilityCatalogEntry, args: unknown, context: ToolContext) => Promise<CapabilityActionReview | null>;
+    authorizeBackground?: (entry: AiCapabilityCatalogEntry, args: unknown) => Promise<void>;
     onReview?: (callId: string, review: CapabilityActionReview) => void;
     onPrepared?: (snapshot: {
       prepared: PreparedAiTools;
@@ -635,10 +653,9 @@ export const createAiToolResolver =
     }) => void;
   }): ToolResolver =>
   async (): Promise<Tool[]> => {
-    const [registry, persistedLoadedNames, helpRegistry] = await Promise.all([
+    const [registry, persistedLoadedNames] = await Promise.all([
       input.listRegistry ? resolveCapabilityRegistry(input.listRegistry, input.onCapabilityRegistryError) : [],
       input.store.getLoadedTools({ conversationId: input.conversationId }),
-      input.listHelpRegistry ? resolveHelpRegistry(input.listHelpRegistry, input.onHelpRegistryError) : [],
     ]);
     const configuredLimit = Math.floor(input.maxLoadedTools ?? 0);
     const loadedNames = configuredLimit > 0 ? persistedLoadedNames.slice(-configuredLimit) : persistedLoadedNames;
@@ -651,9 +668,9 @@ export const createAiToolResolver =
     }
     const allowed = input.allowedTools == null ? null : new Set(input.allowedTools);
     const capabilityCatalog = buildAiCapabilityCatalog(registry).filter((entry) => !allowed || allowed.has(entry.name));
-    const helpTools = input.listHelpRegistry ? createAiHelpTools(helpRegistry, input.locale) : [];
+    const helpTools = input.help ? createAiHelpTools(input.help, input.locale) : [];
     const resourceTool =
-      input.execute && capabilityCatalog.length > 0
+      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(
@@ -679,8 +696,10 @@ export const createAiToolResolver =
         ? createLoadedAiCapabilityTools({
             catalog: capabilityCatalog,
             loadedNames,
+            actor: input.actor,
             review: input.review,
             onReview: input.onReview,
+            authorizeBackground: input.authorizeBackground,
             execute: input.execute,
           })
         : []),

package/src/ai/capability-execution.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import type { ToolContext } from "@k2b/nessi";
 import { type CapabilityDispatchDependencies, dispatchCapability } from "../api/capabilities";
+import { capabilityValueMeta, recordCapabilityExecution } from "../capabilities/executions";
 import { type CapabilityActionManifest, type CapabilityActionReview, CapabilityActionReviewSchema } from "../contracts/capabilities";
 import type { RequestActor } from "../server";
 import type { AccessSubject } from "../server/services/access";
@@ -98,18 +99,24 @@ const dispatchAiCapability = async (input: AiCapabilityCall, review: boolean): P
   const headers = new Headers();
   if (input.locale) headers.set(LOCALE_HEADER, input.locale);
   const action = input.entry.kind === "action" ? (input.entry.operation as CapabilityActionManifest) : null;
-  if (!review && action?.idempotency === "required" && input.context.callId) {
-    const key = idempotencyKey(input.conversationId, input.context.callId);
-    if (input.turnId) {
-      await aiToolAudit.noteCapabilityDispatch({
-        conversationId: input.conversationId,
-        turnId: input.turnId,
-        callId: input.context.callId,
-        toolName: input.entry.name,
-        idempotencyKey: key,
-      });
-    }
-    headers.set("idempotency-key", key);
+  // One request id per dispatch links the tool call, the platform execution
+  // record, and the target app's own audit rows.
+  const requestId = crypto.randomUUID();
+  headers.set("x-request-id", requestId);
+  const key =
+    !review && action?.idempotency === "required" && input.context.callId
+      ? idempotencyKey(input.conversationId, input.context.callId)
+      : null;
+  if (key) headers.set("idempotency-key", key);
+  if (!review && input.turnId && input.context.callId) {
+    await aiToolAudit.noteCapabilityDispatch({
+      conversationId: input.conversationId,
+      turnId: input.turnId,
+      callId: input.context.callId,
+      toolName: input.entry.name,
+      requestId,
+      idempotencyKey: key,
+    });
   }
   const request = new Request("http://cloud.internal/api/ai/capability", {
     method: "POST",
@@ -120,6 +127,7 @@ const dispatchAiCapability = async (input: AiCapabilityCall, review: boolean): P
     await dispatch({
       request,
       kind: input.entry.kind === "query" ? "queries" : "actions",
+      origin: "assistant",
       review,
       appId: input.entry.appId,
       capabilityId: input.entry.operation.localId,
@@ -149,3 +157,30 @@ export const reviewAiCapability = async (input: AiCapabilityCall): Promise<Capab
 };
 
 export const executeAiCapability = (input: AiCapabilityCall): Promise<unknown> => dispatchAiCapability(input, false);
+
+/**
+ * A rejected approval never reaches the dispatcher, so the assistant records
+ * the same execution row the dispatcher would have written for the attempt.
+ */
+export const recordRejectedAiCapability = async (input: {
+  entry: Pick<AiCapabilityCatalogEntry, "appId" | "kind" | "name" | "operation">;
+  actor: CapabilityActor;
+  args: unknown;
+}): Promise<void> => {
+  const at = new Date();
+  await recordCapabilityExecution({
+    requestId: crypto.randomUUID(),
+    origin: "assistant",
+    appId: input.entry.appId,
+    capability: input.entry.name,
+    kind: input.entry.kind,
+    destructive: "destructive" in input.entry.operation ? input.entry.operation.destructive : false,
+    actorKind: "user",
+    actorId: input.actor.user.id,
+    userId: input.actor.user.id,
+    status: "rejected",
+    inputMeta: capabilityValueMeta(input.args),
+    startedAt: at,
+    completedAt: at,
+  });
+};

package/src/ai/chat/blocks.tsx

@@ -1,9 +1,11 @@
+import { hasCapabilityTable } from "./capability-result";
 import { dates } from "@k2b/stdlib";
 import { mutation } from "@k2b/stdlib/solid";
-import { Button, ButtonLink, Chat, isStructuredDataValue, SplitButton, StructuredDataPreview, useLocale } from "@k2b/ui";
-import { createSignal, For, type JSX, Match, Show, Switch } from "solid-js";
+import { Button, ButtonLink, Chat, MarkdownView, isStructuredDataValue, SplitButton, StructuredDataPreview, useLocale } from "@k2b/ui";
+import { createMemo, createSignal, For, type JSX, Match, Show, Switch } from "solid-js";
 import type { CapabilityActionReview } from "../../contracts/capabilities";
 import { markdown } from "../../shared";
+import { groupToolBlocks, isFailedTool, summarizeToolGroup } from "./tool-groups";
 import type { AiTurnBlock } from "../protocol";
 import { isRenderableTurnBlock } from "../protocol";
 import { hasSpecializedBuiltinToolView, SpecializedBuiltinToolBlock } from "./builtin-tools";
@@ -288,14 +290,23 @@ function ApprovalBlockView(props: { turnId: string; block: ToolBlock }) {
                 {(detail) => (
                   <section class="min-w-0" aria-label={detail.label}>
                     <h4 class="mb-1.5 font-semibold text-primary">{detail.label}</h4>
-                    <pre
-                      class="max-h-72 overflow-auto whitespace-pre-wrap break-words pr-2 font-sans text-xs leading-5 text-secondary"
-                      role="region"
-                      tabIndex={0}
-                      aria-label={`${detail.label} content`}
+                    <Show
+                      when={detail.format === "markdown"}
+                      fallback={
+                        <pre
+                          class="max-h-72 overflow-auto whitespace-pre-wrap break-words pr-2 font-sans text-xs leading-5 text-secondary"
+                          role="region"
+                          tabIndex={0}
+                          aria-label={`${detail.label} content`}
+                        >
+                          <ReviewDetailValue detail={detail} />
+                        </pre>
+                      }
                     >
-                      <ReviewDetailValue detail={detail} />
-                    </pre>
+                      <div class="max-h-72 overflow-auto text-xs text-secondary" role="region" tabIndex={0} aria-label={detail.label}>
+                        <MarkdownView class="cloud-ai-approval-detail" markdown={detail.value} headingScale="compact" allowImages={false} />
+                      </div>
+                    </Show>
                   </section>
                 )}
               </For>
@@ -496,9 +507,6 @@ function CapabilityToolView(props: { block: ToolBlock }) {
           </Show>
         </Show>
       </Show>
-      <Show when={props.block.status !== "running" && !props.block.isError}>
-        <CapabilityTablePreview result={props.block.result} label={label()} />
-      </Show>
     </>
   );
 }
@@ -618,85 +626,138 @@ function MemoryToolView(props: { block: ToolBlock }) {
 }
 
 function ToolBlockView(props: { turnId: string; block: ToolBlock; active?: boolean }) {
+  const actions = useAiChatActions();
   const status = () => props.block.status;
   const fetchError = () =>
     props.block.name === "fetch_file" && props.block.isError ? fetchFileErrorPresentation(props.block.result) : undefined;
   return (
-    <Switch
-      fallback={
-        <ToolResultDisclosure
-          blockId={props.block.id}
-          name={displayToolName(props.block.name)}
-          toolName={props.block.name}
-          args={props.block.args}
-          result={props.block.result}
-          isError={Boolean(props.block.isError)}
-          errorLabel={fetchError()?.label}
-          errorDescription={fetchError()?.description}
-        />
-      }
-    >
-      <Match when={status() === "awaiting_approval"}>
-        <ApprovalBlockView turnId={props.turnId} block={props.block} />
-      </Match>
-      <Match when={status() === "rejected"}>
-        <RejectedToolView block={props.block} />
-      </Match>
-      <Match when={props.block.presentation?.kind === "capability"}>
-        <CapabilityToolView block={props.block} />
-      </Match>
-      <Match when={props.block.name === "present" && !props.block.isError}>
-        <PresentToolBlock block={props.block} />
-      </Match>
-      <Match when={props.block.name === "web_search" && !props.block.isError}>
-        <WebSearchToolBlock block={props.block} />
-      </Match>
-      <Match when={props.block.name === "web_extract" && !props.block.isError}>
-        <WebExtractToolBlock block={props.block} />
-      </Match>
-      <Match when={props.block.name === "fetch_file" && !props.block.isError}>
-        <FetchFileToolBlock block={props.block} />
-      </Match>
-      <Match when={props.block.name === "memory"}>
-        <MemoryToolView block={props.block} />
-      </Match>
-      <Match when={hasSpecializedBuiltinToolView(props.block.name, props.block.result) && status() === "completed" && !props.block.isError}>
-        <SpecializedBuiltinToolBlock block={props.block} />
+    <>
+      <Switch
+        fallback={
+          <ToolResultDisclosure
+            blockId={props.block.id}
+            name={displayToolName(props.block.name)}
+            toolName={props.block.name}
+            args={props.block.args}
+            result={props.block.result}
+            isError={Boolean(props.block.isError)}
+            errorLabel={fetchError()?.label}
+            errorDescription={fetchError()?.description}
+          />
+        }
+      >
+        <Match when={status() === "awaiting_approval"}>
+          <ApprovalBlockView turnId={props.turnId} block={props.block} />
+        </Match>
+        <Match when={status() === "rejected"}>
+          <RejectedToolView block={props.block} />
+        </Match>
+        <Match when={props.block.presentation?.kind === "capability"}>
+          <CapabilityToolView block={props.block} />
+        </Match>
+        <Match when={actions.renderCodePresentation && props.block.name === "code_present" && status() === "completed" && !props.block.isError}>
+          {actions.renderCodePresentation?.(props.block.result)}
+        </Match>
+        <Match when={props.block.name === "present" && !props.block.isError}>
+          <PresentToolBlock block={props.block} />
+        </Match>
+        <Match when={props.block.name === "web_search" && !props.block.isError}>
+          <WebSearchToolBlock block={props.block} />
+        </Match>
+        <Match when={props.block.name === "web_extract" && !props.block.isError}>
+          <WebExtractToolBlock block={props.block} />
+        </Match>
+        <Match when={props.block.name === "fetch_file" && !props.block.isError}>
+          <FetchFileToolBlock block={props.block} />
+        </Match>
+        <Match when={props.block.name === "memory"}>
+          <MemoryToolView block={props.block} />
+        </Match>
+        <Match when={hasSpecializedBuiltinToolView(props.block.name, props.block.result) && status() === "completed" && !props.block.isError}>
+          <SpecializedBuiltinToolBlock block={props.block} />
+        </Match>
+        <Match when={isCardToolName(props.block.name) && !props.block.isError}>
+          <CloudCardBlock args={props.block.args} />
+        </Match>
+        <Match when={isSurveyToolName(props.block.name) && !props.block.isError}>
+          <SurveyToolView turnId={props.turnId} block={props.block} active={props.active} />
+        </Match>
+        <Match when={isTextEditorToolName(props.block.name)}>
+          <TextEditorToolView turnId={props.turnId} block={props.block} active={props.active} />
+        </Match>
+        <Match when={status() === "running" || status() === "awaiting_client"}>
+          <Chat.Activity label={displayToolName(props.block.name)} icon={aiToolIcon(props.block.name)} busy />
+        </Match>
+      </Switch>
+      <Show when={hasCapabilityTable(props.block)}>
+        <CapabilityTablePreview result={props.block.result} label={props.block.presentation?.title ?? displayToolName(props.block.name)} />
+      </Show>
+    </>
+  );
+}
+
+/** Render one unified turn block. Shared by persisted assistant groups and the live turn. */
+export function AiTurnBlockView(props: { block: AiTurnBlock; turnId: string; streaming?: boolean; active?: boolean }) {
+  // The id/kind remain stable while the immutable block value changes during a turn.
+  return (
+    <Switch>
+      <Match when={props.block.kind === "text" && props.block}>
+        {block => <AssistantMarkdownBlock html={markdown.renderSync(block().text)} />}
       </Match>
-      <Match when={isCardToolName(props.block.name) && !props.block.isError}>
-        <CloudCardBlock args={props.block.args} />
+      <Match when={props.block.kind === "thinking" && props.block}>
+        {block => <ThinkingBlockView text={block().text} streaming={props.streaming} />}
       </Match>
-      <Match when={isSurveyToolName(props.block.name) && !props.block.isError}>
-        <SurveyToolView turnId={props.turnId} block={props.block} active={props.active} />
+      <Match when={props.block.kind === "steer_applied"}>
+        <Chat.Activity label="Conversation steered" icon="ti ti-route" tone="ai" />
       </Match>
-      <Match when={isTextEditorToolName(props.block.name)}>
-        <TextEditorToolView turnId={props.turnId} block={props.block} active={props.active} />
+      <Match when={props.block.kind === "tool" && props.block}>
+        {block => <ToolBlockView turnId={props.turnId} block={block()} active={props.active} />}
       </Match>
-      <Match when={status() === "running" || status() === "awaiting_client"}>
-        <Chat.Activity label={displayToolName(props.block.name)} icon={aiToolIcon(props.block.name)} busy />
+      <Match when={props.block.kind === "compaction" && props.block}>
+        {block => <CompactionBlockView block={block()} />}
       </Match>
     </Switch>
   );
 }
 
-/** Render one unified turn block. Shared by persisted assistant groups and the live turn. */
-export function AiTurnBlockView(props: { block: AiTurnBlock; turnId: string; streaming?: boolean; active?: boolean }) {
-  // block.kind is immutable for a given block id, so this switch may run once.
-  const block = props.block;
-  switch (block.kind) {
-    case "text":
-      return <AssistantMarkdownBlock html={markdown.renderSync(block.text)} />;
-    case "thinking":
-      return <ThinkingBlockView text={block.text} streaming={props.streaming} />;
-    case "steer_message":
-      return null;
-    case "steer_applied":
-      return <Chat.Activity label="Conversation steered" icon="ti ti-route" tone="ai" />;
-    case "tool":
-      return <ToolBlockView turnId={props.turnId} block={block} active={props.active} />;
-    case "compaction":
-      return <CompactionBlockView block={block} />;
-  }
+function CompactToolRow(props: { block: ToolBlock; busy?: boolean }) {
+  const locale = useLocale();
+  const de = () => locale().startsWith("de");
+  const args = () => isRecord(props.block.args) ? props.block.args : {};
+  const detail = () => [args().path, args().name, args().query].find((value) => typeof value === "string");
+  const waiting = () => props.block.status === "awaiting_client";
+  return <AiToolActivity blockId={props.block.id} label={props.block.presentation?.title ?? displayToolName(props.block.name)}
+    description={[props.block.status === "running" ? props.block.progress ?? "" : "", typeof detail() === "string" ? String(detail()) : "", waiting() ? (de() ? "Wartet" : "Waiting") : isFailedTool(props.block) ? (de() ? "Fehlgeschlagen" : "Failed") : ""].filter(Boolean).join(" · ")}
+    icon={waiting() ? "ti ti-clock" : aiToolIcon(props.block.name, props.block.presentation?.appIcon)}
+    tone={isFailedTool(props.block) ? "danger" : "neutral"} busy={props.busy && !waiting()} bodyInset={false} renderBody={() =>
+    <div class="max-h-72 overflow-auto overscroll-contain rounded-md bg-zinc-100 p-3 dark:bg-zinc-950" tabIndex={0} role="region" aria-label={de() ? "Werkzeug-Eingabe und Ausgabe" : "Tool input and output"}>
+      <ToolDetail title={de() ? "Eingabe" : "Input"} toolName={props.block.name} value={props.block.args} />
+      <ToolDetail title={de() ? "Ausgabe" : "Output"} toolName={props.block.name} value={props.block.result} />
+    </div>}
+  />;
+}
+
+function ToolGroupView(props: { blocks: ToolBlock[]; active: boolean }) {
+  const locale = useLocale();
+  const last = () => props.blocks.at(-1)!;
+  const waiting = () => last().status === "awaiting_client";
+  const multiple = () => props.blocks.length > 1;
+  const detail = () => {
+    const args = last().args;
+    return isRecord(args) ? [args.path,args.name,args.query].find(value=>typeof value==="string") : undefined;
+  };
+  return <AiToolActivity blockId={`group:${props.blocks[0]!.id}`} bodyInset={false}
+    label={props.active || !multiple() ? (last().presentation?.title ?? displayToolName(last().name)) : summarizeToolGroup(props.blocks, locale())}
+    description={waiting() ? (locale().startsWith("de") ? "Wartet" : "Waiting") : last().status === "running" ? last().progress : !multiple() && typeof detail()==="string" ? String(detail()) : undefined}
+    icon={props.active || !multiple() ? (waiting() ? "ti ti-clock" : aiToolIcon(last().name)) : "ti ti-stack"}
+    tone={!multiple() && isFailedTool(last()) ? "danger" : "neutral"}
+    busy={props.active && !waiting()} renderBody={() => <Show when={multiple()} fallback={
+      <div class="max-h-72 overflow-auto overscroll-contain rounded-md bg-zinc-100 p-3 dark:bg-zinc-950" tabIndex={0} role="region" aria-label={locale().startsWith("de") ? "Werkzeug-Eingabe und Ausgabe" : "Tool input and output"}>
+        <ToolDetail title={locale().startsWith("de") ? "Eingabe" : "Input"} toolName={last().name} value={last().args} />
+        <ToolDetail title={locale().startsWith("de") ? "Ausgabe" : "Output"} toolName={last().name} value={last().result} />
+      </div>
+    }><For each={props.blocks}>{(block) => <CompactToolRow block={block} />}</For></Show>}
+    />;
 }
 
 export function AiTurnBlockList(props: {
@@ -707,24 +768,25 @@ export function AiTurnBlockList(props: {
   active?: boolean;
   disclosureState?: AiToolDisclosureState;
 }) {
-  const visible = () => props.blocks.filter(isRenderableTurnBlock);
+  const groups = createMemo(() => groupToolBlocks(props.blocks.filter(isRenderableTurnBlock)));
+  const keyedGroups = createMemo(() => new Map(groups().map(group => [group.kind === "tools" ? `tools:${group.blocks[0]!.id}` : `block:${group.block.id}`, group])));
+  const keys = createMemo(() => [...keyedGroups().keys()]);
   const disclosureState = props.disclosureState ?? createAiToolDisclosureState();
   return (
-    <Show when={visible().length > 0}>
-      <AiToolDisclosureProvider state={disclosureState}>
-        <div class={`flex flex-col ${props.compact ? "gap-1" : "gap-2"}`}>
-          <For each={visible()}>
-            {(block, index) => (
-              <AiTurnBlockView
-                block={block}
-                turnId={props.turnId}
-                streaming={props.streaming && index() === visible().length - 1}
-                active={props.active}
-              />
-            )}
-          </For>
-        </div>
-      </AiToolDisclosureProvider>
-    </Show>
+    <Show when={groups().length > 0}><AiToolDisclosureProvider state={disclosureState}>
+      <div class={`flex flex-col ${props.compact ? "gap-1" : "gap-2"}`}>
+        <For each={keys()}>{(key, index) => {
+          const group = () => keyedGroups().get(key)!;
+          return <Switch>
+            <Match when={(() => { const value = group(); return value.kind === "tools" ? value : undefined; })()}>
+              {(tools) => <ToolGroupView blocks={tools().blocks} active={Boolean(props.active && index() === keys().length - 1)} />}
+            </Match>
+            <Match when={(() => { const value = group(); return value.kind === "block" ? value : undefined; })()}>
+              {(item) => <AiTurnBlockView block={item().block} turnId={props.turnId} streaming={props.streaming && index() === keys().length - 1} active={props.active} />}
+            </Match>
+          </Switch>;
+        }}</For>
+      </div>
+    </AiToolDisclosureProvider></Show>
   );
 }

package/src/ai/chat/capability-result.ts

@@ -0,0 +1,15 @@
+import { CapabilityTablePresentationSchema, capabilityDataAtPath } from "../../contracts/capabilities";
+import type { AiTurnBlock } from "../protocol";
+
+export const capabilityTable = (result: unknown) => {
+  if (!result || typeof result !== "object") return null;
+  const presentation = CapabilityTablePresentationSchema.safeParse(capabilityDataAtPath(result, ["presentation"]));
+  if (!presentation.success) return null;
+  const rows = capabilityDataAtPath(capabilityDataAtPath(result, ["data"]), presentation.data.rowsPath);
+  if (!Array.isArray(rows)) return null;
+  return { presentation: presentation.data, rows };
+};
+
+/** Result presentation is independent of optional app branding. */
+export const hasCapabilityTable = (block: Extract<AiTurnBlock, { kind: "tool" }>): boolean =>
+  block.status === "completed" && !block.isError && capabilityTable(block.result) !== null;

package/src/ai/chat/capability-table.tsx

@@ -1,17 +1,9 @@
+import { capabilityTable } from "./capability-result";
 import { ButtonLink, DataTable, type DataTableColumn, useLocale } from "@k2b/ui";
 import { createMemo, For, Show } from "solid-js";
-import { CapabilitySemanticLinkSchema, CapabilityTablePresentationSchema, capabilityDataAtPath } from "../../contracts/capabilities";
+import { CapabilitySemanticLinkSchema, capabilityDataAtPath } from "../../contracts/capabilities";
 import { aiChatMessages } from "./messages";
 
-export const capabilityTable = (result: unknown) => {
-  if (!result || typeof result !== "object") return null;
-  const presentation = CapabilityTablePresentationSchema.safeParse(capabilityDataAtPath(result, ["presentation"]));
-  if (!presentation.success) return null;
-  const rows = capabilityDataAtPath(capabilityDataAtPath(result, ["data"]), presentation.data.rowsPath);
-  if (!Array.isArray(rows)) return null;
-  return { presentation: presentation.data, rows };
-};
-
 export const capabilityCellText = (value: unknown): string => {
   if (value === undefined || value === null) return "—";
   if (typeof value === "string") return value;