@threadplane/chat 0.0.56 → 0.0.58

package/types/threadplane-chat.d.ts

@@ -1,28 +1,86 @@
 import * as _threadplane_render from '@threadplane/render';
 import { StandardSchemaV1, StandardSchemaInferOutput, AngularRegistry, RenderEvent, ViewRegistry, RenderViewEntry, RenderHost } from '@threadplane/render';
 export { StandardSchemaInferInput, StandardSchemaInferOutput, StandardSchemaV1, ViewRegistry, toRenderRegistry, views, withViews, withoutViews } from '@threadplane/render';
-import { A2uiComponentDef, A2uiSurface, A2uiMessage, A2uiActionMessage } from '@threadplane/a2ui';
-export { A2uiAction, A2uiActionContextEntry, A2uiActionMessage, A2uiChildren, A2uiClientDataModel, A2uiComponent, A2uiComponentDef, A2uiSurface, A2uiTheme, DynamicBoolean, DynamicNumber, DynamicString, isLiteralBoolean, isLiteralNumber, isLiteralString, isPathRef } from '@threadplane/a2ui';
+import { A2uiComponent, A2uiSurface, A2uiMessage, A2uiActionMessage, A2uiErrorMessage, A2uiClientCapabilities } from '@threadplane/a2ui';
+export { A2UI_BASIC_CATALOG_ID, A2UI_MIME_TYPE, A2UI_WIRE_VERSION, A2uiAction, A2uiActionMessage, A2uiCatalogComponent, A2uiCheck, A2uiChildren, A2uiClientCapabilities, A2uiClientDataModel, A2uiComponent, A2uiComponentBase, A2uiErrorMessage, A2uiEventAction, A2uiFunctionAction, A2uiFunctionCall, A2uiPathRef, A2uiSurface, A2uiTheme, DynamicBoolean, DynamicNumber, DynamicString, DynamicStringList, DynamicValue, isFunctionCall, isPathRef } from '@threadplane/a2ui';
 import * as _angular_core from '@angular/core';
 import { Type, InjectionToken, Signal, TemplateRef, ElementRef, WritableSignal, InputSignal, InputSignalWithTransform } from '@angular/core';
 import * as _json_render_core from '@json-render/core';
 import { StateStore, Spec } from '@json-render/core';
 import { Observable } from 'rxjs';
 import * as _threadplane_chat from '@threadplane/chat';
+import * as _cacheplane_partial_markdown from '@cacheplane/partial-markdown';
+import { MarkdownDocumentNode, CitationDefinition, MarkdownNode, MarkdownParagraphNode, MarkdownHeadingNode, MarkdownBlockquoteNode, MarkdownListNode, MarkdownListItemNode, MarkdownCodeBlockNode, MarkdownThematicBreakNode, MarkdownTextNode, MarkdownEmphasisNode, MarkdownStrongNode, MarkdownStrikethroughNode, MarkdownInlineCodeNode, MarkdownMathInlineNode, MarkdownMathDisplayNode, MarkdownHtmlInlineNode, MarkdownHtmlBlockNode, MarkdownLinkNode, MarkdownAutolinkNode, MarkdownImageNode, MarkdownSoftBreakNode, MarkdownHardBreakNode, MarkdownCitationReferenceNode, MarkdownTableNode, MarkdownTableRowNode, MarkdownTableCellNode } from '@cacheplane/partial-markdown';
 import { PartialJsonParser } from '@cacheplane/partial-json';
 import { BaseMessage } from '@langchain/core/messages';
-import * as _cacheplane_partial_markdown from '@cacheplane/partial-markdown';
-import { CitationDefinition, MarkdownDocumentNode, MarkdownNode, MarkdownParagraphNode, MarkdownHeadingNode, MarkdownBlockquoteNode, MarkdownListNode, MarkdownListItemNode, MarkdownCodeBlockNode, MarkdownThematicBreakNode, MarkdownTextNode, MarkdownEmphasisNode, MarkdownStrongNode, MarkdownStrikethroughNode, MarkdownInlineCodeNode, MarkdownMathInlineNode, MarkdownMathDisplayNode, MarkdownHtmlInlineNode, MarkdownHtmlBlockNode, MarkdownLinkNode, MarkdownAutolinkNode, MarkdownImageNode, MarkdownSoftBreakNode, MarkdownHardBreakNode, MarkdownCitationReferenceNode, MarkdownTableNode, MarkdownTableRowNode, MarkdownTableCellNode } from '@cacheplane/partial-markdown';
 import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
 import { NavigationExtras } from '@angular/router';
 
+type ToolCallStatus = 'pending' | 'running' | 'complete' | 'error';
+interface ToolCall {
+    id: string;
+    name: string;
+    /** Arguments. May be partial while streaming (`status !== 'complete'`). */
+    args: unknown;
+    status: ToolCallStatus;
+    /** Present when status === 'complete' or 'error'. */
+    result?: unknown;
+    /** Optional error payload when status === 'error'. */
+    error?: unknown;
+}
+
+/** Runtime context passed to browser-executed function tool handlers. */
+interface FunctionToolHandlerContext {
+    /** Aborts when the client tool execution should stop without resolving. */
+    readonly signal: AbortSignal;
+}
+/** Execution policy options for browser-executed function tools. */
+interface ClientToolContinuationOptions {
+    /** False when the tool result should be recorded without forcing a continuation. */
+    readonly followUp?: boolean;
+}
+/** Execution policy options for browser-executed function tools. */
+interface ClientToolExecutionOptions extends ClientToolContinuationOptions {
+    /** True when the handler may safely re-run and should skip durable pre-claims. */
+    readonly idempotent?: boolean;
+}
+/** Diagnostic emitted when client-tool continuation would exceed the configured max turn count. */
+interface ClientToolContinuationLimitEvent {
+    readonly maxTurns: number;
+    readonly attemptedTurn: number;
+    readonly toolCallIds: readonly string[];
+    readonly toolNames: readonly string[];
+}
+/** Policy for automatic client-tool continuation. */
+interface ClientToolContinuationPolicy {
+    /** Maximum consecutive client-tool continuation groups per user turn. Default: 10. Use 0 for unlimited. */
+    readonly maxTurns?: number;
+    /** Called when the max-turn guard stops a continuation group. */
+    readonly onLimit?: (event: ClientToolContinuationLimitEvent) => void;
+}
+type ClientToolLifecyclePhase = 'running' | 'complete' | 'error';
+interface ClientToolLifecycle {
+    readonly id: string;
+    readonly name: string;
+    readonly status: ToolCallStatus;
+    readonly phase: ClientToolLifecyclePhase;
+    readonly hasResult: boolean;
+    readonly result?: unknown;
+    readonly error?: unknown;
+}
+type ClientToolViewProps<S extends StandardSchemaV1> = StandardSchemaInferOutput<S> & {
+    readonly status?: ToolCallStatus;
+    readonly clientTool?: ClientToolLifecycle;
+};
 /** Precise authored function tool — what `action()` returns. Carries the schema
  *  `S` and the handler's resolved return type `R`. */
 interface FunctionToolDef<S extends StandardSchemaV1 = StandardSchemaV1, R = unknown> {
     readonly kind: 'function';
     readonly description: string;
     readonly schema: S;
-    readonly handler: (args: StandardSchemaInferOutput<S>) => R | Promise<R>;
+    readonly followUp?: boolean;
+    readonly idempotent?: boolean;
+    readonly handler: (args: StandardSchemaInferOutput<S>, context: FunctionToolHandlerContext) => R | Promise<R>;
 }
 /** Bivariant union member used only for registry storage/iteration. The handler
  *  param is `any` (NOT `never`): `any` is simultaneously a supertype any precise
@@ -33,18 +91,22 @@ interface AnyFunctionToolDef {
     readonly kind: 'function';
     readonly description: string;
     readonly schema: StandardSchemaV1;
-    readonly handler: (args: any) => unknown | Promise<unknown>;
+    readonly followUp?: boolean;
+    readonly idempotent?: boolean;
+    readonly handler: (args: any, context: FunctionToolHandlerContext) => unknown | Promise<unknown>;
 }
 interface ViewToolDef<S extends StandardSchemaV1 = StandardSchemaV1, C = unknown> {
     readonly kind: 'view';
     readonly description: string;
     readonly schema: S;
+    readonly followUp?: boolean;
     readonly component: Type<C>;
 }
 interface AskToolDef<S extends StandardSchemaV1 = StandardSchemaV1, C = unknown> {
     readonly kind: 'ask';
     readonly description: string;
     readonly schema: S;
+    readonly followUp?: boolean;
     readonly component: Type<C>;
 }
 /** A client tool the model can call; executed in the browser. */
@@ -178,9 +240,50 @@ interface Citation {
     publishedAt?: string | number | Date;
 }
 
+/**
+ * Terminal result of one response attempt.
+ *
+ * `paused` is an intentional stop awaiting resumable input; `interrupted` means
+ * the response stream ended unexpectedly. The other outcomes indicate normal
+ * completion, failure, or caller cancellation.
+ */
+type CompleteOutcome = 'success' | 'error' | 'aborted' | 'interrupted' | 'paused';
+/**
+ * Delivery lifecycle for one response attempt. `generation` identifies that
+ * attempt and is stable only for its lifetime. `streaming` means chunks may
+ * still arrive; `complete` means the attempt has stopped with a terminal outcome.
+ */
+type MessageDelivery = {
+    readonly generation: string;
+    readonly phase: 'streaming';
+} | {
+    readonly generation: string;
+    readonly phase: 'complete';
+    readonly outcome: CompleteOutcome;
+};
+/** Creates the active delivery state for one response-attempt generation. */
+declare function streamingDelivery(generation: string): {
+    readonly generation: string;
+    readonly phase: "streaming";
+};
+/** Creates a terminal delivery state for an existing response-attempt generation. */
+declare function completeDelivery<const TOutcome extends CompleteOutcome>(generation: string, outcome: TOutcome): {
+    readonly generation: string;
+    readonly phase: "complete";
+    readonly outcome: TOutcome;
+};
+/** Creates a successful terminal delivery state for an already-complete message. */
+declare function staticDelivery(messageId: string): {
+    readonly generation: string;
+    readonly phase: "complete";
+    readonly outcome: "success";
+};
+
 type Role = 'user' | 'assistant' | 'system' | 'tool';
 interface Message {
     id: string;
+    /** Adapter-owned authoritative delivery lifecycle state for this message. */
+    delivery: MessageDelivery;
     role: Role;
     /** Plain text, or a list of structured content blocks. */
     content: string | ContentBlock[];
@@ -271,19 +374,6 @@ declare function isSystemMessage(m: Message): m is Message & {
     role: 'system';
 };
 
-type ToolCallStatus = 'pending' | 'running' | 'complete' | 'error';
-interface ToolCall {
-    id: string;
-    name: string;
-    /** Arguments. May be partial while streaming (`status !== 'complete'`). */
-    args: unknown;
-    status: ToolCallStatus;
-    /** Present when status === 'complete' or 'error'. */
-    result?: unknown;
-    /** Optional error payload when status === 'error'. */
-    error?: unknown;
-}
-
 type AgentStatus = 'idle' | 'running' | 'error';
 
 interface AgentInterrupt {
@@ -385,6 +475,15 @@ interface ClientToolsCapability {
     setCatalog(specs: readonly ClientToolSpec[]): void;
     /** Tool calls the model made for client tools that await a client result. */
     readonly pending: Signal<readonly ToolCall[]>;
+    /** Record a client tool's result without continuing the run. */
+    settle?(toolCallId: string, result: ClientToolResult): void;
+    /**
+     * Make every result recorded via {@link settle} durable on the server
+     * WITHOUT continuing the run. No-op for adapters whose settle() is already
+     * durable. Adapters that buffer locally MUST clear their buffer only on a
+     * successful write, so a failure degrades to a later flush or submit.
+     */
+    flush?(): void | Promise<void>;
     /** Return a client tool's result (or error) and continue the run. */
     resolve(toolCallId: string, result: ClientToolResult): void;
 }
@@ -456,7 +555,7 @@ declare const AGENT_ERROR_MESSAGES: Record<AgentErrorKind, string>;
  * Invariant: state lives on signals; `events$` carries only things that are
  * not derivable from signals.
  */
-interface Agent<TState = Record<string, unknown>> {
+interface Agent<TState = unknown> {
     messages: Signal<Message[]>;
     status: Signal<AgentStatus>;
     isLoading: Signal<boolean>;
@@ -539,7 +638,7 @@ interface AgentCheckpoint {
  * implement this. Pure request/response runtimes that don't have checkpoints
  * should implement plain Agent.
  */
-interface AgentWithHistory<TState = Record<string, unknown>> extends Agent<TState> {
+interface AgentWithHistory<TState = unknown> extends Agent<TState> {
     history: Signal<AgentCheckpoint[]>;
     /**
      * Optional reactive map of `messageId → checkpointId`, computed by
@@ -601,7 +700,7 @@ declare class MessageTemplateDirective {
  */
 declare function getMessageType(message: Message): MessageTemplateType;
 declare class ChatMessageListComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly messageTemplates: _angular_core.Signal<readonly MessageTemplateDirective[]>;
     readonly messages: _angular_core.Signal<Message[]>;
     readonly getMessageType: typeof getMessageType;
@@ -689,17 +788,19 @@ declare class ChatTraceComponent {
  * step labels often appear in reasoning output).
  *
  * Internal state: a tristate "expanded" — null means follow auto state-
- * driven logic (force-expand on isStreaming, otherwise honor
+ * driven logic (force-expand while delivery is streaming, otherwise honor
  * defaultExpanded), boolean is a manual user choice that wins for the
  * lifetime of the instance.
  */
 declare class ChatReasoningComponent {
     readonly content: _angular_core.InputSignal<string>;
-    readonly isStreaming: _angular_core.InputSignal<boolean>;
+    readonly delivery: _angular_core.InputSignal<MessageDelivery>;
     readonly durationMs: _angular_core.InputSignal<number | undefined>;
     readonly label: _angular_core.InputSignal<string | undefined>;
     readonly defaultExpanded: _angular_core.InputSignal<boolean>;
     readonly hasContent: _angular_core.Signal<boolean>;
+    readonly isStreaming: _angular_core.Signal<boolean>;
+    readonly document: _angular_core.Signal<_threadplane_chat.StreamingMarkdownDocument>;
     /** null = follow auto logic (streaming → expanded, else defaultExpanded). */
     private readonly _expandedOverride;
     readonly expanded: _angular_core.Signal<boolean>;
@@ -708,7 +809,7 @@ declare class ChatReasoningComponent {
     constructor();
     toggle(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatReasoningComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatReasoningComponent, "chat-reasoning", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "isStreaming": { "alias": "isStreaming"; "required": false; "isSignal": true; }; "durationMs": { "alias": "durationMs"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "defaultExpanded": { "alias": "defaultExpanded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatReasoningComponent, "chat-reasoning", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "delivery": { "alias": "delivery"; "required": true; "isSignal": true; }; "durationMs": { "alias": "durationMs"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "defaultExpanded": { "alias": "defaultExpanded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ChatLauncherButtonComponent {
@@ -736,7 +837,7 @@ declare class ChatSuggestionsComponent {
  */
 declare function submitMessage(agent: Agent, text: string): string | null;
 declare class ChatInputComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly submitOnEnter: _angular_core.InputSignal<boolean>;
     readonly placeholder: _angular_core.InputSignal<string>;
     /** When true (default), shows a stop button while the agent is streaming. */
@@ -788,7 +889,7 @@ declare class ChatInputComponent {
  */
 declare function isTyping(agent: Agent): boolean;
 declare class ChatTypingIndicatorComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly visible: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatTypingIndicatorComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatTypingIndicatorComponent, "chat-typing-indicator", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -897,7 +998,7 @@ declare class ChatScrollBubbleComponent {
  */
 declare function extractErrorMessage(error: unknown): string | null;
 declare class ChatErrorComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatErrorComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatErrorComponent, "chat-error", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -916,7 +1017,7 @@ declare class ChatErrorComponent {
  */
 declare function getInterrupt(agent: Agent): AgentInterrupt | undefined;
 declare class ChatInterruptComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
     readonly interrupt: _angular_core.Signal<AgentInterrupt | undefined>;
     defaultText(i: AgentInterrupt): string;
@@ -987,7 +1088,7 @@ interface Group {
     subagent?: Subagent;
 }
 declare class ChatToolCallsComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly message: _angular_core.InputSignal<Message | undefined>;
     readonly grouping: _angular_core.InputSignal<"auto" | "none">;
     readonly groupSummary: _angular_core.InputSignal<((name: string, count: number) => string) | undefined>;
@@ -1026,7 +1127,7 @@ declare class ChatToolCallsComponent {
  * (and a `status` a component chooses not to declare) are harmless.
  */
 declare class ChatToolViewsComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly events: _angular_core.OutputEmitterRef<RenderEvent>;
     readonly message: _angular_core.InputSignal<Message | undefined>;
     readonly views: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
@@ -1043,7 +1144,7 @@ declare class ChatToolViewsComponent {
 }
 
 declare class ChatSubagentsComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
     readonly activeSubagents: _angular_core.Signal<Subagent[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSubagentsComponent, never>;
@@ -1249,7 +1350,7 @@ declare class ChatGenuiSkeletonComponent {
 }
 
 declare class ChatTimelineComponent {
-    readonly agent: _angular_core.InputSignal<AgentWithHistory<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<AgentWithHistory<unknown>>;
     readonly checkpointSelected: _angular_core.OutputEmitterRef<AgentCheckpoint>;
     readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
     readonly history: _angular_core.Signal<AgentCheckpoint[]>;
@@ -1418,6 +1519,53 @@ declare class ChatConnectedOverlayDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ChatConnectedOverlayDirective, "[chatConnectedOverlay]", never, { "origin": { "alias": "chatOverlayOrigin"; "required": true; "isSignal": true; }; "open": { "alias": "chatOverlayOpen"; "required": false; "isSignal": true; }; "positions": { "alias": "chatOverlayPositions"; "required": false; "isSignal": true; }; "panelClass": { "alias": "chatOverlayPanelClass"; "required": false; "isSignal": true; }; }, { "attached": "chatOverlayAttached"; "outsideClick": "chatOverlayOutsideClick"; "detached": "chatOverlayDetach"; }, never, never, true, never>;
 }
 
+type CitationTypeIcon = 'web' | 'file' | 'app' | 'memory' | 'generic';
+interface CitationTypeMeta {
+    type: string;
+    label: string | null;
+    icon: CitationTypeIcon;
+    tone: CitationTypeIcon;
+    isKnown: boolean;
+}
+interface CitationImageVisual {
+    kind: 'image';
+    iconUrl: string;
+}
+interface CitationTypeIconVisual {
+    kind: 'type-icon';
+    icon: CitationTypeIcon;
+    tone: CitationTypeIcon;
+    label: string | null;
+}
+interface CitationMonogramVisual {
+    kind: 'monogram';
+    monogram: string;
+    color: string;
+}
+type CitationSourceVisual = CitationImageVisual | CitationTypeIconVisual | CitationMonogramVisual;
+/** Hostname of `url` with a leading `www.` removed; null if absent/malformed. */
+declare function deriveDomain(url?: string): string | null;
+/** Explicit `sourceType`, else 'web' inferred from a url, else 'unknown'. */
+declare function deriveSourceType(c: Citation): string;
+/** Uppercased first letter of the domain (or title) for the monogram chip. */
+declare function deriveMonogram(c: Citation): string;
+/** Deterministic hue in [0,360) from a seed string (stable monogram color). */
+declare function monogramHue(seed: string): number;
+/** Short freshness label (e.g. "Apr 2024"); null when absent or unparseable. */
+declare function formatPublished(value?: string | number | Date): string | null;
+/** Deterministic monogram-chip background color (stable per source). */
+declare function monogramColor(c: Citation): string;
+/**
+ * Derive normalized source-type metadata for badges, icons, and tone tokens.
+ */
+declare function citationTypeMeta(c: Citation): CitationTypeMeta;
+/**
+ * Choose the visual source marker for a citation: provider image, type icon, or monogram.
+ */
+declare function citationSourceVisual(c: Citation): CitationSourceVisual;
+/** Human label for the source-type badge; null when type is 'unknown'. */
+declare function citationTypeLabel(c: Citation): string | null;
+
 /**
  * ContentChild template directive for custom citation card rendering.
  * Usage: <ng-template chatCitationCard let-citation>...</ng-template>
@@ -1431,9 +1579,12 @@ declare class ChatCitationCardTemplateDirective {
 }
 interface FavEntry {
     id: string;
+    kind: 'image' | 'type-icon' | 'monogram';
     iconUrl?: string;
-    mono: string;
-    color: string;
+    icon?: CitationTypeIcon;
+    tone?: CitationTypeIcon;
+    monogram?: string;
+    color?: string;
 }
 declare class ChatCitationsComponent {
     readonly message: _angular_core.InputSignal<Message>;
@@ -1462,11 +1613,17 @@ declare class ChatCitationsComponent {
  */
 declare class ChatCitationsCardComponent {
     readonly citation: _angular_core.InputSignal<Citation>;
+    private readonly sourceVisual;
+    private readonly typeMeta;
     protected readonly domain: _angular_core.Signal<string | null>;
     protected readonly title: _angular_core.Signal<string | null>;
-    protected readonly monogram: _angular_core.Signal<string>;
-    protected readonly monoColor: _angular_core.Signal<string>;
+    protected readonly sourceIconUrl: _angular_core.Signal<string | null>;
+    protected readonly sourceIcon: _angular_core.Signal<CitationTypeIcon | null>;
+    protected readonly sourceMonogram: _angular_core.Signal<string | null>;
+    protected readonly sourceMonoColor: _angular_core.Signal<string | null>;
     protected readonly typeLabel: _angular_core.Signal<string | null>;
+    protected readonly typeTone: _angular_core.Signal<CitationTypeIcon>;
+    protected isTypeTone(tone: CitationTypeIcon): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatCitationsCardComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatCitationsCardComponent, "chat-citations-card", never, { "citation": { "alias": "citation"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -1478,30 +1635,21 @@ declare class ChatCitationsCardComponent {
  */
 declare class ChatCitationPreviewComponent {
     readonly citation: _angular_core.InputSignal<Citation>;
+    private readonly sourceVisual;
+    private readonly typeMeta;
     protected readonly domain: _angular_core.Signal<string | null>;
-    protected readonly monogram: _angular_core.Signal<string>;
-    protected readonly monoColor: _angular_core.Signal<string>;
+    protected readonly sourceIconUrl: _angular_core.Signal<string | null>;
+    protected readonly sourceIcon: _angular_core.Signal<CitationTypeIcon | null>;
+    protected readonly sourceMonogram: _angular_core.Signal<string | null>;
+    protected readonly sourceMonoColor: _angular_core.Signal<string | null>;
     protected readonly typeLabel: _angular_core.Signal<string | null>;
+    protected readonly typeTone: _angular_core.Signal<CitationTypeIcon>;
     protected readonly published: _angular_core.Signal<string | null>;
+    protected isTypeTone(tone: CitationTypeIcon): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatCitationPreviewComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatCitationPreviewComponent, "chat-citation-preview", never, { "citation": { "alias": "citation"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** Hostname of `url` with a leading `www.` removed; null if absent/malformed. */
-declare function deriveDomain(url?: string): string | null;
-/** Explicit `sourceType`, else 'web' inferred from a url, else 'unknown'. */
-declare function deriveSourceType(c: Citation): string;
-/** Uppercased first letter of the domain (or title) for the monogram chip. */
-declare function deriveMonogram(c: Citation): string;
-/** Deterministic hue in [0,360) from a seed string (stable monogram color). */
-declare function monogramHue(seed: string): number;
-/** Short freshness label (e.g. "Apr 2024"); null when absent or unparseable. */
-declare function formatPublished(value?: string | number | Date): string | null;
-/** Deterministic monogram-chip background color (stable per source). */
-declare function monogramColor(c: Citation): string;
-/** Human label for the source-type badge; null when type is 'unknown'. */
-declare function citationTypeLabel(c: Citation): string | null;
-
 interface ThreadRoutingConfig {
     /** The app-owned source-of-truth signal for the active thread id. */
     threadId: WritableSignal<string | null>;
@@ -1543,6 +1691,76 @@ interface ChatLifecycle {
 }
 declare const CHAT_LIFECYCLE: InjectionToken<ChatLifecycle>;
 
+/** Durable identity for one client-tool execution on one thread. */
+interface ClientToolExecutionKey {
+    readonly threadId: string;
+    readonly toolCallId: string;
+}
+/** Prior durable execution state returned by a client-tool execution store. */
+type ClientToolExecutionRecord = {
+    readonly status: 'executing';
+} | {
+    readonly status: 'done';
+    readonly result: ClientToolResult;
+} | {
+    readonly status: 'failed';
+    readonly result?: ClientToolResult;
+};
+/** Structural store contract for guarded browser client-tool execution. */
+interface ClientToolExecutionStore {
+    /** Atomically claim a tool-call execution. Returns prior state when present. */
+    claim(key: ClientToolExecutionKey): Promise<'claimed' | ClientToolExecutionRecord>;
+    /** Record the final client-tool result for a claimed execution. */
+    record(key: ClientToolExecutionKey, result: ClientToolResult): Promise<void>;
+    /** Lookup prior execution states for pending tool calls on a thread. */
+    lookup(threadId: string, toolCallIds: readonly string[]): Promise<Record<string, ClientToolExecutionRecord>>;
+}
+/** Opt-in guard configuration for claim-before-execute client tools. */
+interface ClientToolExecutionGuard {
+    readonly threadId: string;
+    readonly store: ClientToolExecutionStore;
+}
+/** Return whether this function tool should claim before browser execution. */
+declare function shouldClaimBeforeExecute(def: AnyFunctionToolDef): boolean;
+/** Default fail-closed result for a stale in-progress client-tool execution. */
+declare function defaultInterruptedClientToolResult(toolCallId: string): ClientToolResult;
+/** Result recorded when the user stops a run while a client tool is running. */
+declare function cancelledClientToolResult(toolCallId: string): ClientToolResult;
+/** Default fail-closed result when the execution guard itself cannot be reached. */
+declare function clientToolGuardFailureResult(toolCallId: string, error: unknown): ClientToolResult;
+
+interface StreamingMarkdownDocument {
+    readonly generation: string;
+    readonly phase: 'streaming' | 'complete';
+    readonly content: string;
+}
+/** Creates the atomic document consumed by the streaming Markdown renderer. */
+declare function markdownDocument(content: string, delivery: MessageDelivery, suffix?: string): StreamingMarkdownDocument;
+type StreamingMarkdownContractViolationPolicy = 'throw' | 'rebuild';
+declare const STREAMING_MARKDOWN_CONTRACT_VIOLATION_POLICY: InjectionToken<StreamingMarkdownContractViolationPolicy>;
+/**
+ * Renders one explicitly-versioned markdown document through the shared view
+ * registry. A generation owns one parser session; append-only updates preserve
+ * parser and subtree identity, while generation changes replace the session.
+ */
+declare class ChatStreamingMdComponent {
+    readonly document: _angular_core.InputSignal<StreamingMarkdownDocument>;
+    readonly viewRegistry: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
+    readonly resolvedRegistry: _angular_core.Signal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>>>;
+    private readonly resolver;
+    private readonly violationPolicy;
+    private readonly createParser;
+    private parser;
+    private prior;
+    private materializedRoot;
+    readonly root: _angular_core.Signal<MarkdownDocumentNode | null>;
+    constructor();
+    private process;
+    private replaceFrom;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatStreamingMdComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatStreamingMdComponent, "chat-streaming-md", never, { "document": { "alias": "document"; "required": true; "isSignal": true; }; "viewRegistry": { "alias": "viewRegistry"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 interface ElementAccumulationState {
     hasType: boolean;
     hasProps: boolean;
@@ -1573,29 +1791,29 @@ declare function createParseTreeStore(parser: PartialJsonParser): ParseTreeStore
 
 /** Chat-internal projection of an A2UI component, materialized by the
  * surface store. Distinct from the wire-format `A2uiComponent` in
- * `@threadplane/a2ui` (which carries the raw `component: A2uiComponentDef`
- * payload) — this type adds the per-component readiness fields the
- * progressive renderer consumes. */
+ * `@threadplane/a2ui` — this type adds the per-component readiness fields
+ * the progressive renderer consumes. */
 interface A2uiComponentView {
     /** The component's id (same as the wire-format `A2uiComponent.id`). */
     readonly id: string;
-    /** The component type key — e.g. `'Button'`, `'TextField'` — matched
-     * against catalog `views` entries. */
+    /** The component type — e.g. `'Button'`, `'TextField'` — matched
+     * against catalog `views` entries. Mirrors the wire `component` string. */
     readonly type: string;
     /** Data model paths this component references via its `{$.path}` prop
-     * expressions. Extracted once on `surfaceUpdate` apply; immutable. */
+     * expressions. Extracted once on `updateComponents` apply; immutable. */
     readonly bindings: readonly string[];
     /** Monotonic: `false` until every binding has resolved at least once
      * in the accumulated data model, then `true` forever. Once `true`,
-     * subsequent `dataModelUpdate` envelopes push new prop values but do
+     * subsequent `updateDataModel` envelopes push new prop values but do
      * NOT flip this back to `false`. */
     readonly ready: boolean;
-    /** Resolved property bag. Meaningful only when `ready === true`. */
+    /** Resolved property bag (reserved protocol keys stripped). Meaningful
+     * only when `ready === true`. */
     readonly props: Readonly<Record<string, unknown>>;
-    /** The raw wire-format component def, retained so the slot directive
+    /** The raw wire-format component, retained so the slot directive
      * can look up the catalog entry by type and resolve nested children
      * on re-renders. */
-    readonly def: A2uiComponentDef;
+    readonly def: A2uiComponent;
 }
 
 /** Chat-side state for a surface — wraps the wire-format `A2uiSurface`
@@ -1625,10 +1843,15 @@ interface A2uiSurfaceStore {
 }
 /**
  * Create an {@link A2uiSurfaceStore} — the per-conversation store that buffers
- * streamed A2UI surface updates, tracks each surface's data model + lifecycle
+ * streamed A2UI v0.9 envelopes, tracks each surface's data model + lifecycle
  * state, and exposes them as signals for rendering. One store backs a chat
  * thread's A2UI surfaces.
  *
+ * A surface becomes visible once its `createSurface` envelope has arrived AND
+ * a component with id `root` has been defined (the v0.9 progressive-rendering
+ * rule). Everything received earlier is buffered; afterwards, components merge
+ * incrementally by id and data-model updates apply immediately.
+ *
  * @returns A fresh, empty {@link A2uiSurfaceStore}.
  * @example
  * ```ts
@@ -1685,7 +1908,7 @@ interface ChatRenderEvent {
 }
 
 declare class ChatComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly views: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
     /**
      * Client-declared tools (`view`/`ask`/`function`) the model may call. When
@@ -1726,9 +1949,12 @@ declare class ChatComponent {
      * Default covers the canonical A2UI + json-render schema tools.
      */
     readonly genuiToolNames: _angular_core.InputSignal<readonly string[]>;
+    readonly clientToolExecutionGuard: _angular_core.InputSignal<ClientToolExecutionGuard | undefined>;
+    readonly clientToolContinuationPolicy: _angular_core.InputSignal<ClientToolContinuationPolicy | undefined>;
     readonly showWelcome: _angular_core.Signal<boolean>;
     readonly threadSelected: _angular_core.OutputEmitterRef<string>;
     readonly renderEvent: _angular_core.OutputEmitterRef<ChatRenderEvent>;
+    readonly clientToolContinuationLimit: _angular_core.OutputEmitterRef<ClientToolContinuationLimitEvent>;
     /** Emitted when the user clicks the regenerate button on an assistant message. */
     readonly regenerate: _angular_core.OutputEmitterRef<void>;
     /** Emitted when the user rates an assistant message. */
@@ -1783,13 +2009,6 @@ declare class ChatComponent {
      * back to the original text.
      */
     protected humanContent(message: unknown): string;
-    /**
-     * True while a message's reasoning is mid-stream — i.e. it's the latest
-     * message, the agent is loading, the message has reasoning content, and
-     * no response text has arrived yet. Once the response text begins, the
-     * reasoning pill collapses (per its internal logic).
-     */
-    protected isReasoningStreaming(message: Message, index: number): boolean;
     /** The nearest preceding assistant message (skipping hidden tool messages), or undefined. */
     private prevAssistant;
     /**
@@ -1800,17 +2019,19 @@ declare class ChatComponent {
     protected reasoningRunStart(index: number): boolean;
     /**
      * Aggregate the reasoning RUN starting at `index`: joins each step's
-     * reasoning, sums durations, counts steps, and computes the streaming flag
-     * and the merged label when N > 1 ("Thought for {total} · {N} steps", or
-     * just "{N} steps" when no step reported timing).
+     * reasoning, sums durations, counts steps, and returns the last step's
+     * delivery because that step owns the current aggregate snapshot. Also
+     * computes the merged label when N > 1 ("Thought for {total} · {N} steps",
+     * or just "{N} steps" when no step reported timing).
      */
     protected reasoningRun(index: number): {
         content: string;
         durationMs: number | undefined;
-        streaming: boolean;
+        delivery: MessageDelivery;
         label: string | undefined;
     };
     private readonly classifiers;
+    private readonly markdownDocuments;
     private readonly destroyRef;
     private readonly injector;
     private readonly lifecycle;
@@ -1831,15 +2052,13 @@ declare class ChatComponent {
     private programmaticScrollCount;
     private static readonly PIN_TOLERANCE_PX;
     /**
-     * True iff there's a current (last-index) assistant message that's
-     * still streaming. The bubble's own caret already signals loading;
+     * True iff the current (last-index) assistant message owns an active
+     * delivery generation. The bubble's own caret already signals loading;
      * we suppress the floor typing-indicator in that case so the user
      * doesn't see two loading affordances at once.
      *
      * Matches the same `streaming + current` condition the bubble uses
-     * to enable `.chat-message__caret`:
-     *   `this.agent().isLoading() && i === this.agent().messages().length - 1`
-     *   `i === this.agent().messages().length - 1`
+     * to enable `.chat-message__caret`.
      *
      * Restricted to assistant role because the caret only renders on
      * assistant bubbles (`:host([data-role="assistant"][data-current=...
@@ -1889,9 +2108,8 @@ declare class ChatComponent {
      * unlike a single prev-message check.
      */
     protected isGenuiTurn(message: unknown, _prevMsg: unknown, index?: number): boolean;
-    classifyMessage(content: string, message: {
-        id?: string;
-    }): ContentClassifier;
+    classifyMessage(content: string, message: Pick<Message, 'id' | 'delivery'>): ContentClassifier;
+    protected markdownDocumentFor(content: string, message: Pick<Message, 'id' | 'delivery'>): StreamingMarkdownDocument;
     clearClassifiers(): void;
     onSpecEvent(event: RenderEvent, messageIndex: number): void;
     /**
@@ -1908,11 +2126,11 @@ declare class ChatComponent {
     onRate(message: unknown, value: 'up' | 'down'): void;
     onCopy(message: unknown, content: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatComponent, "chat", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "clientTools": { "alias": "clientTools"; "required": false; "isSignal": true; }; "store": { "alias": "store"; "required": false; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "threads": { "alias": "threads"; "required": false; "isSignal": true; }; "activeThreadId": { "alias": "activeThreadId"; "required": false; "isSignal": true; }; "welcomeDisabled": { "alias": "welcomeDisabled"; "required": false; "isSignal": true; }; "modelOptions": { "alias": "modelOptions"; "required": false; "isSignal": true; }; "showModelPicker": { "alias": "showModelPicker"; "required": false; "isSignal": true; }; "selectedModel": { "alias": "selectedModel"; "required": false; "isSignal": true; }; "modelPickerPlaceholder": { "alias": "modelPickerPlaceholder"; "required": false; "isSignal": true; }; "genuiToolNames": { "alias": "genuiToolNames"; "required": false; "isSignal": true; }; }, { "selectedModel": "selectedModelChange"; "threadSelected": "threadSelected"; "renderEvent": "renderEvent"; "regenerate": "regenerate"; "rate": "rate"; "messageCopy": "messageCopy"; }, never, ["[chatWelcomeSuggestions]", "[chatHeader]", "[chatToolCallTemplate]", "[chatInputModelSelect]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatComponent, "chat", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "clientTools": { "alias": "clientTools"; "required": false; "isSignal": true; }; "store": { "alias": "store"; "required": false; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "threads": { "alias": "threads"; "required": false; "isSignal": true; }; "activeThreadId": { "alias": "activeThreadId"; "required": false; "isSignal": true; }; "welcomeDisabled": { "alias": "welcomeDisabled"; "required": false; "isSignal": true; }; "modelOptions": { "alias": "modelOptions"; "required": false; "isSignal": true; }; "showModelPicker": { "alias": "showModelPicker"; "required": false; "isSignal": true; }; "selectedModel": { "alias": "selectedModel"; "required": false; "isSignal": true; }; "modelPickerPlaceholder": { "alias": "modelPickerPlaceholder"; "required": false; "isSignal": true; }; "genuiToolNames": { "alias": "genuiToolNames"; "required": false; "isSignal": true; }; "clientToolExecutionGuard": { "alias": "clientToolExecutionGuard"; "required": false; "isSignal": true; }; "clientToolContinuationPolicy": { "alias": "clientToolContinuationPolicy"; "required": false; "isSignal": true; }; }, { "selectedModel": "selectedModelChange"; "threadSelected": "threadSelected"; "renderEvent": "renderEvent"; "clientToolContinuationLimit": "clientToolContinuationLimit"; "regenerate": "regenerate"; "rate": "rate"; "messageCopy": "messageCopy"; }, never, ["[chatWelcomeSuggestions]", "[chatHeader]", "[chatToolCallTemplate]", "[chatInputModelSelect]"], true, never>;
 }
 
 declare class ChatPopupComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     /** A2UI component catalog forwarded to the inner <chat>. Without it,
      * messages classified as A2UI parse correctly but never mount a
      * surface. Pass `a2uiBasicCatalog()` from `@threadplane/chat`. */
@@ -1952,7 +2170,7 @@ declare class ChatPopupComponent {
 }
 
 declare class ChatSidebarComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     /** A2UI component catalog forwarded to the inner <chat>. Without it,
      * messages classified as A2UI parse correctly but never mount a
      * surface. Pass `a2uiBasicCatalog()` from `@threadplane/chat`. */
@@ -1986,7 +2204,7 @@ declare class ChatSidebarComponent {
 }
 
 declare class ChatTimelineSliderComponent {
-    readonly agent: _angular_core.InputSignal<AgentWithHistory<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<AgentWithHistory<unknown>>;
     readonly selectedIndex: _angular_core.WritableSignal<number>;
     readonly history: _angular_core.Signal<AgentCheckpoint[]>;
     readonly replayRequested: _angular_core.OutputEmitterRef<string>;
@@ -1998,6 +2216,37 @@ declare class ChatTimelineSliderComponent {
 }
 
 type ChatSidenavMode = 'expanded' | 'collapsed' | 'drawer';
+/**
+ * The conversation sidebar: thread list, projects, search, and the new-chat
+ * action. Pair it with a runtime's thread store (e.g. `LangGraphThreadsAdapter`)
+ * and a {@link ThreadActionAdapter} for the per-row rename/delete/archive menu.
+ *
+ * **This component renders the sidebar only — it is not a layout wrapper.** Its
+ * `<ng-content>` slots are all named (`sidenavHeader`, `sidenavPrimary`,
+ * `sidenavSections`, `sidenavFooterLeft`, `sidenavFooterRight`,
+ * `sidenavAccount`) and target regions *inside* the sidebar. There is no default
+ * slot, so a `<chat>` placed between the tags is silently dropped. Render the
+ * chat as a sibling and lay the two out yourself:
+ *
+ * @example
+ * ```html
+ * <chat-sidenav
+ *   [threads]="threads.threads()"
+ *   [activeThreadId]="activeThread()"
+ *   [actions]="threadActions"
+ *   [agent]="agent"
+ *   (newChat)="activeThread.set(null)"
+ *   (threadSelected)="activeThread.set($event)"
+ * />
+ * <main class="chat-pane">
+ *   <chat [agent]="agent" />
+ * </main>
+ * ```
+ * ```css
+ * :host { display: flex; height: 100dvh; }
+ * .chat-pane { flex: 1; min-width: 0; }
+ * ```
+ */
 declare class ChatSidenavComponent {
     readonly mode: _angular_core.InputSignal<ChatSidenavMode>;
     readonly open: _angular_core.InputSignal<boolean>;
@@ -2008,7 +2257,7 @@ declare class ChatSidenavComponent {
     readonly projects: _angular_core.InputSignal<Project[] | null>;
     readonly selectedProjectId: _angular_core.InputSignal<string | null>;
     readonly projectActions: _angular_core.InputSignal<ProjectActionAdapter | null>;
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>> | AgentWithHistory<Record<string, unknown>> | null>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown> | AgentWithHistory<unknown> | null>;
     readonly debug: _angular_core.InputSignal<boolean>;
     readonly newChat: _angular_core.OutputEmitterRef<void>;
     readonly threadSelected: _angular_core.OutputEmitterRef<string>;
@@ -2059,7 +2308,7 @@ declare class ChatSidenavScrimComponent {
 
 type InterruptAction = 'accept' | 'edit' | 'respond' | 'ignore';
 declare class ChatInterruptPanelComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly action: _angular_core.OutputEmitterRef<InterruptAction>;
     readonly interrupt: _angular_core.Signal<AgentInterrupt | undefined>;
     readonly interruptReason: _angular_core.Signal<string>;
@@ -2069,7 +2318,7 @@ declare class ChatInterruptPanelComponent {
 
 type ChatApprovalAction = 'approve' | 'edit' | 'cancel';
 declare class ChatApprovalCardComponent {
-    readonly agent: _angular_core.InputSignal<Agent<Record<string, unknown>>>;
+    readonly agent: _angular_core.InputSignal<Agent<unknown>>;
     readonly matchKind: _angular_core.InputSignal<string | undefined>;
     readonly title: _angular_core.InputSignal<string>;
     readonly showEdit: _angular_core.InputSignal<boolean>;
@@ -2099,6 +2348,9 @@ declare function statusColor(status: SubagentStatus): string;
 declare class ChatSubagentCardComponent {
     readonly subagent: _angular_core.InputSignal<Subagent>;
     readonly state: _angular_core.Signal<TraceState>;
+    private readonly markdownDocuments;
+    constructor();
+    protected markdownDocumentFor(content: string, message: Message): StreamingMarkdownDocument;
     protected textOf(m: Message): string;
     protected toolCallsFor(m: Message): ToolCall[];
     protected toToolCallInfo(tc: ToolCall): ToolCallInfo;
@@ -2118,39 +2370,6 @@ declare class CitationsResolverService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<CitationsResolverService>;
 }
 
-/**
- * Renders streaming markdown by walking a @cacheplane/partial-markdown AST
- * through @threadplane/render's view registry.
- *
- * Reactivity model: the live `parser.root` keeps a stable JS reference
- * across pushes (partial-markdown's identity guarantee). To make Angular
- * signals propagate downstream when the underlying tree changes, we surface
- * a materialized snapshot via `materialize()`. The snapshot shares
- * structurally — unchanged subtrees keep the SAME reference, and any
- * descendant change yields a NEW root reference. This lets Angular's
- * `Object.is` equality check both detect changes (root reference differs)
- * and short-circuit unchanged subtrees (per-node references stable).
- *
- * Override per-node-type renderers via the `[viewRegistry]` input or by
- * supplying a different `MARKDOWN_VIEW_REGISTRY` provider in the injector
- * tree.
- */
-declare class ChatStreamingMdComponent {
-    readonly content: _angular_core.InputSignal<string>;
-    readonly streaming: _angular_core.InputSignal<boolean>;
-    readonly viewRegistry: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
-    readonly resolvedRegistry: _angular_core.Signal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>>>;
-    private readonly resolver;
-    constructor();
-    private parser;
-    private prior;
-    private finished;
-    private readonly finalizeTick;
-    readonly root: _angular_core.Signal<MarkdownDocumentNode | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatStreamingMdComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatStreamingMdComponent, "chat-streaming-md", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "viewRegistry": { "alias": "viewRegistry"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
 /**
  * DI token for the markdown view registry consumed by <chat-streaming-md>
  * and <md-children>. Maps MarkdownNode.type strings (e.g. "paragraph",
@@ -2456,17 +2675,15 @@ interface PartialArgsBridge {
  * tool_call.arguments JSON. Uses @cacheplane/partial-json to extract
  * structurally-complete envelope objects from the growing args string.
  *
- * Synthesis safety net: if the first complete surfaceUpdate arrives and
- * no beginRendering has been extracted yet, the bridge synthesises one
- * targeted at the surfaceUpdate's first component (preferring id='root'
- * if present). This makes the surface mount IMMEDIATELY after the first
- * surfaceUpdate parses — without waiting for the LLM to emit beginRendering
- * at the end of its envelope list — so the render-element fallback gate
- * (PR #252) actually fires while dataModelUpdates flow in.
+ * Synthesis safety net: v0.9 requires a `createSurface` envelope before
+ * any `updateComponents`. If a complete `updateComponents` arrives for a
+ * surface with no `createSurface` seen yet this turn, the bridge
+ * synthesises one (basic catalog) so the surface can mount as soon as its
+ * `root` component is defined — the store gates rendering on
+ * createSurface + root, and fills the tree in progressively after that.
  *
- * The store's apply() already treats repeated beginRendering for the same
- * surfaceId as idempotent (just re-applies styles), so the LLM's eventual
- * beginRendering (if any) is a no-op rather than a conflict.
+ * The store treats a later "real" createSurface for the same surface as an
+ * idempotent refresh, so LLMs that emit one out of order are harmless.
  */
 declare function createPartialArgsBridge(store: A2uiSurfaceStore): PartialArgsBridge;
 
@@ -2495,27 +2712,40 @@ declare class A2uiSurfaceComponent {
     readonly surfaceFallback: _angular_core.InputSignal<Type<unknown> | undefined>;
     readonly events: _angular_core.OutputEmitterRef<RenderEvent>;
     readonly action: _angular_core.OutputEmitterRef<A2uiActionMessage>;
-    /** Agent-set primary color from `beginRendering.styles.primaryColor`.
+    /** Emitted when a submit is blocked by failing validation checks —
+     * the spec client → agent error message (code VALIDATION_FAILED). */
+    readonly validationError: _angular_core.OutputEmitterRef<A2uiErrorMessage>;
+    /** Surface-owned live state store: `$bindState` props read it and input
+     * components write user edits into it, so event-time logic (checks,
+     * action context) sees CURRENT values instead of the agent-seeded
+     * snapshot. Seeded from spec.state with user edits preserved. Public so
+     * hosts (and tests) can read the live values of a rendered surface. */
+    readonly liveStore: _json_render_core.StateStore;
+    /** Last value this component seeded per state path (see chat-generative-ui:
+     * distinguishes "still our seed — safe to overwrite" from "user edited"). */
+    private readonly seeded;
+    constructor();
+    /** Agent-set primary color from `createSurface.theme.primaryColor`.
      * Returns null when unset so the host binding doesn't override the
      * consumer's `:root`-level `--a2ui-primary` default. */
     readonly primaryColor: _angular_core.Signal<string | null>;
-    /** Agent-set font family from `beginRendering.styles.font`. Returns
-     * null when unset so the host doesn't override consumer fonts. */
-    readonly fontFamily: _angular_core.Signal<string | null>;
-    /** Roots from the surface state — components whose ids appear as
-     * children of no other component. The wire spec includes
-     * `beginRendering.root` as the single root; that path stays usable
-     * but we keep the renderer permissive in case future surfaces emit
-     * multiple top-level components.
+    /** Agent identity chrome from `createSurface.theme`. When neither
+     * `agentDisplayName` nor `iconUrl` is set, no header renders at all
+     * (zero layout impact for themeless surfaces — the common case). */
+    protected readonly agentDisplayName: _angular_core.Signal<string | null>;
+    protected readonly iconUrl: _angular_core.Signal<string | null>;
+    /** Roots from the surface state. The v0.9 wire contract reserves the
+     * component id `root` as the single tree root; we keep the renderer
+     * permissive in case future surfaces emit multiple top-level
+     * components.
      *
      * Conservative: returns only the first key from componentViews
-     * insertion order. The wire format's beginRendering.root carries the
-     * true root id; plumbing it through A2uiSurfaceState is a follow-up. */
+     * insertion order. */
     readonly rootIds: _angular_core.Signal<string[]>;
     /** Convert the A2UI surface to a json-render Spec for rendering.
      *  Prefers `state().surface` (the progressively-built wire surface)
      *  over the legacy `surface` input. surfaceToSpec handles
-     *  children.explicitList → spec.children translation + reserved-key
+     *  children-id-list → spec.children translation + reserved-key
      *  filtering + path-ref → $bindState rewriting; the rendered tree
      *  then uses render-element's standard input-mapping
      *  (`childKeys: el.children`) so catalog components receive the
@@ -2533,14 +2763,19 @@ declare class A2uiSurfaceComponent {
         'a2ui:localAction': (params: Record<string, unknown>) => unknown;
     }>;
     onRenderEvent(event: RenderEvent): void;
+    /** Agent-seeded data model overlaid with the store's current state
+     * (user edits + check messages). Shallow per-key merge is sufficient:
+     * store snapshots hold whole top-level values written via pointers. */
+    private mergedLiveModel;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiSurfaceComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiSurfaceComponent, "a2ui-surface", never, { "surface": { "alias": "surface"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "catalog": { "alias": "catalog"; "required": true; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "surfaceFallback": { "alias": "surfaceFallback"; "required": false; "isSignal": true; }; }, { "events": "events"; "action": "action"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiSurfaceComponent, "a2ui-surface", never, { "surface": { "alias": "surface"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "catalog": { "alias": "catalog"; "required": true; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "surfaceFallback": { "alias": "surfaceFallback"; "required": false; "isSignal": true; }; }, { "events": "events"; "action": "action"; "validationError": "validationError"; }, never, never, true, never>;
 }
 
-/** Builds an A2uiActionMessage from handler params and the current surface.
- *  The action.context is serialized as v1 DynamicValue-wrapped entries.
- *  Sets action.label when the source component is a Button with a Text
- *  child whose literalString is non-empty. */
+/** Builds a v0.9 A2uiActionMessage from handler params and the current
+ *  surface. The action.context is the resolved plain object the renderer
+ *  produced from the component's `action.event.context`. Sets action.label
+ *  when the source component is a Button with a Text child whose text is a
+ *  non-empty bare literal. */
 declare function buildA2uiActionMessage(params: Record<string, unknown>, surface: A2uiSurface): A2uiActionMessage;
 
 /**
@@ -2560,20 +2795,36 @@ declare function a2uiBasicCatalog(): ViewRegistry;
 /** Writes a typed value to the render state store if the prop has a binding path. */
 declare function emitBinding(host: RenderHost, bindings: Record<string, string> | undefined, prop: string, value: unknown): void;
 
-/** v1 textFieldType values from A2uiTextField. */
-type TextFieldType = 'date' | 'longText' | 'number' | 'shortText' | 'obscured';
+/**
+ * The A2UI client capabilities this renderer supports — the typed
+ * `a2uiClientCapabilities` metadata a host attaches to agent requests so
+ * the agent knows which component catalogs it may target
+ * (catalog negotiation, A2UI v0.9 transport metadata).
+ *
+ * @example
+ * ```ts
+ * const metadata = { a2uiClientCapabilities: a2uiClientCapabilities() };
+ * ```
+ */
+declare function a2uiClientCapabilities(): A2uiClientCapabilities;
+
+/** v0.9 TextField variant values ('date' was removed — DateTimeInput owns dates). */
+type TextFieldVariant = 'longText' | 'number' | 'shortText' | 'obscured';
 declare class A2uiTextFieldComponent {
     private static _idCounter;
     protected readonly _inputId: string;
     private readonly host;
     readonly label: _angular_core.InputSignal<string>;
-    /** v1 prop: text (resolved string value). */
-    readonly text: _angular_core.InputSignal<string>;
-    /** Back-compat alias: value. surface-to-spec resolves DynamicString → plain string. */
-    readonly value: _angular_core.Signal<string>;
+    /** v0.9 prop: resolved string value. */
+    readonly value: _angular_core.InputSignal<string>;
     readonly placeholder: _angular_core.InputSignal<string>;
-    readonly textFieldType: _angular_core.InputSignal<TextFieldType>;
+    /** v0.9 prop: input variant (default 'shortText'). */
+    readonly variant: _angular_core.InputSignal<TextFieldVariant>;
+    /** Enforced by the surface's check gate as an implicit regex rule (plus the native pattern attribute). */
     readonly validationRegexp: _angular_core.InputSignal<string>;
+    /** Live validation message written by the surface's check gate
+     * (bound to /_a2uiChecks/<id>); empty when valid. */
+    readonly errorText: _angular_core.InputSignal<string>;
     readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly loading: _angular_core.InputSignal<boolean>;
@@ -2582,39 +2833,42 @@ declare class A2uiTextFieldComponent {
     protected readonly htmlInputType: _angular_core.Signal<string>;
     onInput(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiTextFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiTextFieldComponent, "a2ui-text-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "textFieldType": { "alias": "textFieldType"; "required": false; "isSignal": true; }; "validationRegexp": { "alias": "validationRegexp"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiTextFieldComponent, "a2ui-text-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "validationRegexp": { "alias": "validationRegexp"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiCheckBoxComponent {
     private readonly host;
     readonly label: _angular_core.InputSignal<string>;
-    /** v1 canonical prop: boolean checked state. */
-    readonly value: _angular_core.InputSignal<boolean | undefined>;
-    /** Pre-v1 alias retained for back-compat. */
-    readonly checked: _angular_core.InputSignal<boolean>;
+    /** v0.9 prop: boolean checked state. */
+    readonly value: _angular_core.InputSignal<boolean>;
+    /** Live validation message written by the surface's check gate
+     * (bound to /_a2uiChecks/<id>); empty when valid. */
+    readonly errorText: _angular_core.InputSignal<string>;
     readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
-    protected readonly effectiveValue: _angular_core.Signal<boolean>;
     onChange(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiCheckBoxComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiCheckBoxComponent, "a2ui-check-box", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiCheckBoxComponent, "a2ui-check-box", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+type ButtonVariant = 'default' | 'primary' | 'borderless';
 declare class A2uiButtonComponent {
-    /** v1: child Text component is rendered inside the button via childKeys. */
+    /** v0.9: child Text component is rendered inside the button via childKeys. */
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec>;
-    readonly primary: _angular_core.InputSignal<boolean>;
+    /** v0.9 prop: visual style (default 'default'). */
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly loading: _angular_core.InputSignal<boolean>;
+    protected cssClass(): string;
     handleClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiButtonComponent, "a2ui-button", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "primary": { "alias": "primary"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiButtonComponent, "a2ui-button", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** Resolved option shape — label and value are plain strings after surface-to-spec resolves them. */
@@ -2622,30 +2876,44 @@ interface ResolvedOption {
     label: string;
     value: string;
 }
-declare class A2uiMultipleChoiceComponent {
+declare class A2uiChoicePickerComponent {
+    private static _idCounter;
+    /** Groups the radio inputs of this instance (mutuallyExclusive mode). */
+    protected readonly _groupName: string;
     private readonly host;
     readonly label: _angular_core.InputSignal<string>;
-    /** Resolved current selections from surface-to-spec. Normalized in
-     * `selectionsArray` because LLMs sometimes seed the data model with a
-     * scalar (e.g. `"5"`) instead of an array (`["5"]`); we coerce so
-     * .includes() works either way. */
-    readonly selections: _angular_core.InputSignal<string | string[] | undefined>;
-    protected readonly selectionsArray: _angular_core.Signal<string[]>;
+    /** v0.9 prop: current selection (string[]). Normalized in `valueArray`
+     * because LLMs sometimes seed the data model with a scalar (e.g. `"5"`)
+     * instead of an array (`["5"]`); we coerce so .includes() works either way. */
+    readonly value: _angular_core.InputSignal<string | string[] | undefined>;
     /** Resolved options with plain string labels (surface-to-spec resolves DynamicString). */
     readonly options: _angular_core.InputSignal<ResolvedOption[]>;
-    /** When ≤ 1 — render as single-select <select>; otherwise multi-select checkboxes. */
-    readonly maxAllowedSelections: _angular_core.InputSignal<number>;
+    /** v0.9 prop: 'mutuallyExclusive' (single-select, default) or 'multipleSelection'. */
+    readonly variant: _angular_core.InputSignal<"mutuallyExclusive" | "multipleSelection">;
+    /** v0.9 prop: render as 'checkbox' rows (default) or 'chips'. */
+    readonly displayStyle: _angular_core.InputSignal<"checkbox" | "chips">;
+    /** v0.9 prop: when true, show a client-side option filter input. */
+    readonly filterable: _angular_core.InputSignal<boolean>;
+    /** Live validation message written by the surface's check gate
+     * (bound to /_a2uiChecks/<id>); empty when valid. */
+    readonly errorText: _angular_core.InputSignal<string>;
     readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    protected readonly valueArray: _angular_core.Signal<string[]>;
     protected readonly isSingleSelect: _angular_core.Signal<boolean>;
+    /** Local, client-side option filter (only rendered when filterable). */
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    protected readonly visibleOptions: _angular_core.Signal<ResolvedOption[]>;
     protected isSelected(value: string): boolean;
-    onSelectChange(event: Event): void;
+    onFilterInput(event: Event): void;
     onCheckChange(value: string, event: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiMultipleChoiceComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiMultipleChoiceComponent, "a2ui-multiple-choice", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "selections": { "alias": "selections"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "maxAllowedSelections": { "alias": "maxAllowedSelections"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    onChipToggle(value: string): void;
+    private toggled;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiChoicePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiChoicePickerComponent, "a2ui-choice-picker", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "displayStyle": { "alias": "displayStyle"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiSliderComponent {
@@ -2653,13 +2921,15 @@ declare class A2uiSliderComponent {
     protected readonly _inputId: string;
     private readonly host;
     readonly label: _angular_core.InputSignal<string>;
-    /** v1 prop: value (resolved DynamicNumber). */
+    /** v0.9 prop: value (resolved DynamicNumber). */
     readonly value: _angular_core.InputSignal<number>;
-    /** v1 prop: minValue. */
-    readonly minValue: _angular_core.InputSignal<number>;
-    /** v1 prop: maxValue. */
-    readonly maxValue: _angular_core.InputSignal<number>;
-    readonly step: _angular_core.InputSignal<number>;
+    /** v0.9 prop: lower bound (default 0). */
+    readonly min: _angular_core.InputSignal<number>;
+    /** v0.9 prop: upper bound. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Live validation message written by the surface's check gate
+     * (bound to /_a2uiChecks/<id>); empty when valid. */
+    readonly errorText: _angular_core.InputSignal<string>;
     readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly loading: _angular_core.InputSignal<boolean>;
@@ -2667,7 +2937,7 @@ declare class A2uiSliderComponent {
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
     onInput(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiSliderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiSliderComponent, "a2ui-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiSliderComponent, "a2ui-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiDateTimeInputComponent {
@@ -2675,12 +2945,19 @@ declare class A2uiDateTimeInputComponent {
     protected readonly _inputId: string;
     private readonly host;
     readonly label: _angular_core.InputSignal<string>;
-    /** v1 prop: value (resolved DynamicString). */
+    /** v0.9 prop: ISO 8601 value (resolved DynamicString). Still renders when absent. */
     readonly value: _angular_core.InputSignal<string>;
-    /** v1 prop: enableDate — include date portion. */
+    /** v0.9 prop: enableDate — include date portion. */
     readonly enableDate: _angular_core.InputSignal<boolean>;
-    /** v1 prop: enableTime — include time portion. */
+    /** v0.9 prop: enableTime — include time portion. */
     readonly enableTime: _angular_core.InputSignal<boolean>;
+    /** v0.9 prop: ISO lower bound mapped to the native input's min. */
+    readonly min: _angular_core.InputSignal<string | undefined>;
+    /** v0.9 prop: ISO upper bound mapped to the native input's max. */
+    readonly max: _angular_core.InputSignal<string | undefined>;
+    /** Live validation message written by the surface's check gate
+     * (bound to /_a2uiChecks/<id>); empty when valid. */
+    readonly errorText: _angular_core.InputSignal<string>;
     readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly loading: _angular_core.InputSignal<boolean>;
@@ -2690,13 +2967,14 @@ declare class A2uiDateTimeInputComponent {
     protected readonly htmlInputType: _angular_core.Signal<string>;
     onChange(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiDateTimeInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiDateTimeInputComponent, "a2ui-date-time-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "enableDate": { "alias": "enableDate"; "required": false; "isSignal": true; }; "enableTime": { "alias": "enableTime"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiDateTimeInputComponent, "a2ui-date-time-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "enableDate": { "alias": "enableDate"; "required": false; "isSignal": true; }; "enableTime": { "alias": "enableTime"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type UsageHint = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'caption' | 'body';
+type TextVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'caption' | 'body';
 declare class A2uiTextComponent {
     readonly text: _angular_core.InputSignal<string>;
-    readonly usageHint: _angular_core.InputSignal<UsageHint>;
+    /** v0.9 prop: typography variant. */
+    readonly variant: _angular_core.InputSignal<TextVariant>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
@@ -2704,92 +2982,98 @@ declare class A2uiTextComponent {
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
     protected cssClass(): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiTextComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiTextComponent, "a2ui-text", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "usageHint": { "alias": "usageHint"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiTextComponent, "a2ui-text", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiIconComponent {
-    /** v1 canonical prop. */
-    readonly name: _angular_core.InputSignal<string | undefined>;
-    /** Pre-v1 alias retained for back-compat. */
-    readonly icon: _angular_core.InputSignal<string>;
-    readonly size: _angular_core.InputSignal<number | null>;
+    /** v0.9 prop: a Material Symbols name (string) or an inline `{ svgPath }`. */
+    readonly name: _angular_core.InputSignal<string | {
+        svgPath: string;
+    } | undefined>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
-    protected readonly effectiveName: _angular_core.Signal<string>;
+    /** Inline SVG path when `name` is the `{ svgPath }` object form. */
+    protected readonly svgPath: _angular_core.Signal<string | null>;
+    /** The string ligature name when `name` is a string. */
+    protected readonly ligatureName: _angular_core.Signal<string>;
     /** The effective name as a Material Symbols ligature (camelCase → snake_case). */
     protected readonly glyphName: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiIconComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiIconComponent, "a2ui-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiIconComponent, "a2ui-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** v1 fit values mapped 1:1 to CSS object-fit. */
-type ImageFit = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
-/** v1 usageHint maps to a sizing preset. The component renders fluid by
- * default; usageHint sets a max-width / aspect-ratio to match common
- * intents. */
-type ImageUsageHint = 'icon' | 'avatar' | 'smallFeature' | 'mediumFeature' | 'largeFeature' | 'header';
+/** v0.9 fit values; 'scaleDown' maps to CSS object-fit: scale-down. */
+type ImageFit = 'contain' | 'cover' | 'fill' | 'none' | 'scaleDown';
+/** v0.9 variant maps to a sizing preset class. */
+type ImageVariant = 'icon' | 'avatar' | 'smallFeature' | 'mediumFeature' | 'largeFeature' | 'header';
 declare class A2uiImageComponent {
     readonly url: _angular_core.InputSignal<string>;
-    readonly alt: _angular_core.InputSignal<string>;
-    readonly width: _angular_core.InputSignal<number | null>;
-    readonly height: _angular_core.InputSignal<number | null>;
-    /** v1 prop: CSS object-fit equivalent. */
-    readonly fit: _angular_core.InputSignal<ImageFit | undefined>;
-    /** v1 prop: sizing preset. */
-    readonly usageHint: _angular_core.InputSignal<ImageUsageHint | undefined>;
+    /** v0.9 prop: alt text / accessible description. */
+    readonly description: _angular_core.InputSignal<string>;
+    /** v0.9 prop: CSS object-fit equivalent ('scaleDown' → 'scale-down'). */
+    readonly fit: _angular_core.InputSignal<ImageFit>;
+    /** v0.9 prop: sizing preset. */
+    readonly variant: _angular_core.InputSignal<ImageVariant>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
-    protected explicitWidth(): string | null;
-    protected explicitHeight(): string | null;
-    protected hintStyle(): {
-        maxWidth: string;
-        aspectRatio?: string;
-        borderRadius?: string;
-    } | null;
+    protected readonly objectFit: _angular_core.Signal<string>;
+    protected readonly cssClass: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiImageComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiImageComponent, "a2ui-image", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "fit": { "alias": "fit"; "required": false; "isSignal": true; }; "usageHint": { "alias": "usageHint"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiImageComponent, "a2ui-image", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "fit": { "alias": "fit"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type ColumnAlignment = 'start' | 'center' | 'end' | 'stretch';
+type ColumnAlign = 'start' | 'center' | 'end' | 'stretch';
+type ColumnJustify = 'start' | 'center' | 'end' | 'spaceAround' | 'spaceBetween' | 'spaceEvenly' | 'stretch';
 declare class A2uiColumnComponent {
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec>;
-    readonly gap: _angular_core.InputSignal<number>;
-    readonly alignment: _angular_core.InputSignal<ColumnAlignment>;
-    readonly distribution: _angular_core.InputSignal<"center" | "start" | "end" | "spaceBetween" | "spaceAround" | "spaceEvenly">;
+    /** v0.9 prop: cross-axis alignment (default 'stretch'). */
+    readonly align: _angular_core.InputSignal<ColumnAlign>;
+    /** v0.9 prop: main-axis distribution (default 'start'). */
+    readonly justify: _angular_core.InputSignal<ColumnJustify>;
+    /** Not part of the v0.9 catalog — kept for json-render generative-ui
+     * specs, which may set a numeric spacing unit (multiples of 4px) or a
+     * named size. Unset falls back to the CSS default gap. */
+    readonly gap: _angular_core.InputSignal<number | "small" | "medium" | "large" | undefined>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
     protected readonly alignItems: _angular_core.Signal<string>;
-    /** Convert the Tailwind gap unit (multiples of 4px) to pixels. */
-    protected readonly gapPx: _angular_core.Signal<number>;
+    protected readonly justifyContent: _angular_core.Signal<string>;
+    protected readonly cssClass: _angular_core.Signal<"a2ui-col a2ui-col--justify-stretch" | "a2ui-col">;
+    protected readonly gapPx: _angular_core.Signal<number | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiColumnComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiColumnComponent, "a2ui-column", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "distribution": { "alias": "distribution"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiColumnComponent, "a2ui-column", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "justify": { "alias": "justify"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type RowAlignment = 'start' | 'center' | 'end' | 'stretch';
-type RowDistribution = 'start' | 'center' | 'end' | 'space-between' | 'space-around';
+type RowAlign = 'start' | 'center' | 'end' | 'stretch';
+type RowJustify = 'start' | 'center' | 'end' | 'spaceAround' | 'spaceBetween' | 'spaceEvenly' | 'stretch';
 declare class A2uiRowComponent {
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec>;
-    readonly gap: _angular_core.InputSignal<number>;
-    readonly alignment: _angular_core.InputSignal<RowAlignment>;
-    readonly distribution: _angular_core.InputSignal<RowDistribution>;
+    /** v0.9 prop: cross-axis alignment (default 'stretch'). */
+    readonly align: _angular_core.InputSignal<RowAlign>;
+    /** v0.9 prop: main-axis distribution (default 'start'). */
+    readonly justify: _angular_core.InputSignal<RowJustify>;
+    /** Not part of the v0.9 catalog — kept for json-render generative-ui
+     * specs, which may set a numeric spacing unit (multiples of 4px) or a
+     * named size. Unset falls back to the CSS default gap. */
+    readonly gap: _angular_core.InputSignal<number | "small" | "medium" | "large" | undefined>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
     protected readonly alignItems: _angular_core.Signal<string>;
     protected readonly justifyContent: _angular_core.Signal<string>;
-    /** Convert the gap unit (multiples of 4px) to pixels. */
-    protected readonly gapPx: _angular_core.Signal<number>;
+    protected readonly cssClass: _angular_core.Signal<"a2ui-row" | "a2ui-row a2ui-row--justify-stretch">;
+    protected readonly gapPx: _angular_core.Signal<number | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiRowComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiRowComponent, "a2ui-row", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "distribution": { "alias": "distribution"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiRowComponent, "a2ui-row", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "justify": { "alias": "justify"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiCardComponent {
@@ -2804,11 +3088,8 @@ declare class A2uiCardComponent {
 }
 
 declare class A2uiDividerComponent {
-    /** Canonical v1 spec name. The LLM emits this. */
-    readonly axis: _angular_core.InputSignal<"horizontal" | "vertical" | undefined>;
-    /** Older alias retained for json-render usage and back-compat. */
-    readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
-    /** Effective axis — `axis` wins if provided, otherwise fall back to `direction`. */
+    /** v0.9 prop: divider axis (default 'horizontal'). */
+    readonly axis: _angular_core.InputSignal<"horizontal" | "vertical">;
     protected readonly orientation: _angular_core.Signal<"horizontal" | "vertical">;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
@@ -2816,33 +3097,31 @@ declare class A2uiDividerComponent {
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiDividerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiDividerComponent, "a2ui-divider", never, { "axis": { "alias": "axis"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiDividerComponent, "a2ui-divider", never, { "axis": { "alias": "axis"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiListComponent {
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec>;
     readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
-    /** v1 canonical prop: cross-axis alignment. */
-    readonly alignment: _angular_core.InputSignal<"center" | "start" | "end" | "stretch" | undefined>;
+    /** v0.9 prop: cross-axis alignment (default 'stretch'). */
+    readonly align: _angular_core.InputSignal<"center" | "start" | "end" | "stretch">;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
     protected readonly listClass: _angular_core.Signal<"a2ui-list--horizontal" | "a2ui-list--vertical">;
-    protected readonly alignmentCss: _angular_core.Signal<string | null>;
+    protected readonly alignmentCss: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiListComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiListComponent, "a2ui-list", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiListComponent, "a2ui-list", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiModalComponent {
     /**
-     * v1: childKeys[0] = entryPointChild (inline trigger),
-     *     childKeys[1] = contentChild (modal body).
+     * v0.9: childKeys[0] = trigger (inline entry point),
+     *       childKeys[1] = content (modal body).
      */
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec>;
-    /** Resolved title string (from optional title DynamicString). */
-    readonly title: _angular_core.InputSignal<string>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
@@ -2850,13 +3129,13 @@ declare class A2uiModalComponent {
     protected readonly entryPointKey: _angular_core.Signal<string>;
     protected readonly contentKey: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiModalComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiModalComponent, "a2ui-modal", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiModalComponent, "a2ui-modal", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiTabsComponent {
-    /** Resolved tab titles from tabItems[*].title — produced by surface-to-spec. */
+    /** Resolved tab titles from tabs[*].title — produced by surface-to-spec. */
     readonly tabTitles: _angular_core.InputSignal<string[]>;
-    /** v1: each child key corresponds to a tab's contentChild (childKeys[i] ↔ tabTitles[i]). */
+    /** v0.9: each child key corresponds to a tab's child (childKeys[i] ↔ tabTitles[i]). */
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
@@ -2872,32 +3151,26 @@ declare class A2uiTabsComponent {
 
 declare class A2uiAudioPlayerComponent {
     readonly url: _angular_core.InputSignal<string>;
-    /** v1 canonical prop: short description / title rendered above the player. */
+    /** v0.9 prop: short description / title rendered above the player. */
     readonly description: _angular_core.InputSignal<string>;
-    /** v1 prop name: autoPlay (camelCase). */
-    readonly autoPlay: _angular_core.InputSignal<boolean>;
-    readonly controls: _angular_core.InputSignal<boolean>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiAudioPlayerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiAudioPlayerComponent, "a2ui-audio-player", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "autoPlay": { "alias": "autoPlay"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiAudioPlayerComponent, "a2ui-audio-player", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class A2uiVideoComponent {
     readonly url: _angular_core.InputSignal<string>;
-    /** v1 prop name: autoPlay (camelCase). */
-    readonly autoPlay: _angular_core.InputSignal<boolean>;
-    readonly controls: _angular_core.InputSignal<boolean>;
     readonly bindings: _angular_core.InputSignal<Record<string, string>>;
     readonly emit: _angular_core.InputSignal<(event: string) => void>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly childKeys: _angular_core.InputSignal<string[]>;
     readonly spec: _angular_core.InputSignal<Spec | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiVideoComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiVideoComponent, "a2ui-video", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "autoPlay": { "alias": "autoPlay"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiVideoComponent, "a2ui-video", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -2961,8 +3234,11 @@ type ViewProps<S extends StandardSchemaV1> = Prettify<StandardSchemaInferOutput<
  * @param description Natural-language description the model sees.
  * @param schema Standard Schema (e.g. a Zod object) for the arguments; the
  *   handler's argument type is inferred from it.
- * @param handler Runs in the browser when the model calls the tool; its return
- *   type `R` is carried on the resulting {@link FunctionToolDef}.
+ * @param handler Runs in the browser when the model calls the tool. The second
+ *   argument carries an `AbortSignal`; its return type `R` is carried on the
+ *   resulting {@link FunctionToolDef}.
+ * @param options Execution policy options, including `idempotent: true` to skip
+ *   durable pre-execution claims when a guard is configured.
  * @returns A {@link FunctionToolDef} for inclusion in {@link tools}.
  * @example
  * ```ts
@@ -2970,7 +3246,7 @@ type ViewProps<S extends StandardSchemaV1> = Prettify<StandardSchemaInferOutput<
  * const registry = tools({ move_stop: move });
  * ```
  */
-declare function action<S extends StandardSchemaV1, R>(description: string, schema: S, handler: (args: StandardSchemaInferOutput<S>) => R | Promise<R>): FunctionToolDef<S, R>;
+declare function action<S extends StandardSchemaV1, R>(description: string, schema: S, handler: (args: StandardSchemaInferOutput<S>, context: FunctionToolHandlerContext) => R | Promise<R>, options?: ClientToolExecutionOptions): FunctionToolDef<S, R>;
 /**
  * Render-only component tool — the model fills the component's props from the
  * schema's output; the tool call is auto-acknowledged once the component mounts.
@@ -3001,7 +3277,7 @@ declare function action<S extends StandardSchemaV1, R>(description: string, sche
  * const registry = tools({ day_card: dayCard });
  * ```
  */
-declare function view<S extends StandardSchemaV1, C>(description: string, schema: S, component: AcceptComponent<S, C>): ViewToolDef<S, C>;
+declare function view<S extends StandardSchemaV1, C>(description: string, schema: S, component: AcceptComponent<S, C>, options?: ClientToolContinuationOptions): ViewToolDef<S, C>;
 /**
  * Interactive (human-in-the-loop) component tool — the model fills the
  * component's props from the schema's output; the value the component emits
@@ -3034,7 +3310,7 @@ declare function view<S extends StandardSchemaV1, C>(description: string, schema
  * const registry = tools({ pick_option: choice });
  * ```
  */
-declare function ask<S extends StandardSchemaV1, C>(description: string, schema: S, component: AcceptComponent<S, C>): AskToolDef<S, C>;
+declare function ask<S extends StandardSchemaV1, C>(description: string, schema: S, component: AcceptComponent<S, C>, options?: ClientToolContinuationOptions): AskToolDef<S, C>;
 /**
  * Collect named client tools into a frozen, name-keyed registry.
  *
@@ -3059,6 +3335,20 @@ declare function ask<S extends StandardSchemaV1, C>(description: string, schema:
  */
 declare function tools<const M extends Record<string, ClientToolDef>>(map: M): Readonly<M>;
 
+/** Inputs for {@link selectPendingClientToolCalls}. */
+interface SelectPendingClientToolCallsInput {
+    /** Whether the agent is currently streaming a run. Pending client tools are hidden while loading. */
+    isLoading: boolean;
+    /** Tool calls observed from the current agent state. */
+    toolCalls: readonly ToolCall[];
+    /** Client-declared tool names that should be handled in the browser. */
+    catalogNames: ReadonlySet<string>;
+    /** Tool-call ids already resolved by the local client instance. */
+    resolvedIds: ReadonlySet<string>;
+}
+/** Select client tool calls that are ready for browser-side resolution. */
+declare function selectPendingClientToolCalls(input: SelectPendingClientToolCallsInput): readonly ToolCall[];
+
 /** Validate raw model args against a Standard Schema. */
 declare function validateArgs(schema: StandardSchemaV1, args: unknown): Promise<{
     ok: true;
@@ -3068,15 +3358,23 @@ declare function validateArgs(schema: StandardSchemaV1, args: unknown): Promise<
     error: string;
 }>;
 /** Validate args, run the handler, and normalize the outcome to a ClientToolResult. */
-declare function executeFunctionTool(def: AnyFunctionToolDef, rawArgs: unknown): Promise<ClientToolResult>;
+declare function executeFunctionTool(def: AnyFunctionToolDef, rawArgs: unknown, context?: FunctionToolHandlerContext): Promise<ClientToolResult>;
 
+/** Options for wiring automatic browser function-tool execution. */
+interface ClientToolExecutorOptions {
+    readonly executionGuard?: ClientToolExecutionGuard;
+    readonly settleToolCall?: (toolCall: ToolCall, result: ClientToolResult) => void;
+    /** Settlement for calls that must NOT continue the run (user abort, teardown). */
+    readonly settleWithoutContinuing?: (toolCall: ToolCall, result: ClientToolResult) => void;
+    readonly shouldExecuteToolCall?: (toolCall: ToolCall) => boolean;
+}
 /**
  * Watches the agent's pending client tool calls and auto-runs FUNCTION tools,
  * resolving each with its result. View/ask (component) tools are handled by the
  * rendering layer, not here. No-op if the agent lacks the clientTools
  * capability. MUST be called in an injection context (sets up an effect).
  */
-declare function startClientToolExecutor(agent: Agent, registry: ClientToolRegistry): void;
+declare function startClientToolExecutor(agent: Agent, registry: ClientToolRegistry, options?: ClientToolExecutorOptions): void;
 
 interface ClientToolsCoordinator {
     /** Components for `view`/`ask` tools, keyed by tool name — merge into the chat `views`. */
@@ -3149,8 +3447,10 @@ interface MockAgentOptions {
  * @returns A {@link MockAgent} satisfying the full `Agent` contract.
  * @example
  * ```ts
+ * import { staticDelivery } from '@threadplane/chat';
+ *
  * const agent = mockAgent({
- *   messages: [{ id: '1', role: 'assistant', content: 'Hi' }],
+ *   messages: [{ id: '1', role: 'assistant', content: 'Hi', delivery: staticDelivery('1') }],
  *   isLoading: true,
  * });
  * ```
@@ -3160,5 +3460,5 @@ declare function mockAgent(opts?: MockAgentOptions): MockAgent;
 /** Inferred argument type for a schema (alias of StandardSchemaInferOutput). */
 type ToolArgs<S extends StandardSchemaV1> = StandardSchemaInferOutput<S>;
 
-export { A2uiAudioPlayerComponent, A2uiButtonComponent, A2uiCardComponent, A2uiCheckBoxComponent, A2uiColumnComponent, A2uiDateTimeInputComponent, A2uiDividerComponent, A2uiIconComponent, A2uiImageComponent, A2uiListComponent, A2uiModalComponent, A2uiMultipleChoiceComponent, A2uiRowComponent, A2uiSliderComponent, A2uiSurfaceComponent, A2uiTabsComponent, A2uiTextComponent, A2uiTextFieldComponent, A2uiVideoComponent, AGENT_ERROR_MESSAGES, AgentError, CHAT_CONFIG, CHAT_LIFECYCLE, ChatApprovalCardComponent, ChatCitationCardTemplateDirective, ChatCitationPreviewComponent, ChatCitationsCardComponent, ChatCitationsComponent, ChatComponent, ChatConfirmDialogComponent, ChatConnectedOverlayDirective, ChatErrorComponent, ChatGenerativeUiComponent, ChatGenuiSkeletonComponent, ChatHistorySearchPaletteComponent, ChatInputComponent, ChatInterruptComponent, ChatInterruptPanelComponent, ChatLauncherButtonComponent, ChatMessageActionsComponent, ChatMessageComponent, ChatMessageListComponent, ChatOverflowMenuComponent, ChatOverlayOriginDirective, ChatPopupComponent, ChatProjectListComponent, ChatReasoningComponent, ChatScrollBubbleComponent, ChatSelectComponent, ChatSidebarComponent, ChatSidenavComponent, ChatSidenavScrimComponent, ChatStreamingMdComponent, ChatSubagentCardComponent, ChatSubagentsComponent, ChatSuggestionsComponent, ChatThreadListComponent, ChatTimelineComponent, ChatTimelineSliderComponent, ChatToolCallCardComponent, ChatToolCallTemplateDirective, ChatToolCallsComponent, ChatToolViewsComponent, ChatTraceComponent, ChatTypingIndicatorComponent, ChatWelcomeComponent, ChatWelcomeSuggestionComponent, ChatWindowComponent, CitationsResolverService, IS_HEADER_ROW, MARKDOWN_VIEW_REGISTRY, MarkdownAutolinkComponent, MarkdownBlockquoteComponent, MarkdownChildrenComponent, MarkdownCitationReferenceComponent, MarkdownCodeBlockComponent, MarkdownDocumentComponent, MarkdownEmphasisComponent, MarkdownHardBreakComponent, MarkdownHeadingComponent, MarkdownHtmlComponent, MarkdownImageComponent, MarkdownInlineCodeComponent, MarkdownLinkComponent, MarkdownListComponent, MarkdownListItemComponent, MarkdownMathComponent, MarkdownParagraphComponent, MarkdownSoftBreakComponent, MarkdownStrikethroughComponent, MarkdownStrongComponent, MarkdownTableCellComponent, MarkdownTableComponent, MarkdownTableRowComponent, MarkdownTextComponent, MarkdownThematicBreakComponent, MessageTemplateDirective, a2uiBasicCatalog, action, ask, buildA2uiActionMessage, cacheplaneMarkdownViews, citationTypeLabel, createA2uiSurfaceStore, createAgentRef, createContentClassifier, createParseTreeStore, createPartialArgsBridge, deriveDomain, deriveJsonSchema, deriveMonogram, deriveSourceType, emitBinding, executeFunctionTool, extractErrorMessage, formatDuration, formatPublished, getInterrupt, getMessageType, injectThreadRouting, isAbortError, isAssistantMessage, isSystemMessage, isToolMessage, isTyping, isUserMessage, messageContent, mockAgent, monogramColor, monogramHue, normalizeEnvelopeArgs, normalizeViewEntry, provideChat, renderMarkdown, startClientToolExecutor, statusColor, submitMessage, toAgentError, toClientToolSpecs, tools, validateArgs, view };
-export type { A2uiComponentView, A2uiSurfaceState, A2uiSurfaceStore, A2uiViewEntry, A2uiViews, Agent, AgentCheckpoint, AgentCustomEvent, AgentErrorKind, AgentEvent, AgentInterrupt, AgentRef, AgentRuntimeTelemetryEvent, AgentRuntimeTelemetryPayload, AgentRuntimeTelemetryProperties, AgentRuntimeTelemetrySink, AgentStateUpdateEvent, AgentStatus, AgentSubmitInput, AgentSubmitOptions, AgentWithHistory, AnyFunctionToolDef, AskToolDef, ChatApprovalAction, ChatConfig, ChatLifecycle, ChatMessageRole, ChatRenderEvent, ChatScrollBubbleMode, ChatSelectOption, ChatSidenavMode, ChatToolCallTemplateContext, Citation, ClientToolDef, ClientToolRegistry, ClientToolResult, ClientToolSpec, ClientToolsCapability, ClientToolsCoordinator, ConnectedPosition, ContentBlock, ContentClassifier, ContentType, ElementAccumulationState, FunctionToolDef, InterruptAction, Message, MessageTemplateType, MockAgent, MockAgentOptions, OverflowMenuItem, OverlayPositionResult, ParseTreeStore, PartialArgsBridge, Project, ProjectActionAdapter, ResolvedCitation, Role, Subagent, SubagentStatus, Thread, ThreadActionAdapter, ThreadMatch, ThreadRoutingConfig, ToolArgs, ToolCall, ToolCallInfo, ToolCallStatus, TraceState, ViewProps, ViewToolDef };
+export { A2uiAudioPlayerComponent, A2uiButtonComponent, A2uiCardComponent, A2uiCheckBoxComponent, A2uiChoicePickerComponent, A2uiColumnComponent, A2uiDateTimeInputComponent, A2uiDividerComponent, A2uiIconComponent, A2uiImageComponent, A2uiListComponent, A2uiModalComponent, A2uiRowComponent, A2uiSliderComponent, A2uiSurfaceComponent, A2uiTabsComponent, A2uiTextComponent, A2uiTextFieldComponent, A2uiVideoComponent, AGENT_ERROR_MESSAGES, AgentError, CHAT_CONFIG, CHAT_LIFECYCLE, ChatApprovalCardComponent, ChatCitationCardTemplateDirective, ChatCitationPreviewComponent, ChatCitationsCardComponent, ChatCitationsComponent, ChatComponent, ChatConfirmDialogComponent, ChatConnectedOverlayDirective, ChatErrorComponent, ChatGenerativeUiComponent, ChatGenuiSkeletonComponent, ChatHistorySearchPaletteComponent, ChatInputComponent, ChatInterruptComponent, ChatInterruptPanelComponent, ChatLauncherButtonComponent, ChatMessageActionsComponent, ChatMessageComponent, ChatMessageListComponent, ChatOverflowMenuComponent, ChatOverlayOriginDirective, ChatPopupComponent, ChatProjectListComponent, ChatReasoningComponent, ChatScrollBubbleComponent, ChatSelectComponent, ChatSidebarComponent, ChatSidenavComponent, ChatSidenavScrimComponent, ChatStreamingMdComponent, ChatSubagentCardComponent, ChatSubagentsComponent, ChatSuggestionsComponent, ChatThreadListComponent, ChatTimelineComponent, ChatTimelineSliderComponent, ChatToolCallCardComponent, ChatToolCallTemplateDirective, ChatToolCallsComponent, ChatToolViewsComponent, ChatTraceComponent, ChatTypingIndicatorComponent, ChatWelcomeComponent, ChatWelcomeSuggestionComponent, ChatWindowComponent, CitationsResolverService, IS_HEADER_ROW, MARKDOWN_VIEW_REGISTRY, MarkdownAutolinkComponent, MarkdownBlockquoteComponent, MarkdownChildrenComponent, MarkdownCitationReferenceComponent, MarkdownCodeBlockComponent, MarkdownDocumentComponent, MarkdownEmphasisComponent, MarkdownHardBreakComponent, MarkdownHeadingComponent, MarkdownHtmlComponent, MarkdownImageComponent, MarkdownInlineCodeComponent, MarkdownLinkComponent, MarkdownListComponent, MarkdownListItemComponent, MarkdownMathComponent, MarkdownParagraphComponent, MarkdownSoftBreakComponent, MarkdownStrikethroughComponent, MarkdownStrongComponent, MarkdownTableCellComponent, MarkdownTableComponent, MarkdownTableRowComponent, MarkdownTextComponent, MarkdownThematicBreakComponent, MessageTemplateDirective, STREAMING_MARKDOWN_CONTRACT_VIOLATION_POLICY, a2uiBasicCatalog, a2uiClientCapabilities, action, ask, buildA2uiActionMessage, cacheplaneMarkdownViews, cancelledClientToolResult, citationSourceVisual, citationTypeLabel, citationTypeMeta, clientToolGuardFailureResult, completeDelivery, createA2uiSurfaceStore, createAgentRef, createContentClassifier, createParseTreeStore, createPartialArgsBridge, defaultInterruptedClientToolResult, deriveDomain, deriveJsonSchema, deriveMonogram, deriveSourceType, emitBinding, executeFunctionTool, extractErrorMessage, formatDuration, formatPublished, getInterrupt, getMessageType, injectThreadRouting, isAbortError, isAssistantMessage, isSystemMessage, isToolMessage, isTyping, isUserMessage, markdownDocument, messageContent, mockAgent, monogramColor, monogramHue, normalizeEnvelopeArgs, normalizeViewEntry, provideChat, renderMarkdown, selectPendingClientToolCalls, shouldClaimBeforeExecute, startClientToolExecutor, staticDelivery, statusColor, streamingDelivery, submitMessage, toAgentError, toClientToolSpecs, tools, validateArgs, view };
+export type { A2uiComponentView, A2uiSurfaceState, A2uiSurfaceStore, A2uiViewEntry, A2uiViews, Agent, AgentCheckpoint, AgentCustomEvent, AgentErrorKind, AgentEvent, AgentInterrupt, AgentRef, AgentRuntimeTelemetryEvent, AgentRuntimeTelemetryPayload, AgentRuntimeTelemetryProperties, AgentRuntimeTelemetrySink, AgentStateUpdateEvent, AgentStatus, AgentSubmitInput, AgentSubmitOptions, AgentWithHistory, AnyFunctionToolDef, AskToolDef, ChatApprovalAction, ChatConfig, ChatLifecycle, ChatMessageRole, ChatRenderEvent, ChatScrollBubbleMode, ChatSelectOption, ChatSidenavMode, ChatToolCallTemplateContext, Citation, CitationImageVisual, CitationMonogramVisual, CitationSourceVisual, CitationTypeIcon, CitationTypeIconVisual, CitationTypeMeta, ClientToolContinuationLimitEvent, ClientToolContinuationOptions, ClientToolContinuationPolicy, ClientToolDef, ClientToolExecutionGuard, ClientToolExecutionKey, ClientToolExecutionOptions, ClientToolExecutionRecord, ClientToolExecutionStore, ClientToolExecutorOptions, ClientToolLifecycle, ClientToolLifecyclePhase, ClientToolRegistry, ClientToolResult, ClientToolSpec, ClientToolViewProps, ClientToolsCapability, ClientToolsCoordinator, CompleteOutcome, ConnectedPosition, ContentBlock, ContentClassifier, ContentType, ElementAccumulationState, FunctionToolDef, FunctionToolHandlerContext, InterruptAction, Message, MessageDelivery, MessageTemplateType, MockAgent, MockAgentOptions, OverflowMenuItem, OverlayPositionResult, ParseTreeStore, PartialArgsBridge, Project, ProjectActionAdapter, ResolvedCitation, Role, SelectPendingClientToolCallsInput, StreamingMarkdownContractViolationPolicy, StreamingMarkdownDocument, Subagent, SubagentStatus, Thread, ThreadActionAdapter, ThreadMatch, ThreadRoutingConfig, ToolArgs, ToolCall, ToolCallInfo, ToolCallStatus, TraceState, ViewProps, ViewToolDef };