@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.3

package/dist/lib/components/tool-widgets/ToolCard.svelte

@@ -0,0 +1,186 @@
+<script lang="ts">import * as z from "zod/v4";
+import { cn } from "../../utils.js";
+import { Icon } from "../icon/index.js";
+import { Badge } from "../ui/badge/index.js";
+import { getToolWidgetPresentation, hasToolWidgetPresentation } from "./tool-widget-context.js";
+import { iconForTool, titleForTool, toolStatusMeta, formatDuration, toolEvaluationLine } from "./tool-meta.js";
+let { tool, compact = false, icon, title, defaultOpen, actions, children, class: className, ...restProps } = $props();
+const presentation = hasToolWidgetPresentation() ? getToolWidgetPresentation() : undefined;
+const headerActions = $derived(actions ?? presentation?.actions);
+const status = $derived(String(tool.status ?? "completed"));
+const meta = $derived(toolStatusMeta(status));
+const displayTitle = $derived(title ?? tool.title ?? titleForTool(tool.name));
+const leadingIcon = $derived(icon ?? iconForTool(tool.name));
+const isRunning = $derived(status === "running" || status === "pending" || status === "streaming");
+const isInterrupted = $derived(status === "cancelled" || status === "interrupted");
+const isTimedOut = $derived(status === "timeout");
+const isFailed = $derived(status === "failed" || status === "denied" || status === "error" || Boolean(tool.error) && !isInterrupted && !isTimedOut);
+const isCompleted = $derived(status === "completed" || status === "complete");
+const durationLabel = $derived(formatDuration(tool.durationMs));
+const evaluation = $derived(toolEvaluationLine(tool.evaluation));
+// A terminal call always surfaces its explanation in the body, even when a
+// bespoke widget renders no children. Interruption/cancellation stays
+// neutral; only actual failures use destructive chrome.
+const ErrorText = z.string().trim().min(1);
+const hasError = $derived(ErrorText.safeParse(tool.error).success);
+const hasBody = $derived(Boolean(children) || hasError);
+// `open` is user-controlled once toggled; until then it follows `defaultOpen`,
+// falling back to auto-expand on a terminal explanation.
+let userOpen = $state(null);
+const open = $derived(userOpen ?? defaultOpen ?? hasError);
+</script>
+
+<div
+	{...restProps}
+	class={cn(
+		'overflow-hidden rounded-lg border border-border/60 bg-muted/30 shadow-sm transition-colors',
+		isFailed && 'border-destructive/30 bg-destructive/5',
+		isTimedOut && 'border-warning/30 bg-warning/5',
+		isRunning && !isFailed && 'tool-card-live',
+		className
+	)}
+	data-tool={tool.name}
+	data-status={status}
+>
+	<div
+		data-tool-card-header
+		class={cn('flex min-h-11 w-full items-stretch transition-colors', compact && 'min-h-9')}
+	>
+		<button
+			type="button"
+			class={cn(
+				'flex min-w-0 flex-1 items-center gap-2 py-2 pl-3 text-left transition-colors',
+				compact && 'py-1.5 pl-2.5',
+				headerActions ? 'pr-1' : compact ? 'pr-2.5' : 'pr-3',
+				hasBody ? 'cursor-pointer hover:bg-accent/40' : 'cursor-default'
+			)}
+			aria-expanded={hasBody ? open : undefined}
+			disabled={!hasBody}
+			onclick={() => {
+				if (hasBody) userOpen = !open;
+			}}
+		>
+			<span
+				class={cn(
+					'grid shrink-0 place-items-center rounded-lg ring-1 ring-border/50 ring-inset',
+					compact ? 'size-6' : 'size-7',
+					isFailed
+						? 'bg-destructive/10 text-destructive ring-destructive/30'
+						: isTimedOut
+							? 'bg-warning/10 text-warning-ink ring-warning/30'
+							: 'bg-foreground/8 text-foreground/80'
+				)}
+			>
+				{#if isRunning}
+					<Icon icon="lucide:loader-circle" class="size-4 animate-spin text-muted-foreground" />
+				{:else}
+					<Icon icon={leadingIcon} class={compact ? 'size-3.5' : 'size-4'} />
+				{/if}
+			</span>
+
+			<span class="min-w-0 flex-1">
+				<span
+					class={cn('block truncate font-medium text-foreground', compact ? 'text-xs' : 'text-sm')}
+				>
+					{displayTitle}
+				</span>
+				{#if evaluation}
+					<span
+						class={cn(
+							'block truncate text-caption font-normal',
+							evaluation.degraded ? 'text-warning-ink' : 'text-muted-foreground'
+						)}
+						data-evaluation-line={tool.evaluation?.status ?? ''}
+						title={tool.evaluation?.modelId ?? undefined}
+					>
+						{evaluation.summary}
+					</span>
+					{#if evaluation.chips.length > 0}
+						<span class="mt-0.5 flex flex-wrap gap-1">
+							{#each evaluation.chips as chip (chip)}
+								<Badge variant="outline" class="px-1 py-px text-caption font-normal tabular-nums">
+									{chip}
+								</Badge>
+							{/each}
+						</span>
+					{/if}
+				{/if}
+			</span>
+
+			{#if durationLabel}
+				<span class="shrink-0 text-caption font-normal text-muted-foreground tabular-nums"
+					>{durationLabel}</span
+				>
+			{/if}
+
+			{#if isCompleted}
+				<Icon
+					icon="lucide:check"
+					title="Completed"
+					class="size-3.5 shrink-0 text-muted-foreground"
+				/>
+			{:else if meta}
+				<Badge variant={meta.variant} class="shrink-0 text-caption font-medium">{meta.label}</Badge>
+			{/if}
+
+			{#if hasBody}
+				<Icon
+					icon="lucide:chevron-down"
+					class={cn(
+						'size-4 shrink-0 text-muted-foreground transition-transform duration-200',
+						open && 'rotate-180'
+					)}
+				/>
+			{/if}
+		</button>
+
+		{#if headerActions}
+			<div
+				data-tool-card-actions
+				class={cn('flex shrink-0 items-center gap-1', compact ? 'pr-2.5' : 'pr-3')}
+			>
+				{@render headerActions(tool)}
+			</div>
+		{/if}
+	</div>
+
+	{#if hasBody && open}
+		<div class="tool-card-body-region border-t border-border/50">
+			<div class={cn('space-y-2 px-3 py-2.5', compact && 'px-2.5 py-2')}>
+				{#if hasError}
+					<p
+						class={cn(
+							'rounded-lg px-2.5 py-1.5 text-footnote',
+							isFailed
+								? 'bg-destructive/10 text-destructive-ink'
+								: isTimedOut
+									? 'bg-warning/10 text-warning-ink'
+									: 'bg-muted text-muted-foreground'
+						)}
+					>
+						{tool.error}
+					</p>
+				{/if}
+				{@render children?.()}
+			</div>
+		</div>
+	{/if}
+</div>
+
+<style>
+	/* A live call needs a quiet, persistent cue. The spinner and status badge
+	   already communicate activity; a static themed edge avoids a distracting
+	   loop while preserving the same semantic emphasis. */
+	.tool-card-live {
+		position: relative;
+		border-color: color-mix(in oklab, var(--primary, var(--ring)) 32%, var(--border));
+	}
+
+	.tool-card-body-region {
+		transition: opacity var(--motion-response) var(--ease-settle);
+
+		@starting-style {
+			opacity: 0;
+		}
+	}
+</style>

package/dist/lib/components/tool-widgets/ToolCard.svelte.d.ts

@@ -0,0 +1,26 @@
+/**
+     * ToolCard — the shared chrome for an agent tool call: a header row (icon
+     * tile · title · duration · status badge · chevron) with an optional
+     * collapsible body. The default renderer and every bespoke widget compose
+     * this shell so all tool calls stay visually aligned across surfaces.
+     */
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import type { ToolCallView, ToolWidgetActions } from './types.js';
+interface Props extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'title'> {
+    tool: ToolCallView;
+    compact?: boolean;
+    /** Override the leading icon (`prefix:name`). */
+    icon?: string;
+    /** Override the header title. */
+    title?: string;
+    /** Force initial expand state. Defaults to open when a terminal explanation exists. */
+    defaultOpen?: boolean;
+    /** Host-owned controls rendered in the header without nesting interactive elements. */
+    actions?: ToolWidgetActions;
+    /** Collapsible body. When omitted the card is a non-expandable summary row. */
+    children?: Snippet;
+}
+declare const ToolCard: import("svelte").Component<Props, {}, "">;
+type ToolCard = ReturnType<typeof ToolCard>;
+export default ToolCard;

package/dist/lib/components/tool-widgets/ToolCardBody.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">import { cn } from "../../utils.js";
+let { compact = false, children, class: className, ...restProps } = $props();
+</script>
+
+<div
+	{...restProps}
+	data-slot="tool-card-body"
+	class={cn('space-y-2 text-footnote', compact && 'space-y-1.5', className)}
+>
+	{@render children?.()}
+</div>

package/dist/lib/components/tool-widgets/ToolCardBody.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+interface Props extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    compact?: boolean;
+    children?: Snippet;
+}
+declare const ToolCardBody: import("svelte").Component<Props, {}, "">;
+type ToolCardBody = ReturnType<typeof ToolCardBody>;
+export default ToolCardBody;

package/dist/lib/components/tool-widgets/ToolWidgetStateCard.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">/**
+* Canonical presentation for tool-widget infrastructure state. It preserves
+* the tool's runtime status while naming the separate interface lifecycle.
+*/
+import ToolCard from "./ToolCard.svelte";
+import { titleForTool } from "./tool-meta.js";
+let { tool, state, compact = false, actions } = $props();
+const toolTitle = $derived(tool.title ?? titleForTool(tool.name));
+const loading = $derived(state.kind === "loading");
+const title = $derived(loading ? `Loading ${toolTitle} interface…` : `${toolTitle} interface unavailable`);
+const message = $derived(state.kind === "first-party-missing" ? "This first-party tool has no registered interface in the active runtime." : "The tool interface could not load. Retry after reconnecting the workspace.");
+</script>
+
+<div
+	role={loading ? 'status' : 'alert'}
+	aria-live={loading ? 'polite' : undefined}
+	aria-busy={loading}
+	data-tool-widget-presentation={state.kind}
+>
+	{#if loading}
+		<ToolCard {tool} {compact} {actions} {title} icon="lucide:loader-circle" />
+	{:else}
+		<ToolCard {tool} {compact} {actions} {title} icon="lucide:triangle-alert" defaultOpen={true}>
+			<p class="text-xs text-muted-foreground">{message}</p>
+		</ToolCard>
+	{/if}
+</div>

package/dist/lib/components/tool-widgets/ToolWidgetStateCard.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { ToolCallView, ToolWidgetActions, ToolWidgetInfrastructureState } from './types.js';
+interface Props {
+    tool: ToolCallView;
+    state: ToolWidgetInfrastructureState;
+    compact?: boolean;
+    actions?: ToolWidgetActions;
+}
+declare const ToolWidgetStateCard: import("svelte").Component<Props, {}, "">;
+type ToolWidgetStateCard = ReturnType<typeof ToolWidgetStateCard>;
+export default ToolWidgetStateCard;

package/dist/lib/components/tool-widgets/grouping.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tool-call placement grouping.
+ *
+ * Splits a message's tool calls into the three placement bands declared by the
+ * registry (`top` / `inline` / `bottom`), preserving EMISSION order within each
+ * band. Every chat surface renders tool calls through this one helper so the
+ * arrangement (and the TUI-parity ordering) is identical everywhere — the
+ * heavy lifting lives here, not in each app's message component.
+ */
+import { type ToolWidgetResolver } from './registry.js';
+import type { ToolCallView } from './types.js';
+export interface GroupedToolCalls {
+    /** Pinned above the message body. */
+    top: ToolCallView[];
+    /** In the message body, in emission order (the default). */
+    inline: ToolCallView[];
+    /** Pinned below the message body. */
+    bottom: ToolCallView[];
+}
+/**
+ * Group tool calls by their registered placement, keeping the incoming
+ * (emission) order within each band. Input order is assumed to already be
+ * emission order — `metadata.toolCalls` is appended as the agent emits calls.
+ */
+export declare function groupToolCallsByPlacement(tools: readonly ToolCallView[], resolver?: ToolWidgetResolver): GroupedToolCalls;
+/** Stable key for `{#each}` over tool calls. */
+export declare function toolCallKey(tool: ToolCallView): string;

package/dist/lib/components/tool-widgets/grouping.js

@@ -0,0 +1,26 @@
+/**
+ * Tool-call placement grouping.
+ *
+ * Splits a message's tool calls into the three placement bands declared by the
+ * registry (`top` / `inline` / `bottom`), preserving EMISSION order within each
+ * band. Every chat surface renders tool calls through this one helper so the
+ * arrangement (and the TUI-parity ordering) is identical everywhere — the
+ * heavy lifting lives here, not in each app's message component.
+ */
+import { toolWidgetPlacement } from './registry.js';
+/**
+ * Group tool calls by their registered placement, keeping the incoming
+ * (emission) order within each band. Input order is assumed to already be
+ * emission order — `metadata.toolCalls` is appended as the agent emits calls.
+ */
+export function groupToolCallsByPlacement(tools, resolver) {
+    const grouped = { top: [], inline: [], bottom: [] };
+    for (const tool of tools) {
+        grouped[toolWidgetPlacement(tool.name, resolver)].push(tool);
+    }
+    return grouped;
+}
+/** Stable key for `{#each}` over tool calls. */
+export function toolCallKey(tool) {
+    return tool.id ?? `${tool.name}-${tool.timestamp ?? ''}`;
+}

package/dist/lib/components/tool-widgets/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @vibesdotdev/kit/components/tool-widgets
+ *
+ * The universal tool-call widget layer: a shared `ToolCard` shell, a polished
+ * `DefaultToolCard`, a `ToolCallRenderer` dispatcher, and a registry that
+ * feature `-svelte` packages register bespoke widgets into.
+ */
+export { default as ToolCard } from './ToolCard.svelte';
+export { default as ToolCardBody } from './ToolCardBody.svelte';
+export { default as DefaultToolCard } from './DefaultToolCard.svelte';
+export { default as ToolCallRenderer } from './ToolCallRenderer.svelte';
+export { default as MessageToolCalls } from './MessageToolCalls.svelte';
+export { default as ToolWidgetStateCard } from './ToolWidgetStateCard.svelte';
+export { registerToolWidget, registerToolWidgets, hasToolWidget, isUserAuthoredTool, loadToolWidget, toolWidgetPlacement, clearToolWidgetRegistry, type ToolWidgetComponent, type ToolWidgetLoader, type ToolWidgetPlacement, type ToolWidgetOptions, type ToolWidgetResolver } from './registry.js';
+export { groupToolCallsByPlacement, toolCallKey, type GroupedToolCalls } from './grouping.js';
+export { toolStatusMeta, iconForTool, titleForTool, humanizeToolName, formatToolData, toolBlobLanguage, isRedundantFailureOutput, approvalCopy, formatDuration, toolEvaluationLine, type ToolEvaluationLine, type ToolStatusMeta, type ToolStatusVariant } from './tool-meta.js';
+export type { ToolCallView, ToolWidgetActions, ToolWidgetFallback, ToolWidgetFallbackState, ToolWidgetInfrastructureState, ToolWidgetProps, ToolWidgetStatus, ToolWidgetApproval, ToolCallEvaluationStatus, ToolCallEvaluationView } from './types.js';

package/dist/lib/components/tool-widgets/index.js

@@ -0,0 +1,16 @@
+/**
+ * @vibesdotdev/kit/components/tool-widgets
+ *
+ * The universal tool-call widget layer: a shared `ToolCard` shell, a polished
+ * `DefaultToolCard`, a `ToolCallRenderer` dispatcher, and a registry that
+ * feature `-svelte` packages register bespoke widgets into.
+ */
+export { default as ToolCard } from './ToolCard.svelte';
+export { default as ToolCardBody } from './ToolCardBody.svelte';
+export { default as DefaultToolCard } from './DefaultToolCard.svelte';
+export { default as ToolCallRenderer } from './ToolCallRenderer.svelte';
+export { default as MessageToolCalls } from './MessageToolCalls.svelte';
+export { default as ToolWidgetStateCard } from './ToolWidgetStateCard.svelte';
+export { registerToolWidget, registerToolWidgets, hasToolWidget, isUserAuthoredTool, loadToolWidget, toolWidgetPlacement, clearToolWidgetRegistry } from './registry.js';
+export { groupToolCallsByPlacement, toolCallKey } from './grouping.js';
+export { toolStatusMeta, iconForTool, titleForTool, humanizeToolName, formatToolData, toolBlobLanguage, isRedundantFailureOutput, approvalCopy, formatDuration, toolEvaluationLine } from './tool-meta.js';

package/dist/lib/components/tool-widgets/registry.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Tool-widget registry.
+ *
+ * Maps a tool id to a lazily-imported Svelte component. Feature `-svelte`
+ * packages register bespoke widgets for the tools they own:
+ *
+ *   import { registerToolWidget } from '../../index.ts/components/tool-widgets';
+ *   registerToolWidget('web-search', () => import('./WebSearchToolCard.svelte'));
+ *
+ * `ToolCallRenderer` resolves the registered widget for a tool id. An
+ * unregistered user tool falls back to `DefaultToolCard`; first-party missing,
+ * loading, and load-failed states use explicit non-JSON presentations. The
+ * dynamic import is memoized so repeated renders don't re-trigger it.
+ */
+import type { Component } from 'svelte';
+import type { ToolWidgetProps } from './types.js';
+export type ToolWidgetComponent = Component<ToolWidgetProps>;
+export type ToolWidgetLoader = () => Promise<{
+    default: ToolWidgetComponent;
+}>;
+/**
+ * Where a tool's widget renders within an assistant message:
+ * - `inline` (default): in the message body, in EMISSION order with the other
+ *   inline tool calls (matches the TUI's call-then-summarize timeline).
+ * - `top`: pinned above the message body (and above inline widgets) — for
+ *   high-signal context a reader should see first (e.g. a browser page card).
+ * - `bottom`: pinned below the message body — for trailing artifacts (e.g. a
+ *   "saved to knowledge" confirmation).
+ * Placement is a property of the TOOL (declared at registration), so every
+ * surface arranges tool calls identically without per-app layout logic.
+ */
+export type ToolWidgetPlacement = 'inline' | 'top' | 'bottom';
+export interface ToolWidgetOptions {
+    placement?: ToolWidgetPlacement;
+}
+/**
+ * A host-owned widget scope. Explicit scopes never consult the global registry.
+ * Methods may read reactive state; hosts can also replace the resolver prop to
+ * refresh mounted views when their inventory changes.
+ */
+export interface ToolWidgetResolver {
+    has(toolName: string): boolean;
+    load(toolName: string): Promise<ToolWidgetComponent> | null;
+    placement(toolName: string): ToolWidgetPlacement;
+}
+/** Register a bespoke widget for a tool id. Last registration wins. */
+export declare function registerToolWidget(toolName: string, loader: ToolWidgetLoader, options?: ToolWidgetOptions): void;
+/**
+ * Register many widgets at once. Each value is either a bare loader or a
+ * `{ loader, placement }` pair:
+ *   registerToolWidgets({
+ *     'web-search': () => import('./X.svelte'),
+ *     browser: { loader: () => import('./B.svelte'), placement: 'top' }
+ *   });
+ */
+export declare function registerToolWidgets(entries: Record<string, ToolWidgetLoader | {
+    loader: ToolWidgetLoader;
+    placement?: ToolWidgetPlacement;
+}>): void;
+/** The registered placement for a tool id (defaults to `inline`). */
+export declare function toolWidgetPlacement(toolName: string, resolver?: ToolWidgetResolver): ToolWidgetPlacement;
+export declare function hasToolWidget(toolName: string, resolver?: ToolWidgetResolver): boolean;
+/**
+ * User-authored tools live in `tools.custom-tools` under the `custom:` id prefix.
+ * Only those may fall through to `DefaultToolCard`. First-party tools register a
+ * `tools/ui` widget on both Svelte and TUI.
+ */
+export declare function isUserAuthoredTool(toolName: string): boolean;
+/**
+ * Resolve the registered widget for a tool id, or `null` when none is
+ * registered. The renderer chooses the fallback from the tool's ownership.
+ */
+export declare function loadToolWidget(toolName: string, resolver?: ToolWidgetResolver): Promise<ToolWidgetComponent> | null;
+/** Test / HMR helper — drop all registrations. */
+export declare function clearToolWidgetRegistry(): void;

package/dist/lib/components/tool-widgets/registry.js

@@ -0,0 +1,72 @@
+const registry = new Map();
+const placements = new Map();
+const resolved = new Map();
+/** Register a bespoke widget for a tool id. Last registration wins. */
+export function registerToolWidget(toolName, loader, options) {
+    registry.set(toolName, loader);
+    if (options?.placement && options.placement !== 'inline') {
+        placements.set(toolName, options.placement);
+    }
+    else {
+        placements.delete(toolName);
+    }
+    resolved.delete(toolName);
+}
+/**
+ * Register many widgets at once. Each value is either a bare loader or a
+ * `{ loader, placement }` pair:
+ *   registerToolWidgets({
+ *     'web-search': () => import('./X.svelte'),
+ *     browser: { loader: () => import('./B.svelte'), placement: 'top' }
+ *   });
+ */
+export function registerToolWidgets(entries) {
+    for (const [name, value] of Object.entries(entries)) {
+        if ('loader' in value)
+            registerToolWidget(name, value.loader, { placement: value.placement });
+        else
+            registerToolWidget(name, value);
+    }
+}
+/** The registered placement for a tool id (defaults to `inline`). */
+export function toolWidgetPlacement(toolName, resolver) {
+    if (resolver)
+        return resolver.placement(toolName);
+    return placements.get(toolName) ?? 'inline';
+}
+export function hasToolWidget(toolName, resolver) {
+    if (resolver)
+        return resolver.has(toolName);
+    return registry.has(toolName);
+}
+/**
+ * User-authored tools live in `tools.custom-tools` under the `custom:` id prefix.
+ * Only those may fall through to `DefaultToolCard`. First-party tools register a
+ * `tools/ui` widget on both Svelte and TUI.
+ */
+export function isUserAuthoredTool(toolName) {
+    return toolName.startsWith('custom:');
+}
+/**
+ * Resolve the registered widget for a tool id, or `null` when none is
+ * registered. The renderer chooses the fallback from the tool's ownership.
+ */
+export function loadToolWidget(toolName, resolver) {
+    if (resolver)
+        return resolver.load(toolName);
+    const loader = registry.get(toolName);
+    if (!loader)
+        return null;
+    let promise = resolved.get(toolName);
+    if (!promise) {
+        promise = loader().then((mod) => mod.default);
+        resolved.set(toolName, promise);
+    }
+    return promise;
+}
+/** Test / HMR helper — drop all registrations. */
+export function clearToolWidgetRegistry() {
+    registry.clear();
+    placements.clear();
+    resolved.clear();
+}

package/dist/lib/components/tool-widgets/tool-meta.d.ts

@@ -0,0 +1,39 @@
+import type { ToolCallView } from './types.js';
+import type { BadgeVariant } from '../ui/badge/index.js';
+export type ToolStatusVariant = NonNullable<BadgeVariant>;
+export interface ToolStatusMeta {
+    label: string;
+    variant: ToolStatusVariant;
+}
+/** A tool call's arguments or result, as the owner contract declares them. */
+type ToolPayload = ToolCallView['input'] | ToolCallView['output'];
+export declare function toolStatusMeta(status?: string): ToolStatusMeta | null;
+export declare function iconForTool(name: string): string;
+export declare function humanizeToolName(name: string): string;
+export declare function titleForTool(name: string): string;
+export declare function formatToolData(value: ToolPayload): string;
+/** Language for the default card's CodeViewer. Objects/arrays and JSON strings use json. */
+export declare function toolBlobLanguage(raw: string, value: ToolPayload): string;
+/**
+ * True when the output blob would only echo the failure the ToolCard chrome
+ * already shows: the agent loop's `{ok:false, error}` envelope with the same
+ * message. Callers skip the redundant blob (the input blob stays — it shows
+ * what was attempted).
+ */
+export declare function isRedundantFailureOutput(output: ToolCallView['output'], error: ToolCallView['error']): boolean;
+export declare function approvalCopy(tool: Pick<ToolCallView, 'approval'>): string | null;
+export declare function formatDuration(durationMs?: number): string;
+export interface ToolEvaluationLine {
+    summary: string;
+    chips: string[];
+    degraded: boolean;
+}
+/**
+ * Render model for the tool card's evaluation line.
+ *
+ * `absent` (and missing) evaluation yields null: the card is the
+ * deterministic tool. Everything else renders the producer's summary
+ * plus its scorecard chips; `degraded` flags the amber treatment.
+ */
+export declare function toolEvaluationLine(evaluation: ToolCallView['evaluation']): ToolEvaluationLine | null;
+export {};