@signal9/era-ui 2.8.2 → 2.9.0

package/dist/ai/conversations/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Root } from './conversations-root.svelte';
+export { default as Group } from './conversations-group.svelte';
+export { default as Item } from './conversations-item.svelte';
+export { bucketConversations, ConversationsController } from './conversations.svelte.js';
+export type { ConversationEntry, ConversationGroup, ConversationStatus, TimeBucket } from './conversations.svelte.js';

package/dist/ai/conversations/index.js

@@ -0,0 +1,4 @@
+export { default as Root } from './conversations-root.svelte';
+export { default as Group } from './conversations-group.svelte';
+export { default as Item } from './conversations-item.svelte';
+export { bucketConversations, ConversationsController } from './conversations.svelte.js';

package/dist/ai/error-panel/categorize-error.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Headless error-categorization engine for the ErrorPanel.
+ *
+ * Turns a raw LLM/tool error (an `Error`, a JSON error blob, or a plain
+ * string) into a user-facing classification: a stable `category`, a short
+ * `label`, an actionable `hint`, and a `tone` that drives the panel's icon
+ * and color. Ported from term's llm error-utils.
+ */
+/** Coarse buckets an LLM/tool error can fall into. */
+export type ErrorCategory = 'unknown_tool' | 'tool_unavailable' | 'tool_failed' | 'invalid_args' | 'auth' | 'no_org' | 'no_api_key' | 'generic';
+/** Panel tone — AI/config faults warn, real failures are destructive. */
+export type ErrorTone = 'warning' | 'destructive';
+/** The categorization of an error. */
+export interface ErrorCategorization {
+    category: ErrorCategory;
+    /** Tiny uppercase-ready label, e.g. "Tool Unavailable". */
+    label: string;
+    /** One-line, user-facing guidance. */
+    hint: string;
+    tone: ErrorTone;
+}
+/** Pull a tool name out of a provider message, e.g. `call tool 'run_command'`. */
+export declare function extractToolName(message: string): string | null;
+/** Reduce any raw error input to its human message string. */
+export declare function toErrorMessage(input: unknown): string;
+/** Build the full categorization for a known category. */
+export declare function describeCategory(category: ErrorCategory): ErrorCategorization;
+/**
+ * Categorize a raw error into `{ category, label, hint, tone }`.
+ * Accepts an `Error`, a JSON error blob, or a plain message string.
+ */
+export declare function categorizeError(input: unknown): ErrorCategorization;

package/dist/ai/error-panel/categorize-error.js

@@ -0,0 +1,106 @@
+/**
+ * Headless error-categorization engine for the ErrorPanel.
+ *
+ * Turns a raw LLM/tool error (an `Error`, a JSON error blob, or a plain
+ * string) into a user-facing classification: a stable `category`, a short
+ * `label`, an actionable `hint`, and a `tone` that drives the panel's icon
+ * and color. Ported from term's llm error-utils.
+ */
+const HINTS = {
+    unknown_tool: "The AI tried to use a tool that doesn't exist. This is an AI error, not yours.",
+    tool_unavailable: "You don't have access to this tool. The AI was confused about what's available.",
+    tool_failed: 'The tool ran but reported an error.',
+    invalid_args: 'The AI sent malformed data to the tool.',
+    auth: 'Please log in to continue.',
+    no_org: 'Select an organization from the sidebar.',
+    no_api_key: 'Configure an API key in Organization settings.',
+    generic: 'An unexpected error occurred.'
+};
+const LABELS = {
+    unknown_tool: 'AI Error',
+    tool_unavailable: 'Tool Unavailable',
+    tool_failed: 'Tool Failed',
+    invalid_args: 'Parse Error',
+    auth: 'Auth Error',
+    no_org: 'No Organization',
+    no_api_key: 'Missing API Key',
+    generic: 'Error'
+};
+// AI hallucinations and user-resolvable config gaps warn rather than alarm;
+// only genuine tool failures and unknown errors read as destructive.
+const TONES = {
+    unknown_tool: 'warning',
+    tool_unavailable: 'warning',
+    invalid_args: 'warning',
+    auth: 'warning',
+    no_org: 'warning',
+    no_api_key: 'warning',
+    tool_failed: 'destructive',
+    generic: 'destructive'
+};
+/** Pull a tool name out of a provider message, e.g. `call tool 'run_command'`. */
+export function extractToolName(message) {
+    const match = /attempted to call tool '([^']+)'/.exec(message);
+    return match ? match[1] : null;
+}
+/** Reduce any raw error input to its human message string. */
+export function toErrorMessage(input) {
+    if (input instanceof Error)
+        return input.message;
+    if (typeof input !== 'string') {
+        try {
+            return JSON.stringify(input);
+        }
+        catch {
+            return String(input);
+        }
+    }
+    try {
+        const parsed = JSON.parse(input);
+        if (typeof parsed === 'object' && parsed !== null && 'error' in parsed) {
+            return String(parsed.error);
+        }
+    }
+    catch {
+        // Not JSON — use as-is.
+    }
+    return input;
+}
+function classify(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes('unknown tool:'))
+        return 'unknown_tool';
+    if (lower.includes('was not in request.tools') ||
+        lower.includes('tool call validation failed') ||
+        lower.includes('tool_use_failed')) {
+        return 'tool_unavailable';
+    }
+    if (lower.includes('invalid tool arguments') || lower.includes('malformed json')) {
+        return 'invalid_args';
+    }
+    if (lower === 'unauthorized' || lower.includes('please log in'))
+        return 'auth';
+    if (lower.includes('no organization context'))
+        return 'no_org';
+    if (lower.includes('api key') && (lower.includes('no ') || lower.includes('configured'))) {
+        return 'no_api_key';
+    }
+    if (lower.includes('tool execution failed') || lower.includes('failed'))
+        return 'tool_failed';
+    return 'generic';
+}
+/** Build the full categorization for a known category. */
+export function describeCategory(category) {
+    return { category, label: LABELS[category], hint: HINTS[category], tone: TONES[category] };
+}
+/**
+ * Categorize a raw error into `{ category, label, hint, tone }`.
+ * Accepts an `Error`, a JSON error blob, or a plain message string.
+ */
+export function categorizeError(input) {
+    const message = toErrorMessage(input);
+    const category = classify(message);
+    const described = describeCategory(category);
+    // tool_failed's hint is the real error text — more useful than a generic line.
+    return category === 'tool_failed' ? { ...described, hint: message } : described;
+}

package/dist/ai/error-panel/error-panel.svelte

@@ -0,0 +1,130 @@
+<script lang="ts">
+	import { Collapsible } from 'bits-ui';
+	import TriangleAlert from '@lucide/svelte/icons/triangle-alert';
+	import CircleX from '@lucide/svelte/icons/circle-x';
+	import ChevronDown from '@lucide/svelte/icons/chevron-down';
+	import { cn } from '../../utils/index.js';
+	import { CodeBlock } from '../../ui/code-block/index.js';
+	import {
+		categorizeError,
+		describeCategory,
+		toErrorMessage,
+		type ErrorCategorization,
+		type ErrorCategory
+	} from './categorize-error.js';
+
+	let {
+		open = $bindable(false),
+		error,
+		message,
+		category,
+		detail,
+		hint,
+		children: _children,
+		class: className,
+		...restProps
+	}: Collapsible.RootProps & {
+		/** Raw error to self-categorize (Error, JSON blob, or string). */
+		error?: unknown;
+		/** Override the summary line; defaults to the error's message. */
+		message?: string;
+		/** Force a category instead of inferring one from `error`. */
+		category?: ErrorCategory;
+		/** Raw error text for the expandable CodeBlock; derived from `error` if omitted. */
+		detail?: string;
+		/** Override the guidance line; defaults to the category hint. */
+		hint?: string;
+	} = $props();
+
+	// Self-categorize from the raw error, unless a category is forced.
+	const info = $derived<ErrorCategorization>(
+		category ? describeCategory(category) : categorizeError(error ?? message ?? '')
+	);
+
+	const summary = $derived(message ?? (error !== undefined ? toErrorMessage(error) : info.label));
+	// Skip the guidance line when it just echoes the summary (tool_failed's hint
+	// is the raw message, which the summary already shows).
+	const resolvedHint = $derived(hint ?? info.hint);
+	const guidance = $derived(resolvedHint === summary ? undefined : resolvedHint);
+
+	// Raw detail for the CodeBlock — only when it adds something past the summary.
+	const rawDetail = $derived(detail ?? (error !== undefined ? toErrorMessage(error) : undefined));
+	const showDetail = $derived(!!rawDetail && rawDetail !== summary);
+</script>
+
+{#snippet head()}
+	{#if info.tone === 'warning'}
+		<TriangleAlert class="size-(--era-h-xs) shrink-0 text-warning" aria-hidden="true" />
+	{:else}
+		<CircleX class="size-(--era-h-xs) shrink-0 text-destructive" aria-hidden="true" />
+	{/if}
+	<span class="min-w-0 flex-1 truncate text-fg era-text-trim">{summary}</span>
+{/snippet}
+
+<Collapsible.Root
+	bind:open
+	data-tone={info.tone}
+	class={cn(
+		'group/error flex min-w-0 flex-col gap-(--era-gap) rounded-(--era-rd-lg) bg-(--era-surface-bg) p-(--era-pad-sm) shadow-(--era-shadow)',
+		className
+	)}
+	{...restProps}
+>
+	{#if showDetail}
+		<!-- The whole summary row toggles the raw detail; quiet until hovered. -->
+		<Collapsible.Trigger
+			class="flex w-full min-w-0 cursor-pointer items-center gap-(--era-gap) text-body text-muted era-interactive"
+		>
+			{@render head()}
+			<ChevronDown
+				class="size-(--era-h-xs) shrink-0 transition-transform duration-(--era-duration) ease-(--era-ease) group-data-[state=open]/error:rotate-180"
+				aria-hidden="true"
+			/>
+		</Collapsible.Trigger>
+	{:else}
+		<div class="flex min-w-0 items-center gap-(--era-gap) text-body">
+			{@render head()}
+		</div>
+	{/if}
+
+	{#if guidance}
+		<p class="text-body text-muted">{guidance}</p>
+	{/if}
+
+	{#if showDetail}
+		<Collapsible.Content data-era-error-detail class="overflow-hidden">
+			<div class="pt-(--era-gap)">
+				<CodeBlock code={rawDetail} />
+			</div>
+		</Collapsible.Content>
+	{/if}
+</Collapsible.Root>
+
+<style>
+	:global([data-era-error-detail][data-state='open']) {
+		animation: era-error-expand var(--era-duration) var(--era-ease);
+	}
+	:global([data-era-error-detail][data-state='closed']) {
+		animation: era-error-collapse var(--era-duration) var(--era-ease);
+	}
+	@keyframes -global-era-error-expand {
+		from {
+			height: 0;
+			opacity: 0;
+		}
+		to {
+			height: var(--bits-collapsible-content-height);
+			opacity: 1;
+		}
+	}
+	@keyframes -global-era-error-collapse {
+		from {
+			height: var(--bits-collapsible-content-height);
+			opacity: 1;
+		}
+		to {
+			height: 0;
+			opacity: 0;
+		}
+	}
+</style>

package/dist/ai/error-panel/error-panel.svelte.d.ts

@@ -0,0 +1,17 @@
+import { Collapsible } from 'bits-ui';
+import { type ErrorCategory } from './categorize-error.js';
+type $$ComponentProps = Collapsible.RootProps & {
+    /** Raw error to self-categorize (Error, JSON blob, or string). */
+    error?: unknown;
+    /** Override the summary line; defaults to the error's message. */
+    message?: string;
+    /** Force a category instead of inferring one from `error`. */
+    category?: ErrorCategory;
+    /** Raw error text for the expandable CodeBlock; derived from `error` if omitted. */
+    detail?: string;
+    /** Override the guidance line; defaults to the category hint. */
+    hint?: string;
+};
+declare const ErrorPanel: import("svelte").Component<$$ComponentProps, {}, "open">;
+type ErrorPanel = ReturnType<typeof ErrorPanel>;
+export default ErrorPanel;

package/dist/ai/error-panel/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Root } from './error-panel.svelte';
+export { categorizeError, describeCategory, extractToolName, toErrorMessage, type ErrorCategory, type ErrorTone, type ErrorCategorization } from './categorize-error.js';

package/dist/ai/error-panel/index.js

@@ -0,0 +1,2 @@
+export { default as Root } from './error-panel.svelte';
+export { categorizeError, describeCategory, extractToolName, toErrorMessage } from './categorize-error.js';

package/dist/ai/index.d.ts

@@ -12,6 +12,11 @@ export * as Plan from './plan/index.js';
 export * as Queue from './queue/index.js';
 export * as Confirmation from './confirmation/index.js';
 export * as InlineCitation from './inline-citation/index.js';
+export * as Conversations from './conversations/index.js';
+export * as StructuredValue from './structured-value/index.js';
+export * as RuntimeFeed from './runtime-feed/index.js';
+export * as ErrorPanel from './error-panel/index.js';
+export * as RunStatus from './run-status/index.js';
 export { Response, repairStreamingMarkdown } from './response/index.js';
 export { default as ContextGauge } from './context/context.svelte';
 export { default as ModelSelector } from './model-selector/model-selector.svelte';
@@ -27,3 +32,9 @@ export { StickToBottom } from './stick-to-bottom.svelte.js';
 export type { PromptAttachment, PromptMessage, ChatStatus } from './prompt-input/index.js';
 export type { MessageRole, MessageVersion } from './message/index.js';
 export type { ToolState } from './tool/index.js';
+export type { UsageBreakdown } from './message/index.js';
+export type { ConversationEntry, ConversationGroup, ConversationStatus, TimeBucket } from './conversations/index.js';
+export type { RunState, LogTone, RunTools } from './run-status/index.js';
+export type { ErrorCategory, ErrorTone, ErrorCategorization } from './error-panel/index.js';
+export { categorizeError } from './error-panel/index.js';
+export { projectMessages, toolState, type ChatMessage, type ChatPart, type ChatRole, type ProjectedMessage, type ProjectedBlock, type ProjectedTool } from './project.js';

package/dist/ai/index.js

@@ -17,6 +17,11 @@ export * as Plan from './plan/index.js';
 export * as Queue from './queue/index.js';
 export * as Confirmation from './confirmation/index.js';
 export * as InlineCitation from './inline-citation/index.js';
+export * as Conversations from './conversations/index.js';
+export * as StructuredValue from './structured-value/index.js';
+export * as RuntimeFeed from './runtime-feed/index.js';
+export * as ErrorPanel from './error-panel/index.js';
+export * as RunStatus from './run-status/index.js';
 export { Response, repairStreamingMarkdown } from './response/index.js';
 export { default as ContextGauge } from './context/context.svelte';
 export { default as ModelSelector } from './model-selector/model-selector.svelte';
@@ -29,3 +34,5 @@ export { default as Shimmer } from './shimmer.svelte';
 export { default as AIImage } from './image.svelte';
 export { default as CopyButton } from './copy-button.svelte';
 export { StickToBottom } from './stick-to-bottom.svelte.js';
+export { categorizeError } from './error-panel/index.js';
+export { projectMessages, toolState } from './project.js';

package/dist/ai/message/index.d.ts

@@ -1,6 +1,8 @@
 export { default as Root } from './message.svelte';
 export { default as Content } from './message-content.svelte';
 export { default as Toolbar } from './message-toolbar.svelte';
+export { default as Usage } from './message-usage.svelte';
+export type { UsageBreakdown } from './message-usage.svelte';
 export { default as Branch } from './message-branch.svelte';
 export { default as BranchContent } from './message-branch-content.svelte';
 export { default as BranchSelector } from './message-branch-selector.svelte';

package/dist/ai/message/index.js

@@ -1,6 +1,7 @@
 export { default as Root } from './message.svelte';
 export { default as Content } from './message-content.svelte';
 export { default as Toolbar } from './message-toolbar.svelte';
+export { default as Usage } from './message-usage.svelte';
 export { default as Branch } from './message-branch.svelte';
 export { default as BranchContent } from './message-branch-content.svelte';
 export { default as BranchSelector } from './message-branch-selector.svelte';

package/dist/ai/message/message-usage.svelte

@@ -0,0 +1,126 @@
+<script lang="ts" module>
+	/** Per-slice token accounting behind the info affordance. All counts are
+	 *  token estimates; the two `*Messages` fields are message counts. */
+	export interface UsageBreakdown {
+		instructions?: number;
+		text?: number;
+		toolArgs?: number;
+		toolResults?: number;
+		summary?: number;
+		recentMessages?: number;
+		summarizedMessages?: number;
+	}
+
+	// Pure, allocation-cheap formatters — no Date.now / Math.random so the row
+	// renders identically on server and client.
+
+	/** Compact token count: 940 · 12.4k · 3.1M. */
+	function formatTokens(n: number): string {
+		if (n < 1000) return String(n);
+		if (n < 1_000_000) return `${trim(n / 1000)}k`;
+		return `${trim(n / 1_000_000)}M`;
+	}
+
+	/** One decimal, but drop a trailing .0 and don't over-precision ≥100. */
+	function trim(v: number): string {
+		if (v >= 100) return String(Math.round(v));
+		return v.toFixed(1).replace(/\.0$/, '');
+	}
+
+	/** Tiered cost precision: sub-cent shows 4dp, sub-dollar 3dp, else 2dp. */
+	function formatCost(usd: number): string {
+		if (usd === 0) return '$0';
+		if (usd < 0.01) return `$${usd.toFixed(4)}`;
+		if (usd < 1) return `$${usd.toFixed(3)}`;
+		return `$${usd.toFixed(2)}`;
+	}
+
+	/** Strip a provider prefix: `anthropic/claude-opus-4` → `claude-opus-4`. */
+	function shortModel(model: string): string {
+		return model.split('/').pop() || model;
+	}
+</script>
+
+<script lang="ts">
+	import type { HTMLAttributes } from 'svelte/elements';
+	import Info from '@lucide/svelte/icons/info';
+	import * as Tooltip from '../../ui/tooltip/index.js';
+	import { cn } from '../../utils/index.js';
+
+	let {
+		tokensIn,
+		tokensOut,
+		model,
+		cost,
+		breakdown,
+		class: className,
+		...restProps
+	}: HTMLAttributes<HTMLDivElement> & {
+		tokensIn?: number;
+		tokensOut?: number;
+		model?: string;
+		cost?: number;
+		breakdown?: UsageBreakdown;
+	} = $props();
+
+	const total = $derived((tokensIn ?? 0) + (tokensOut ?? 0));
+	const hasTokens = $derived(tokensIn != null || tokensOut != null);
+
+	// Only the token slices present get a row; message counts trail as a caption.
+	const rows = $derived(
+		breakdown
+			? (
+					[
+						['instructions', breakdown.instructions],
+						['text', breakdown.text],
+						['tool args', breakdown.toolArgs],
+						['tool results', breakdown.toolResults],
+						['summary', breakdown.summary]
+					] as [string, number | undefined][]
+				).filter((r): r is [string, number] => r[1] != null)
+			: []
+	);
+</script>
+
+<div
+	class={cn(
+		'flex items-center gap-(--era-inset-sm) font-mono text-body tabular-nums text-muted era-text-trim',
+		className
+	)}
+	{...restProps}
+>
+	{#if hasTokens}
+		<span class="text-fg">{formatTokens(total)} tok</span>
+		<span>in {formatTokens(tokensIn ?? 0)} · out {formatTokens(tokensOut ?? 0)}</span>
+	{/if}
+	{#if model}<span>{shortModel(model)}</span>{/if}
+	{#if cost != null}<span class="text-fg">{formatCost(cost)}</span>{/if}
+
+	{#if breakdown}
+		<Tooltip.Provider delayDuration={150}>
+			<Tooltip.Root>
+				<Tooltip.Trigger
+					class="inline-flex items-center text-muted transition-colors duration-(--era-duration) ease-(--era-ease) hover:text-fg"
+					aria-label="Context window breakdown"
+				>
+					<Info class="size-(--era-h-xs)" aria-hidden="true" />
+				</Tooltip.Trigger>
+				<Tooltip.Content
+					class="h-auto flex-col items-start gap-(--era-inset-xxs) py-(--era-inset-xxs) whitespace-normal"
+				>
+					{#each rows as [label, value] (label)}
+						<span class="flex w-full items-center justify-between gap-(--era-inset-md) tabular-nums">
+							<span class="text-muted">{label}</span>
+							<span>{formatTokens(value)}</span>
+						</span>
+					{/each}
+					{#if breakdown.recentMessages != null || breakdown.summarizedMessages != null}
+						<span class="text-muted tabular-nums">
+							{breakdown.recentMessages ?? 0} recent · {breakdown.summarizedMessages ?? 0} summarized
+						</span>
+					{/if}
+				</Tooltip.Content>
+			</Tooltip.Root>
+		</Tooltip.Provider>
+	{/if}
+</div>

package/dist/ai/message/message-usage.svelte.d.ts

@@ -0,0 +1,22 @@
+/** Per-slice token accounting behind the info affordance. All counts are
+ *  token estimates; the two `*Messages` fields are message counts. */
+export interface UsageBreakdown {
+    instructions?: number;
+    text?: number;
+    toolArgs?: number;
+    toolResults?: number;
+    summary?: number;
+    recentMessages?: number;
+    summarizedMessages?: number;
+}
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
+    tokensIn?: number;
+    tokensOut?: number;
+    model?: string;
+    cost?: number;
+    breakdown?: UsageBreakdown;
+};
+declare const MessageUsage: import("svelte").Component<$$ComponentProps, {}, "">;
+type MessageUsage = ReturnType<typeof MessageUsage>;
+export default MessageUsage;

package/dist/ai/project.d.ts

@@ -0,0 +1,64 @@
+import type { ToolState } from './tool/index.js';
+export type ChatRole = 'user' | 'assistant' | 'system';
+export type ChatPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'reasoning';
+    text: string;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+} | {
+    type: 'tool-result';
+    toolCallId: string;
+    output?: unknown;
+    errorText?: string;
+};
+export interface ChatMessage {
+    id: string;
+    role: ChatRole;
+    parts: ChatPart[];
+}
+export interface ProjectedTool {
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+    output?: unknown;
+    errorText?: string;
+    /** Derived lifecycle, ready to hand straight to <Tool.Root state={…}>. */
+    state: ToolState;
+}
+export type ProjectedBlock = {
+    type: 'text';
+    key: string;
+    text: string;
+} | {
+    type: 'reasoning';
+    key: string;
+    text: string;
+} | {
+    type: 'tool-row';
+    key: string;
+    tools: ProjectedTool[];
+};
+export interface ProjectedMessage {
+    id: string;
+    role: ChatRole;
+    blocks: ProjectedBlock[];
+}
+type ToolResultInfo = {
+    output?: unknown;
+    errorText?: string;
+};
+/**
+ * Derive a tool's AI-SDK lifecycle from its call + (maybe) result. A present
+ * result wins: an `errorText` is `output-error`, otherwise `output-available`.
+ * With no result yet, a call whose input is still `undefined` is streaming its
+ * arguments; once the input is populated it's awaiting execution.
+ */
+export declare function toolState(input: unknown, result: ToolResultInfo | undefined): ToolState;
+export declare function projectMessages(messages: ChatMessage[]): ProjectedMessage[];
+export {};

package/dist/ai/project.js

@@ -0,0 +1,70 @@
+/**
+ * Derive a tool's AI-SDK lifecycle from its call + (maybe) result. A present
+ * result wins: an `errorText` is `output-error`, otherwise `output-available`.
+ * With no result yet, a call whose input is still `undefined` is streaming its
+ * arguments; once the input is populated it's awaiting execution.
+ */
+export function toolState(input, result) {
+    if (result)
+        return result.errorText !== undefined ? 'output-error' : 'output-available';
+    return input === undefined ? 'input-streaming' : 'input-available';
+}
+export function projectMessages(messages) {
+    // First pass: index every tool-result by id, from anywhere in the history —
+    // results routinely arrive in a message after the one that made the call.
+    const results = new Map();
+    for (const message of messages) {
+        for (const part of message.parts) {
+            if (part.type === 'tool-result') {
+                results.set(part.toolCallId, { output: part.output, errorText: part.errorText });
+            }
+        }
+    }
+    // Second pass: build ordered blocks, deduping each tool-call id to its first
+    // appearance (SDKs replay the full transcript every turn).
+    const seenTools = new Set();
+    return messages.map((message) => {
+        const blocks = [];
+        let row = [];
+        const flushRow = () => {
+            if (row.length === 0)
+                return;
+            blocks.push({ type: 'tool-row', key: `${message.id}:tools:${row[0].toolCallId}`, tools: row });
+            row = [];
+        };
+        for (const [i, part] of message.parts.entries()) {
+            switch (part.type) {
+                case 'text':
+                    flushRow();
+                    if (part.text)
+                        blocks.push({ type: 'text', key: `${message.id}:text:${i}`, text: part.text });
+                    break;
+                case 'reasoning':
+                    flushRow();
+                    if (part.text)
+                        blocks.push({ type: 'reasoning', key: `${message.id}:reasoning:${i}`, text: part.text });
+                    break;
+                case 'tool-call': {
+                    if (seenTools.has(part.toolCallId))
+                        break;
+                    seenTools.add(part.toolCallId);
+                    const result = results.get(part.toolCallId);
+                    row.push({
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        input: part.input,
+                        output: result?.output,
+                        errorText: result?.errorText,
+                        state: toolState(part.input, result)
+                    });
+                    break;
+                }
+                case 'tool-result':
+                    // Consumed into its call above; never a standalone block.
+                    break;
+            }
+        }
+        flushRow();
+        return { id: message.id, role: message.role, blocks };
+    });
+}

package/dist/ai/run-status/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Root } from './run-status.svelte';
+export type { RunState, LogTone, RunTools } from './run-status.svelte';

package/dist/ai/run-status/index.js

@@ -0,0 +1 @@
+export { default as Root } from './run-status.svelte';