@wallarm-org/design-system 3.2.0 → 3.3.0

package/dist/components/WallyAssistant/model/deriveChatState.js

@@ -0,0 +1,54 @@
+const LIVE_STEP_STATUSES = new Set([
+    'pending',
+    'running',
+    'awaiting-approval'
+]);
+const NO_APPROVALS = [];
+const isRunningStatus = (status)=>'submitted' === status || 'streaming' === status;
+const isLiveStepStatus = (status)=>LIVE_STEP_STATUSES.has(status);
+const isLiveStep = (step)=>isLiveStepStatus(step.status) || (step.steps?.some(isLiveStep) ?? false);
+const approvalsOf = (message)=>message?.role === 'assistant' ? message.parts.filter((p)=>'approval' === p.type) : [];
+const hasPendingApproval = (message)=>approvalsOf(message).some((p)=>'pending' === p.status);
+const getDockedApprovals = (lastRow)=>{
+    const approvals = approvalsOf(lastRow);
+    const pending = approvals.filter((p)=>'pending' === p.status);
+    if (pending.length) return pending;
+    const last = approvals[approvals.length - 1];
+    return last ? [
+        last
+    ] : NO_APPROVALS;
+};
+const copyTextOf = (message)=>'assistant' === message.role && message.copyText || message.parts.flatMap((p)=>'text' === p.type && p.text ? [
+            p.text
+        ] : []).join('\n\n');
+const lastUserIdOf = (messages)=>{
+    for(let i = messages.length - 1; i >= 0; i--){
+        const m = messages[i];
+        if (m?.role === 'user') return m.id;
+    }
+};
+function deriveChatState(messages, status = 'ready', approvalPlacement = 'inline') {
+    const running = isRunningStatus(status);
+    const lastUserMessageId = lastUserIdOf(messages);
+    const last = messages[messages.length - 1];
+    const rows = running && last?.role === 'user' ? [
+        ...messages,
+        {
+            role: 'assistant',
+            id: `${last.id}:reply`,
+            parts: []
+        }
+    ] : messages;
+    const lastRow = rows[rows.length - 1];
+    const awaitingApproval = hasPendingApproval(lastRow);
+    return {
+        rows,
+        empty: 0 === messages.length,
+        running,
+        awaitingApproval,
+        busy: running && !awaitingApproval,
+        lastUserMessageId,
+        dockedApprovals: 'docked' === approvalPlacement ? getDockedApprovals(lastRow) : NO_APPROVALS
+    };
+}
+export { copyTextOf, deriveChatState, getDockedApprovals, hasPendingApproval, isLiveStep, isLiveStepStatus, isRunningStatus };

package/dist/components/WallyAssistant/model/labels.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Every user-visible string WallyAssistant and the data views render. English defaults; pass a
+ * `Partial<ChatLabels>` to override, so a key added in a minor release doesn't break the build.
+ */
+export interface ChatLabels {
+    /** Header title text; undefined keeps the built "Ask Wally" mark. */
+    title?: string;
+    /** Chat aria-label. */
+    region: string;
+    /** Log aria-label. */
+    log: string;
+    greeting: string;
+    suggestions: string;
+    placeholder: string;
+    /** Textarea aria-label. */
+    input: string;
+    send: string;
+    stop: string;
+    disclaimer: string;
+    scrollToBottom: string;
+    you: string;
+    assistant: string;
+    showMore: string;
+    showLess: string;
+    /** The loader and the synthetic Working row. */
+    working: string;
+    messageActions: string;
+    copy: string;
+    feedbackPositive: string;
+    feedbackNegative: string;
+    retry: string;
+    approvalCaption: string;
+    approvalAllowAlways: string;
+    approvalAllowOnce: string;
+    approvalReject: string;
+    approvalMoreOptions: string;
+    approved: string;
+    rejected: string;
+    permissions: string;
+    permissionsHeading: string;
+    removeContext: (label: string) => string;
+}
+export declare const DEFAULT_CHAT_LABELS: ChatLabels;

package/dist/components/WallyAssistant/model/labels.js

@@ -0,0 +1,33 @@
+const DEFAULT_CHAT_LABELS = {
+    region: 'Wally chat',
+    log: 'Chat messages',
+    greeting: 'How can I help you today?',
+    suggestions: 'Suggestions',
+    placeholder: 'Ask Wally...',
+    input: 'Message Wally',
+    send: 'Send',
+    stop: 'Stop response',
+    disclaimer: 'Wally can make mistakes; always verify.',
+    scrollToBottom: 'Scroll to latest message',
+    you: 'You',
+    assistant: 'Wally',
+    showMore: 'Show more',
+    showLess: 'Show less',
+    working: 'Working...',
+    messageActions: 'Message actions',
+    copy: 'Copy',
+    feedbackPositive: 'Good response',
+    feedbackNegative: 'Bad response',
+    retry: 'Retry',
+    approvalCaption: 'Requires your approval',
+    approvalAllowAlways: 'Always allow in this session',
+    approvalAllowOnce: 'Allow once',
+    approvalReject: 'Reject',
+    approvalMoreOptions: 'More approval options',
+    approved: 'Approved',
+    rejected: 'Rejected',
+    permissions: 'Permission settings',
+    permissionsHeading: 'Always allowed in this conversation',
+    removeContext: (label)=>`Remove ${label}`
+};
+export { DEFAULT_CHAT_LABELS };

package/dist/components/WallyAssistant/model/model.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Wally chat data model, owned by the design system and independent of CopilotKit, AG-UI and the AI SDK.
+ * The app writes one pure mapper (its API → these types); WallyAssistant renders the result, streaming included.
+ *
+ * Rules (mapper obligations: spec §7.2)
+ * - Plain data: no ReactNode, functions, Date or class instances. Times are ISO 8601 strings. `meta` and
+ *   custom `data` are opaque to the DS (never read, rendered or serialized) and should stay JSON-serializable.
+ * - Every message, part, step and option has an `id` that never changes across snapshots.
+ * - Snapshots are immutable: pass new arrays and objects on change; keep unchanged nodes by identity where you can.
+ * - Empty strings and empty arrays mean "absent".
+ * - Renderers never throw on an unknown type, status, kind or icon value. New union members arrive in
+ *   minor releases, so every `switch` over a DS union needs a `default` branch.
+ *
+ * Identity rules
+ * 1. A text part's `id` is fixed when it starts; its `text` grows.
+ * 2. A turn's id is `${userMessageId}:reply`, stable from the loading row through the answer or an error.
+ *    Backend ids go in `meta` (e.g. `meta.sourceIds`).
+ * 3. A run that fails before any output is an assistant message with only an `error` part.
+ * 4. Optimistic user messages keep their client id after the server echoes them.
+ * 5. Step ids are unique within a message, so step toggles survive the stream.
+ * 6. Steps that arrive after a text part open a new chain-of-thought part; approvals don't close a block.
+ *    One merged block followed by one text part is also valid.
+ * 7. Keep unchanged messages and parts by identity where you can; correctness doesn't depend on it.
+ * 8. On a thread switch, remount with `key={threadId}`.
+ */
+export type ChatId = string;
+/** Opaque app data, e.g. backend ids for feedback calls. */
+export type ChatMeta = Readonly<Record<string, unknown>>;
+/** Open vocabulary: known literals autocomplete, any other string still type-checks. */
+export type ChatOpen<T extends string> = T | (string & {});
+/** Same literals as AI SDK `ChatStatus`. 'error' behaves like 'ready'; the failure itself is an `error` part. */
+export type ChatStatus = 'ready' | 'submitted' | 'streaming' | 'error';
+/** Figma 483:1899 step types (resolved to src/icons inside the DS), or any key from the `icons` prop. */
+export type ChatIconKey = ChatOpen<'thinking' | 'plan' | 'decision' | 'subagent' | 'tool' | 'command' | 'web-search' | 'query' | 'datastore' | 'api' | 'read' | 'fetch' | 'filter' | 'create' | 'edit' | 'cite' | 'threat' | 'scan' | 'pending' | 'summary' | 'created'>;
+interface ChatPartBase {
+    readonly id: ChatId;
+    readonly meta?: ChatMeta;
+}
+/** Assistant text is GFM markdown, rendered by `markdown` (default `AssistantMessageMarkdown`); user text is plain, whitespace kept.
+ *  While streaming, `text` grows under the same `id`: snapshots, never deltas. */
+export interface ChatTextPart extends ChatPartBase {
+    readonly type: 'text';
+    readonly text: string;
+}
+/** A superset of AI SDK tool states, CopilotKit ToolCallStatus and AG-UI events:
+ *  pending = args streaming · running = executing · awaiting-approval = waiting for a human ·
+ *  done = has a result · error = failed · denied = the user rejected it · cancelled = the run stopped first. */
+export type ChatStepStatus = 'pending' | 'running' | 'awaiting-approval' | 'done' | 'error' | 'denied' | 'cancelled';
+/** Changes defaults only: reasoning → Brain icon, open while live; tool → Wrench; agent → Bot. */
+export type ChatStepKind = ChatOpen<'reasoning' | 'tool' | 'agent'>;
+/** One chain-of-thought row (Figma chain-item 201:1660). Recursive for sub-agents and grouped calls. */
+export interface ChatStep {
+    readonly id: ChatId;
+    readonly status: ChatStepStatus;
+    /** Localized row text: "Thinking...", "Thought for 5s", "Searched for ABC". */
+    readonly label: string;
+    readonly kind?: ChatStepKind;
+    /** Machine name of the tool or agent ('propose_add_to_denylist'). Never rendered; for `renderStepContent`. */
+    readonly name?: string;
+    /** `null` = Figma "Simple" row (no icon cell, no connector). Absent = the kind's default. */
+    readonly icon?: ChatIconKey | null;
+    /** Right-aligned mono result (Figma "Simple-result"), e.g. "1,204". */
+    readonly metric?: string;
+    /** Collapsible body, markdown: reasoning text, tool output, error detail. Grows while the step is live.
+     *  Rendered before `steps`. */
+    readonly content?: string;
+    /** Nested steps. For an ordered sub-agent log (text, step, text), put the text in child steps with `icon: null`.
+     *  A sub-agent's own text never goes into the answer. */
+    readonly steps?: readonly ChatStep[];
+    readonly meta?: ChatMeta;
+}
+/** One block of steps, rendered as one ChainOfThought. */
+export interface ChatChainOfThoughtPart extends ChatPartBase {
+    readonly type: 'chain-of-thought';
+    readonly steps: readonly ChatStep[];
+    /** "Worked for 3m 45s", or "Thought for 12s" for reasoning-only runs. When set, the block folds under this
+     *  row once the run is over (§7.3). Leave it out to keep the block flat (e.g. a single reasoning step). */
+    readonly summary?: string;
+}
+/** Same literals as the built `ApprovalCardStatus`. */
+export type ChatApprovalStatus = 'pending' | 'approved' | 'rejected';
+/** Figma 182:4099: the first non-reject option is the primary button; other non-reject options go into its
+ *  SplitButton menu; 'reject' options are secondary buttons. Unknown kinds count as allow. */
+export type ChatApprovalOptionKind = ChatOpen<'allow-always' | 'allow-once' | 'reject'>;
+export interface ChatApprovalOption {
+    readonly id: ChatId;
+    readonly kind: ChatApprovalOptionKind;
+    /** Localized button or menu text. */
+    readonly label: string;
+}
+/** Human-in-the-loop request (tool approval or interrupt). The answer leaves through `onApprovalRespond`;
+ *  the new status arrives in the next snapshot — the DS keeps no optimistic state. */
+export interface ChatApprovalPart extends ChatPartBase {
+    readonly type: 'approval';
+    readonly status: ChatApprovalStatus;
+    /** What Wally wants to do, markdown: inline code, a fenced args block (Figma 171:1790). */
+    readonly content: string;
+    /** Default: allow-always, allow-once, reject, with ChatLabels texts (Figma 182:4099). */
+    readonly options?: readonly ChatApprovalOption[];
+    /** Disables the buttons: the answer can't be sent yet, or one is in flight. */
+    readonly disabled?: boolean;
+    /** Replaces "Approved"/"Rejected" in the resolved row, e.g. "Expired" with status 'rejected'. */
+    readonly resolvedLabel?: string;
+}
+/** A failure shown inside an answer. A run that fails before any output is an assistant message with only this part. */
+export interface ChatErrorPart extends ChatPartBase {
+    readonly type: 'error';
+    /** Localized plain text. */
+    readonly text: string;
+    /** Shows Retry when `onRetry` is set. */
+    readonly retryable?: boolean;
+}
+/** App-defined generative UI, rendered only by `renderPart`. Type your payload: `ChatCustomPart<AttackChart>`. */
+export interface ChatCustomPart<D = unknown> extends ChatPartBase {
+    readonly type: 'custom';
+    /** Namespaced by convention: 'wallarm.attack-chart'. */
+    readonly kind: string;
+    readonly data: D;
+}
+export type ChatUserPart = ChatTextPart | ChatCustomPart;
+export type ChatAssistantPart = ChatTextPart | ChatChainOfThoughtPart | ChatApprovalPart | ChatErrorPart | ChatCustomPart;
+export type ChatPart = ChatUserPart | ChatAssistantPart;
+interface ChatMessageBase {
+    readonly id: ChatId;
+    /** ISO 8601 → `<time dateTime>`, text from `formatTimestamp`. */
+    readonly createdAt?: string;
+    readonly meta?: ChatMeta;
+}
+export interface ChatUserMessage extends ChatMessageBase {
+    readonly role: 'user';
+    readonly parts: readonly ChatUserPart[];
+}
+export type ChatFeedback = 'positive' | 'negative';
+/** One assistant turn: the mapper folds the turn's reasoning, tool and text source messages into it. */
+export interface ChatAssistantMessage extends ChatMessageBase {
+    readonly role: 'assistant';
+    readonly parts: readonly ChatAssistantPart[];
+    /** App-owned current feedback; null or absent = none. */
+    readonly feedback?: ChatFeedback | null;
+    /** What Copy copies. Default: the text parts joined by a blank line. */
+    readonly copyText?: string;
+}
+export type ChatMessage = ChatUserMessage | ChatAssistantMessage;
+export interface ChatSuggestionItem {
+    readonly id: ChatId;
+    /** Pill text. */
+    readonly label: string;
+    /** Sent on click; default `label`. */
+    readonly prompt?: string;
+    readonly meta?: ChatMeta;
+}
+/** One "Always allowed in this conversation" switch row. */
+export interface ChatToolPermission {
+    readonly id: ChatId;
+    /** Tool name, e.g. 'propose_add_to_denylist'. */
+    readonly title: string;
+    readonly description?: string;
+    readonly allowed: boolean;
+}
+/** A context chip in the input bar (Figma 26:656 / 26:657). */
+export interface ChatContextItem {
+    readonly id: ChatId;
+    readonly label: string;
+    /** Default: Quote. */
+    readonly icon?: ChatIconKey;
+    /** Default true; removing needs `onContextRemove`. */
+    readonly removable?: boolean;
+}
+export interface ChatApprovalResponse {
+    readonly approvalId: ChatId;
+    readonly optionId: ChatId;
+    readonly kind: ChatApprovalOptionKind;
+    /** `kind !== 'reject'`. */
+    readonly approved: boolean;
+}
+/** What a mapper returns; it spreads straight into <WallyAssistant {...snapshot} />. */
+export interface ChatSnapshot {
+    readonly messages: readonly ChatMessage[];
+    readonly status: ChatStatus;
+    readonly suggestions?: readonly ChatSuggestionItem[];
+    readonly permissions?: readonly ChatToolPermission[];
+    readonly context?: readonly ChatContextItem[];
+}
+export {};

package/dist/components/WallyAssistant/views/ApprovalCardView.d.ts

@@ -0,0 +1,20 @@
+import type { FC, ReactNode } from 'react';
+import { type ApprovalCardProps } from '../../ApprovalCard/index.js';
+import type { ChatApprovalPart, ChatApprovalResponse, ChatMessage } from '../model/model.js';
+export interface ApprovalCardViewProps extends Omit<ApprovalCardProps, 'status' | 'children' | 'caption' | 'approvedLabel' | 'rejectedLabel'> {
+    approval: ChatApprovalPart;
+    message?: ChatMessage;
+    /** Default: the provider's onApprovalRespond. Absent → buttons disabled. */
+    onRespond?: (response: ChatApprovalResponse) => void;
+    /** ORed with `approval.disabled`; ChatPartView sets it for approvals in older messages. */
+    disabled?: boolean;
+    /** Replaces the default option buttons: render your own ApprovalCardActions (the analytics seam).
+     *  undefined = the defaults; null = no actions. */
+    children?: ReactNode;
+}
+/**
+ * One `approval` part as an `ApprovalCard`: the caption, `content` through `markdown`, then the
+ * default option buttons (or your `children`). The answer leaves through `onRespond` or the
+ * provider's `onApprovalRespond`; the resolved status arrives in the next snapshot.
+ */
+export declare const ApprovalCardView: FC<ApprovalCardViewProps>;

package/dist/components/WallyAssistant/views/ApprovalCardView.js

@@ -0,0 +1,274 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { c } from "react/compiler-runtime";
+import { ChevronDown } from "../../../icons/index.js";
+import { useTestId } from "../../../utils/testId.js";
+import { ApprovalCard, ApprovalCardActions, ApprovalCardContent } from "../../ApprovalCard/index.js";
+import { Button } from "../../Button/index.js";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "../../DropdownMenu/index.js";
+import { SplitButton } from "../../SplitButton/index.js";
+import { MarkdownView, useChatView } from "./ChatViewContext.js";
+const defaultOptions = (labels)=>[
+        {
+            id: "allow-always",
+            kind: "allow-always",
+            label: labels.approvalAllowAlways
+        },
+        {
+            id: "allow-once",
+            kind: "allow-once",
+            label: labels.approvalAllowOnce
+        },
+        {
+            id: "reject",
+            kind: "reject",
+            label: labels.approvalReject
+        }
+    ];
+const MENU_POSITIONING = {
+    placement: "bottom-end"
+};
+const DefaultActions = (t0)=>{
+    const $ = c(37);
+    const { options, disabled, moreLabel, onSelect } = t0;
+    const base = useTestId();
+    let t1;
+    if ($[0] !== base) {
+        t1 = (slot)=>base ? `${base}--${slot}` : void 0;
+        $[0] = base;
+        $[1] = t1;
+    } else t1 = $[1];
+    const idOf = t1;
+    let t2;
+    if ($[2] !== options) {
+        t2 = options.filter(_temp);
+        $[2] = options;
+        $[3] = t2;
+    } else t2 = $[3];
+    let more;
+    let primary;
+    if ($[4] !== t2) {
+        [primary, ...more] = t2;
+        $[4] = t2;
+        $[5] = more;
+        $[6] = primary;
+    } else {
+        more = $[5];
+        primary = $[6];
+    }
+    let T0;
+    let t3;
+    let t4;
+    if ($[7] !== disabled || $[8] !== idOf || $[9] !== more || $[10] !== moreLabel || $[11] !== onSelect || $[12] !== options || $[13] !== primary) {
+        const rejects = options.filter(_temp2);
+        let t5;
+        if ($[17] !== disabled || $[18] !== idOf || $[19] !== onSelect || $[20] !== primary) {
+            t5 = primary && /*#__PURE__*/ jsx(Button, {
+                disabled: disabled,
+                "data-testid": idOf(`option-${primary.id}`),
+                onClick: ()=>onSelect(primary),
+                children: primary.label
+            });
+            $[17] = disabled;
+            $[18] = idOf;
+            $[19] = onSelect;
+            $[20] = primary;
+            $[21] = t5;
+        } else t5 = $[21];
+        const primaryButton = t5;
+        T0 = ApprovalCardActions;
+        if ($[22] !== disabled || $[23] !== idOf || $[24] !== more || $[25] !== moreLabel || $[26] !== onSelect || $[27] !== primaryButton) {
+            t3 = more.length ? /*#__PURE__*/ jsxs(DropdownMenu, {
+                positioning: MENU_POSITIONING,
+                children: [
+                    /*#__PURE__*/ jsxs(SplitButton, {
+                        children: [
+                            primaryButton,
+                            /*#__PURE__*/ jsx(DropdownMenuTrigger, {
+                                asChild: true,
+                                "data-testid": idOf("more"),
+                                children: /*#__PURE__*/ jsx(Button, {
+                                    "aria-label": moreLabel,
+                                    disabled: disabled,
+                                    children: /*#__PURE__*/ jsx(ChevronDown, {})
+                                })
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(DropdownMenuContent, {
+                        children: more.map((option)=>/*#__PURE__*/ jsx(DropdownMenuItem, {
+                                disabled: disabled,
+                                "data-testid": idOf(`option-${option.id}`),
+                                onSelect: ()=>onSelect(option),
+                                children: option.label
+                            }, option.id))
+                    })
+                ]
+            }) : primaryButton;
+            $[22] = disabled;
+            $[23] = idOf;
+            $[24] = more;
+            $[25] = moreLabel;
+            $[26] = onSelect;
+            $[27] = primaryButton;
+            $[28] = t3;
+        } else t3 = $[28];
+        let t6;
+        if ($[29] !== disabled || $[30] !== idOf || $[31] !== onSelect) {
+            t6 = (option_0)=>/*#__PURE__*/ jsx(Button, {
+                    variant: "secondary",
+                    color: "neutral",
+                    disabled: disabled,
+                    "data-testid": idOf(`option-${option_0.id}`),
+                    onClick: ()=>onSelect(option_0),
+                    children: option_0.label
+                }, option_0.id);
+            $[29] = disabled;
+            $[30] = idOf;
+            $[31] = onSelect;
+            $[32] = t6;
+        } else t6 = $[32];
+        t4 = rejects.map(t6);
+        $[7] = disabled;
+        $[8] = idOf;
+        $[9] = more;
+        $[10] = moreLabel;
+        $[11] = onSelect;
+        $[12] = options;
+        $[13] = primary;
+        $[14] = T0;
+        $[15] = t3;
+        $[16] = t4;
+    } else {
+        T0 = $[14];
+        t3 = $[15];
+        t4 = $[16];
+    }
+    let t5;
+    if ($[33] !== T0 || $[34] !== t3 || $[35] !== t4) {
+        t5 = /*#__PURE__*/ jsxs(T0, {
+            children: [
+                t3,
+                t4
+            ]
+        });
+        $[33] = T0;
+        $[34] = t3;
+        $[35] = t4;
+        $[36] = t5;
+    } else t5 = $[36];
+    return t5;
+};
+const ApprovalCardView = (t0)=>{
+    const $ = c(31);
+    let approval;
+    let children;
+    let message;
+    let onRespond;
+    let props;
+    let t1;
+    if ($[0] !== t0) {
+        ({ approval, message, onRespond, disabled: t1, children, ...props } = t0);
+        $[0] = t0;
+        $[1] = approval;
+        $[2] = children;
+        $[3] = message;
+        $[4] = onRespond;
+        $[5] = props;
+        $[6] = t1;
+    } else {
+        approval = $[1];
+        children = $[2];
+        message = $[3];
+        onRespond = $[4];
+        props = $[5];
+        t1 = $[6];
+    }
+    const disabled = void 0 === t1 ? false : t1;
+    const { labels, handlers, hasApprovalRespond } = useChatView();
+    const canRespond = null != onRespond || hasApprovalRespond;
+    let t2;
+    if ($[7] !== approval || $[8] !== handlers || $[9] !== onRespond) {
+        t2 = (option)=>{
+            const response = {
+                approvalId: approval.id,
+                optionId: option.id,
+                kind: option.kind,
+                approved: "reject" !== option.kind
+            };
+            if (onRespond) onRespond(response);
+            else handlers.current.onApprovalRespond?.(response, approval);
+        };
+        $[7] = approval;
+        $[8] = handlers;
+        $[9] = onRespond;
+        $[10] = t2;
+    } else t2 = $[10];
+    const respond = t2;
+    const t3 = approval.resolvedLabel || labels.approved;
+    const t4 = approval.resolvedLabel || labels.rejected;
+    const t5 = message?.id;
+    let t6;
+    if ($[11] !== approval.content || $[12] !== approval.id || $[13] !== t5) {
+        t6 = /*#__PURE__*/ jsx(ApprovalCardContent, {
+            children: /*#__PURE__*/ jsx(MarkdownView, {
+                text: approval.content,
+                streaming: false,
+                variant: "approval",
+                messageId: t5,
+                partId: approval.id
+            })
+        });
+        $[11] = approval.content;
+        $[12] = approval.id;
+        $[13] = t5;
+        $[14] = t6;
+    } else t6 = $[14];
+    let t7;
+    if ($[15] !== approval.disabled || $[16] !== approval.options || $[17] !== canRespond || $[18] !== children || $[19] !== disabled || $[20] !== labels || $[21] !== respond) {
+        t7 = void 0 !== children ? children : /*#__PURE__*/ jsx(DefaultActions, {
+            options: approval.options?.length ? approval.options : defaultOptions(labels),
+            disabled: disabled || !!approval.disabled || !canRespond,
+            moreLabel: labels.approvalMoreOptions,
+            onSelect: respond
+        });
+        $[15] = approval.disabled;
+        $[16] = approval.options;
+        $[17] = canRespond;
+        $[18] = children;
+        $[19] = disabled;
+        $[20] = labels;
+        $[21] = respond;
+        $[22] = t7;
+    } else t7 = $[22];
+    let t8;
+    if ($[23] !== approval.status || $[24] !== labels.approvalCaption || $[25] !== props || $[26] !== t3 || $[27] !== t4 || $[28] !== t6 || $[29] !== t7) {
+        t8 = /*#__PURE__*/ jsxs(ApprovalCard, {
+            ...props,
+            status: approval.status,
+            caption: labels.approvalCaption,
+            approvedLabel: t3,
+            rejectedLabel: t4,
+            children: [
+                t6,
+                t7
+            ]
+        });
+        $[23] = approval.status;
+        $[24] = labels.approvalCaption;
+        $[25] = props;
+        $[26] = t3;
+        $[27] = t4;
+        $[28] = t6;
+        $[29] = t7;
+        $[30] = t8;
+    } else t8 = $[30];
+    return t8;
+};
+ApprovalCardView.displayName = "ApprovalCardView";
+function _temp(o) {
+    return "reject" !== o.kind;
+}
+function _temp2(o_0) {
+    return "reject" === o_0.kind;
+}
+export { ApprovalCardView };

package/dist/components/WallyAssistant/views/ChainOfThoughtView.d.ts

@@ -0,0 +1,18 @@
+import { type FC } from 'react';
+import { type ChainOfThoughtProps } from '../../ChainOfThought/index.js';
+import type { ChatChainOfThoughtPart, ChatMessage } from '../model/model.js';
+/** `...rest` lands on the root `ol`. The DOM `part` attribute is dropped: `part` is the data here. */
+export interface ChainOfThoughtViewProps extends Omit<ChainOfThoughtProps, 'children' | 'part'> {
+    part: ChatChainOfThoughtPart;
+    message: ChatMessage;
+    /** The run is still producing this message: the block stays flat and never folds. */
+    active?: boolean;
+    /** Append the synthetic "Working..." row: the run is busy but no step is live. */
+    working?: boolean;
+}
+/**
+ * One `chain-of-thought` part as a `ChainOfThought`. Flat while the run is active (plus a
+ * "Working..." row when `working`); folds under its `summary` once the run is over. A reasoning
+ * step is open while live and closes when done; a manual toggle always wins and survives the fold.
+ */
+export declare const ChainOfThoughtView: FC<ChainOfThoughtViewProps>;