@vibesdotdev/chat 0.0.0-stage → 1.0.0-rc.0

package/dist/svelte/components/tool-call-cancellation.svelte.js

@@ -0,0 +1,50 @@
+import { SvelteSet } from 'svelte/reactivity';
+import { settle, valueFreeFailure } from '@vibesdotdev/kernel';
+import { getLogger } from '@vibesdotdev/logging';
+import { toolCallKey } from '@vibesdotdev/kit/components/tool-widgets';
+const cancellableStatuses = new Set(['pending', 'running', 'streaming', 'awaiting_approval']);
+export function isCancellableToolCall(tool) {
+    return cancellableStatuses.has(String(tool.status ?? ''));
+}
+/**
+ * Per-renderer optimistic cancellation state.
+ *
+ * The Chat runtime still owns durable cancellation. This projection only makes
+ * the user's intent visible while that command settles, and removes the intent
+ * again when the command rejects so the control remains usable.
+ */
+export class ToolCallCancellationIntent {
+    runtime;
+    #requested = new SvelteSet();
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    resolveRuntime(requestRuntime) {
+        if (requestRuntime)
+            return requestRuntime;
+        if (this.runtime instanceof Function)
+            return this.runtime();
+        return this.runtime ?? undefined;
+    }
+    project(tool) {
+        return this.#requested.has(toolCallKey(tool)) && isCancellableToolCall(tool)
+            ? { ...tool, status: 'cancelled' }
+            : tool;
+    }
+    async request(tool, cancel, requestRuntime) {
+        const key = toolCallKey(tool);
+        if (this.#requested.has(key) || !isCancellableToolCall(tool))
+            return;
+        this.#requested.add(key);
+        const settled = await settle(async () => {
+            await cancel();
+        });
+        if (!settled.ok) {
+            const rt = this.resolveRuntime(requestRuntime);
+            if (rt) {
+                getLogger('chat.svelte.tool-call-cancellation', rt).warn('The tool call cancellation was rejected; the control is usable again', { error: valueFreeFailure(settled.cause) });
+            }
+            this.#requested.delete(key);
+        }
+    }
+}

package/dist/svelte/components/utils/message-utils.d.ts

@@ -0,0 +1,18 @@
+import type { ChatMessageStatus } from './types.ts';
+export declare const getMessageStatusText: (status: ChatMessageStatus) => string;
+/**
+ * True while the agent is actively working on a reply (generating tokens or
+ * running tools). Drives the breathing "Answering…" status label so a live turn
+ * reads as alive rather than static. Terminal/queued states return false.
+ */
+export declare const isLiveMessageStatus: (status: ChatMessageStatus) => boolean;
+export declare const getMessageStatusColor: (status: ChatMessageStatus) => string;
+export declare function cleanMessageContent(content: string | null | undefined): string;
+/**
+ * Some legacy/model paths hand chat renderer entity-encoded markdown markers
+ * (`> quote`) even though the renderer now preserves raw `>` correctly. Decode
+ * only line-leading blockquote markers, and skip fenced code, so prose entities
+ * stay literal while markdown structure recovers.
+ */
+export declare function normalizeChatMarkdownContent(content: string): string;
+//# sourceMappingURL=message-utils.d.ts.map

package/dist/svelte/components/utils/message-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-utils.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/utils/message-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,eAAO,MAAM,oBAAoB,GAAI,QAAQ,iBAAiB,KAAG,MAyBhE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,iBAAiB,KAAG,OACd,CAAC;AAEnD,eAAO,MAAM,qBAAqB,GAAI,QAAQ,iBAAiB,KAAG,MAkBjE,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAG9E;AAOD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBpE"}

package/dist/svelte/components/utils/message-utils.js

@@ -0,0 +1,86 @@
+export const getMessageStatusText = (status) => {
+    switch (status) {
+        case 'sending':
+            return 'Sending';
+        case 'sent':
+            return 'Sent';
+        case 'queued':
+            return 'Queued';
+        case 'pending':
+            return 'Waiting';
+        case 'declined':
+            return 'Could not reply';
+        case 'processing':
+            return 'Working on it';
+        case 'streaming':
+            return 'Answering…';
+        case 'completed':
+            return 'Completed';
+        case 'failed':
+            return 'Failed';
+        case 'cancelled':
+            return 'Stopped';
+        default:
+            return '';
+    }
+};
+/**
+ * True while the agent is actively working on a reply (generating tokens or
+ * running tools). Drives the breathing "Answering…" status label so a live turn
+ * reads as alive rather than static. Terminal/queued states return false.
+ */
+export const isLiveMessageStatus = (status) => status === 'streaming' || status === 'processing';
+export const getMessageStatusColor = (status) => {
+    switch (status) {
+        case 'sent':
+        case 'completed':
+            return 'text-success';
+        case 'failed':
+        case 'declined':
+        case 'cancelled':
+            return 'text-destructive';
+        case 'pending':
+        case 'processing':
+        case 'streaming':
+        case 'sending':
+        case 'queued':
+            return 'text-warning';
+        default:
+            return '';
+    }
+};
+export function cleanMessageContent(content) {
+    if (!content)
+        return '';
+    return content.replace(/^Final Answer:\s*/i, '').trim();
+}
+const FENCE_LINE = /^[ \t]{0,3}(```|~~~)/;
+const ENCODED_BLOCKQUOTE_PREFIX = /^([ \t]{0,3})((?:(?:>|>|>|>)[ \t]?)+)(.*)$/i;
+const ENCODED_BLOCKQUOTE_MARKER = />|>|>/gi;
+/**
+ * Some legacy/model paths hand chat renderer entity-encoded markdown markers
+ * (`> quote`) even though the renderer now preserves raw `>` correctly. Decode
+ * only line-leading blockquote markers, and skip fenced code, so prose entities
+ * stay literal while markdown structure recovers.
+ */
+export function normalizeChatMarkdownContent(content) {
+    if (!content)
+        return content;
+    let inFence = false;
+    return content
+        .split(/(\r?\n)/)
+        .map((part, index) => {
+        if (index % 2 === 1)
+            return part;
+        if (FENCE_LINE.test(part)) {
+            inFence = !inFence;
+            return part;
+        }
+        if (inFence)
+            return part;
+        return part.replace(ENCODED_BLOCKQUOTE_PREFIX, (_match, indent, markers, rest) => {
+            return `${indent}${markers.replace(ENCODED_BLOCKQUOTE_MARKER, '>')}${rest}`;
+        });
+    })
+        .join('');
+}

package/dist/svelte/components/utils/reactions.d.ts

@@ -0,0 +1,26 @@
+import type { ReactionType } from './types.ts';
+export interface ReactionCounts {
+    up: number;
+    down: number;
+}
+export interface ReactionState {
+    counts: ReactionCounts;
+    mine: ReactionType | undefined;
+}
+export interface ReactionMetadata {
+    reactionCounts?: {
+        up?: number;
+        down?: number;
+    };
+    reactions?: Array<{
+        userId?: string;
+        reactionType?: ReactionType;
+    }>;
+}
+/**
+ * Derive reaction display state from message metadata. `mine` resolves only
+ * when `currentUserId` is known (absent → counts still display, toggle intent
+ * is the caller's gate).
+ */
+export declare function readReactionState(metadata?: unknown, currentUserId?: string): ReactionState;
+//# sourceMappingURL=reactions.d.ts.map

package/dist/svelte/components/utils/reactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactions.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/utils/reactions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,WAAW,cAAc;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,YAAY,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAChC,cAAc,CAAC,EAAE;QAChB,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,IAAI,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;IACF,SAAS,CAAC,EAAE,KAAK,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,YAAY,CAAC;KAC5B,CAAC,CAAC;CACH;AAmBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,QAAQ,CAAC,EAAE,OAAO,EAClB,aAAa,CAAC,EAAE,MAAM,GACpB,aAAa,CAkCf"}

package/dist/svelte/components/utils/reactions.js

@@ -0,0 +1,50 @@
+import * as z from 'zod/v4';
+const countFieldSchema = z.number().int().nonnegative();
+const rawReactionCountsSchema = z.looseObject({
+    reactionCounts: z
+        .looseObject({
+        up: z.unknown().optional(),
+        down: z.unknown().optional()
+    })
+        .optional(),
+    reactions: z.unknown().optional()
+});
+const reactionEntrySchema = z.looseObject({
+    userId: z.string().optional(),
+    reactionType: z.enum(['up', 'down']).optional()
+});
+/**
+ * Derive reaction display state from message metadata. `mine` resolves only
+ * when `currentUserId` is known (absent → counts still display, toggle intent
+ * is the caller's gate).
+ */
+export function readReactionState(metadata, currentUserId) {
+    const counts = { up: 0, down: 0 };
+    let mine;
+    const containerParsed = rawReactionCountsSchema.safeParse(metadata);
+    if (containerParsed.success) {
+        const rawCounts = containerParsed.data.reactionCounts;
+        if (rawCounts) {
+            const upParsed = countFieldSchema.safeParse(rawCounts.up);
+            if (upParsed.success) {
+                counts.up = upParsed.data;
+            }
+            const downParsed = countFieldSchema.safeParse(rawCounts.down);
+            if (downParsed.success) {
+                counts.down = downParsed.data;
+            }
+        }
+        if (currentUserId && Array.isArray(containerParsed.data.reactions)) {
+            for (const item of containerParsed.data.reactions) {
+                const entryParsed = reactionEntrySchema.safeParse(item);
+                if (entryParsed.success &&
+                    entryParsed.data.userId === currentUserId &&
+                    entryParsed.data.reactionType) {
+                    mine = entryParsed.data.reactionType;
+                    break;
+                }
+            }
+        }
+    }
+    return { counts, mine };
+}

package/dist/svelte/components/utils/streaming-markdown.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Split a mid-stream markdown buffer into a settled prefix and a live tail.
+ *
+ * The problem this solves (GH #580): re-parsing the WHOLE reply — markdown AST +
+ * sanitize + code re-highlight — on every arriving token is O(n²) over the reply
+ * length. The previous remedy was to render raw text for the entire duration of
+ * the stream, so users watched literal `**bold**` and unclosed fences type
+ * themselves out and then snap to formatted at the end.
+ *
+ * The fix is to move the boundary rather than give up formatting. Everything up
+ * to the last COMPLETE block is settled: it stops changing, so the markdown
+ * renderer re-parses it only when a new block completes (once per block, not
+ * once per token). Only the trailing partial block is rendered as plain text,
+ * and that is bounded by one paragraph — not by the reply length.
+ *
+ * Safety property worth stating plainly: the split is a *transient* view
+ * concern. When the turn settles, the caller renders the full buffer through the
+ * markdown renderer in one pass, so any imperfect boundary (a loose list broken
+ * into two tight ones, say) corrects itself. The one thing the split must never
+ * do is cut inside an open code fence, because that produces an unterminated
+ * fence in the settled half — visible, wrong, and not self-correcting until the
+ * end.
+ */
+export interface SettledSplit {
+    /** Complete blocks. Safe to hand to a markdown renderer. */
+    settled: string;
+    /** The still-growing trailing block. Render as plain text. */
+    tail: string;
+}
+export declare function splitSettledMarkdown(content: string): SettledSplit;
+/**
+ * Split the live tail into render chunks, preserving whitespace runs so the
+ * plain-text layout matches what the markdown renderer will produce later.
+ *
+ * Chunks are keyed by index by the caller: appending a token adds chunks at the
+ * end and leaves earlier ones untouched, so only genuinely new text plays the
+ * arrival animation. Re-splitting the whole tail on every token is cheap because
+ * the tail is one block, not the whole reply.
+ */
+export declare function toArrivalChunks(tail: string): string[];
+/**
+ * Does the tail contain a fence that has not been closed yet?
+ *
+ * The tail is safe to render as markdown — it is one block, so re-parsing it per
+ * token costs O(block), not the O(message) that made GH #580 — EXCEPT when it
+ * holds an open fence. Then every token re-runs syntax highlighting over the
+ * growing code, and the renderer paints a code block whose end keeps moving.
+ * Plain text is both cheaper and calmer there.
+ */
+export declare function hasOpenFence(tail: string): boolean;
+//# sourceMappingURL=streaming-markdown.d.ts.map

package/dist/svelte/components/utils/streaming-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-markdown.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/utils/streaming-markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,YAAY;IAC5B,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;CACb;AAID,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAgDlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAGtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAkBlD"}

package/dist/svelte/components/utils/streaming-markdown.js

@@ -0,0 +1,109 @@
+/**
+ * Split a mid-stream markdown buffer into a settled prefix and a live tail.
+ *
+ * The problem this solves (GH #580): re-parsing the WHOLE reply — markdown AST +
+ * sanitize + code re-highlight — on every arriving token is O(n²) over the reply
+ * length. The previous remedy was to render raw text for the entire duration of
+ * the stream, so users watched literal `**bold**` and unclosed fences type
+ * themselves out and then snap to formatted at the end.
+ *
+ * The fix is to move the boundary rather than give up formatting. Everything up
+ * to the last COMPLETE block is settled: it stops changing, so the markdown
+ * renderer re-parses it only when a new block completes (once per block, not
+ * once per token). Only the trailing partial block is rendered as plain text,
+ * and that is bounded by one paragraph — not by the reply length.
+ *
+ * Safety property worth stating plainly: the split is a *transient* view
+ * concern. When the turn settles, the caller renders the full buffer through the
+ * markdown renderer in one pass, so any imperfect boundary (a loose list broken
+ * into two tight ones, say) corrects itself. The one thing the split must never
+ * do is cut inside an open code fence, because that produces an unterminated
+ * fence in the settled half — visible, wrong, and not self-correcting until the
+ * end.
+ */
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+export function splitSettledMarkdown(content) {
+    if (!content)
+        return { settled: '', tail: '' };
+    const lines = content.split('\n');
+    /** The fence string that opened the block we're inside, if any. */
+    let openFence = null;
+    /** Index of the first line that is NOT yet settled. */
+    let boundary = 0;
+    // Judge only COMPLETED lines — never the last one, which is still being typed.
+    // A partial line lies about its own structure: "`" becomes "```", and a line
+    // that reads as a closing fence becomes a non-closing one the moment a token
+    // lands after it. Deciding from a growing line makes the settled prefix shrink
+    // again, which flickers formatted text back to raw source mid-stream.
+    for (let index = 0; index < lines.length - 1; index += 1) {
+        const line = lines[index];
+        const match = FENCE.exec(line);
+        if (openFence) {
+            // Only a fence of the same character, at least as long, with nothing
+            // after it, closes the block. Anything else is code content.
+            const closes = match !== null &&
+                match[1][0] === openFence[0] &&
+                match[1].length >= openFence.length &&
+                line.slice(line.indexOf(match[1]) + match[1].length).trim() === '';
+            if (closes) {
+                openFence = null;
+                boundary = index + 1;
+            }
+            continue;
+        }
+        if (match) {
+            openFence = match[1];
+            continue;
+        }
+        // A blank line terminates the preceding block, and belongs with it.
+        if (line.trim() === '')
+            boundary = index + 1;
+    }
+    // Because only completed lines can advance it, `boundary` is monotonic across
+    // a stream: settled text never reverts to the tail.
+    return {
+        settled: lines.slice(0, boundary).join('\n'),
+        tail: lines.slice(boundary).join('\n')
+    };
+}
+/**
+ * Split the live tail into render chunks, preserving whitespace runs so the
+ * plain-text layout matches what the markdown renderer will produce later.
+ *
+ * Chunks are keyed by index by the caller: appending a token adds chunks at the
+ * end and leaves earlier ones untouched, so only genuinely new text plays the
+ * arrival animation. Re-splitting the whole tail on every token is cheap because
+ * the tail is one block, not the whole reply.
+ */
+export function toArrivalChunks(tail) {
+    if (!tail)
+        return [];
+    return tail.split(/(\s+)/).filter((chunk) => chunk !== '');
+}
+/**
+ * Does the tail contain a fence that has not been closed yet?
+ *
+ * The tail is safe to render as markdown — it is one block, so re-parsing it per
+ * token costs O(block), not the O(message) that made GH #580 — EXCEPT when it
+ * holds an open fence. Then every token re-runs syntax highlighting over the
+ * growing code, and the renderer paints a code block whose end keeps moving.
+ * Plain text is both cheaper and calmer there.
+ */
+export function hasOpenFence(tail) {
+    let open = null;
+    for (const line of tail.split('\n')) {
+        const match = FENCE.exec(line);
+        if (!match)
+            continue;
+        if (!open) {
+            open = match[1];
+            continue;
+        }
+        if (match[1][0] === open[0] &&
+            match[1].length >= open.length &&
+            line.slice(line.indexOf(match[1]) + match[1].length).trim() === '') {
+            open = null;
+        }
+    }
+    return open !== null;
+}

package/dist/svelte/components/utils/tool-calls.d.ts

@@ -0,0 +1,14 @@
+import type { ToolCallView } from '@vibesdotdev/kit/components/tool-widgets';
+export declare function normalizeToolCallView(value: unknown): ToolCallView | null;
+export declare function readToolCallViews(metadata?: unknown): ToolCallView[];
+export interface ToolCallHistoryMarker {
+    total: number;
+    omitted: number;
+}
+/**
+ * Read the consumer tail marker (`metadata.toolCallHistory`): the projection
+ * kept the recent tail and cut `omitted` older calls, recoverable through the
+ * room's `listToolCalls`. Null when nothing was cut or the marker is malformed.
+ */
+export declare function readToolCallHistory(metadata?: unknown): ToolCallHistoryMarker | null;
+//# sourceMappingURL=tool-calls.d.ts.map

package/dist/svelte/components/utils/tool-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-calls.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/utils/tool-calls.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAwG7E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CAyFzE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,YAAY,EAAE,CASpE;AAED,MAAM,WAAW,qBAAqB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,qBAAqB,GAAG,IAAI,CAOpF"}

package/dist/svelte/components/utils/tool-calls.js

@@ -0,0 +1,186 @@
+import * as z from 'zod/v4';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+const toolWidgetApprovalSchema = z.looseObject({
+    required: z.boolean().optional(),
+    decision: z.enum(['approved', 'denied', 'timeout', 'pending']).optional(),
+    reason: z.string().optional()
+});
+/** A tool-call record is an object; every field below is read from it on its own. */
+const toolCallRecordObjectSchema = z.looseObject({});
+const toolCallsContainerSchema = z.looseObject({
+    toolCalls: z.unknown().optional()
+});
+const toolCallHistorySchema = z.looseObject({
+    total: z.number(),
+    omitted: z.number()
+});
+const toolCallHistoryContainerSchema = z.looseObject({
+    toolCallHistory: toolCallHistorySchema.optional()
+});
+const toolNameFieldSchema = z.looseObject({
+    name: z.string()
+});
+const toolToolNameFieldSchema = z.looseObject({
+    toolName: z.string()
+});
+const toolToolIdFieldSchema = z.looseObject({
+    toolId: z.string()
+});
+const toolIdFieldSchema = z.looseObject({
+    id: z.string()
+});
+const toolCallIdFieldSchema = z.looseObject({
+    toolCallId: z.string()
+});
+const toolCallTitleSchema = z.looseObject({
+    title: z.string()
+});
+/** A call the agent ran as another tool keeps the model's command as its title. */
+const toolCallRewrittenFromSchema = z.looseObject({
+    rewrittenFrom: z.looseObject({ command: z.string() })
+});
+const toolCallStatusSchema = z.looseObject({
+    status: z.string()
+});
+const toolInputFieldSchema = z.looseObject({
+    input: JsonValueSchema
+});
+const toolArgumentsFieldSchema = z.looseObject({
+    arguments: JsonValueSchema
+});
+const toolArgsFieldSchema = z.looseObject({
+    args: JsonValueSchema
+});
+const toolCallOutputSchema = z.looseObject({
+    output: JsonValueSchema
+});
+const toolCallErrorStringSchema = z.looseObject({
+    error: z.string()
+});
+const toolCallErrorObjectSchema = z.looseObject({
+    error: z.looseObject({
+        message: z.string()
+    })
+});
+const toolCallApprovalSchema = z.looseObject({
+    approval: toolWidgetApprovalSchema
+});
+const toolCallDurationNumberSchema = z.looseObject({
+    durationMs: z.number().finite()
+});
+const toolTimestampFieldSchema = z.looseObject({
+    timestamp: z.string()
+});
+const toolCompletedAtFieldSchema = z.looseObject({
+    completedAt: z.string()
+});
+const toolStartedAtFieldSchema = z.looseObject({
+    startedAt: z.string()
+});
+export function normalizeToolCallView(value) {
+    const record = toolCallRecordObjectSchema.safeParse(value);
+    if (!record.success)
+        return null;
+    const parsedName = toolNameFieldSchema.safeParse(record.data);
+    const parsedToolName = toolToolNameFieldSchema.safeParse(record.data);
+    const parsedToolId = toolToolIdFieldSchema.safeParse(record.data);
+    const name = ((parsedName.success ? parsedName.data.name.trim() : '') ||
+        (parsedToolName.success ? parsedToolName.data.toolName.trim() : '') ||
+        (parsedToolId.success ? parsedToolId.data.toolId.trim() : ''));
+    if (!name)
+        return null;
+    const view = { name };
+    const parsedId = toolIdFieldSchema.safeParse(record.data);
+    const parsedToolCallId = toolCallIdFieldSchema.safeParse(record.data);
+    const id = ((parsedId.success ? parsedId.data.id.trim() : '') ||
+        (parsedToolCallId.success ? parsedToolCallId.data.toolCallId.trim() : ''));
+    if (id)
+        view.id = id;
+    const parsedTitle = toolCallTitleSchema.safeParse(record.data);
+    const parsedRewrittenFrom = toolCallRewrittenFromSchema.safeParse(record.data);
+    const title = ((parsedTitle.success ? parsedTitle.data.title.trim() : '') ||
+        (parsedRewrittenFrom.success ? parsedRewrittenFrom.data.rewrittenFrom.command.trim() : ''));
+    if (title)
+        view.title = title;
+    const parsedStatus = toolCallStatusSchema.safeParse(record.data);
+    if (parsedStatus.success) {
+        const status = parsedStatus.data.status.trim();
+        if (status)
+            view.status = status;
+    }
+    const parsedInput = toolInputFieldSchema.safeParse(record.data);
+    const parsedArguments = toolArgumentsFieldSchema.safeParse(record.data);
+    const parsedArgs = toolArgsFieldSchema.safeParse(record.data);
+    if (parsedInput.success && parsedInput.data.input !== undefined) {
+        view.input = parsedInput.data.input;
+    }
+    else if (parsedArguments.success && parsedArguments.data.arguments !== undefined) {
+        view.input = parsedArguments.data.arguments;
+    }
+    else if (parsedArgs.success && parsedArgs.data.args !== undefined) {
+        view.input = parsedArgs.data.args;
+    }
+    const parsedOutput = toolCallOutputSchema.safeParse(record.data);
+    if (parsedOutput.success && parsedOutput.data.output !== undefined) {
+        view.output = parsedOutput.data.output;
+    }
+    const stringErr = toolCallErrorStringSchema.safeParse(record.data);
+    if (stringErr.success) {
+        const msg = stringErr.data.error.trim();
+        if (msg)
+            view.error = msg;
+    }
+    else {
+        const objErr = toolCallErrorObjectSchema.safeParse(record.data);
+        if (objErr.success) {
+            const msg = objErr.data.error.message.trim();
+            if (msg)
+                view.error = msg;
+        }
+    }
+    const parsedApproval = toolCallApprovalSchema.safeParse(record.data);
+    if (parsedApproval.success && parsedApproval.data.approval !== undefined) {
+        view.approval = parsedApproval.data.approval;
+    }
+    const numDuration = toolCallDurationNumberSchema.safeParse(record.data);
+    if (numDuration.success) {
+        view.durationMs = numDuration.data.durationMs;
+    }
+    const parsedTimestamp = toolTimestampFieldSchema.safeParse(record.data);
+    const parsedCompletedAt = toolCompletedAtFieldSchema.safeParse(record.data);
+    const parsedStartedAt = toolStartedAtFieldSchema.safeParse(record.data);
+    const timestamp = ((parsedTimestamp.success ? parsedTimestamp.data.timestamp.trim() : '') ||
+        (parsedCompletedAt.success ? parsedCompletedAt.data.completedAt.trim() : '') ||
+        (parsedStartedAt.success ? parsedStartedAt.data.startedAt.trim() : ''));
+    if (timestamp)
+        view.timestamp = timestamp;
+    return view;
+}
+export function readToolCallViews(metadata) {
+    const parsed = toolCallsContainerSchema.safeParse(metadata);
+    if (!parsed.success || !Array.isArray(parsed.data.toolCalls))
+        return [];
+    const views = [];
+    for (const item of parsed.data.toolCalls) {
+        const view = normalizeToolCallView(item);
+        if (view)
+            views.push(view);
+    }
+    return views;
+}
+/**
+ * Read the consumer tail marker (`metadata.toolCallHistory`): the projection
+ * kept the recent tail and cut `omitted` older calls, recoverable through the
+ * room's `listToolCalls`. Null when nothing was cut or the marker is malformed.
+ */
+export function readToolCallHistory(metadata) {
+    const parsed = toolCallHistoryContainerSchema.safeParse(metadata);
+    if (!parsed.success || !parsed.data.toolCallHistory)
+        return null;
+    const { total, omitted } = parsed.data.toolCallHistory;
+    if (!Number.isInteger(total) || !Number.isInteger(omitted))
+        return null;
+    if (total < 0 || omitted <= 0 || omitted > total)
+        return null;
+    return { total, omitted };
+}

package/dist/svelte/components/utils/types.d.ts

@@ -0,0 +1,41 @@
+export type ChatMessageStatus = 'sending' | 'sent' | 'queued' | 'pending' | 'declined' | 'processing' | 'streaming' | 'completed' | 'failed' | 'cancelled';
+export type ChatSenderType = 'user' | 'agent' | 'system';
+export type ReactionType = 'up' | 'down';
+export interface ChatToolCallApproval {
+    required?: boolean;
+    decision?: 'approved' | 'denied' | 'timeout' | 'pending';
+    reason?: string;
+}
+export interface ChatToolCall {
+    toolCallId?: string;
+    toolName: string;
+    status?: string;
+    input?: unknown;
+    output?: unknown;
+    error?: string;
+    approval?: ChatToolCallApproval;
+    timestamp?: string;
+}
+export interface ChatMessageContentBlocks {
+    thinking?: string;
+    message?: string;
+}
+export interface ChatRenderableMessage {
+    id: string;
+    senderType: ChatSenderType;
+    status: ChatMessageStatus;
+    content?: string | null;
+    contentBlocks?: ChatMessageContentBlocks;
+    toolCalls?: ChatToolCall[];
+}
+export interface ChatTypingParticipant {
+    id: string;
+    name: string;
+    alias?: string;
+}
+export interface ChatRenderConfig {
+    allowUnsafeHtml?: boolean;
+    enableGfm?: boolean;
+    enableBreaks?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/svelte/components/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/utils/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAC1B,SAAS,GACT,MAAM,GACN,QAAQ,GACR,SAAS,GACT,UAAU,GACV,YAAY,GACZ,WAAW,GACX,WAAW,GACX,QAAQ,GACR,WAAW,CAAC;AAEf,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEzD,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,MAAM,CAAC;AAEzC,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,cAAc,CAAC;IAC3B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,SAAS,CAAC,EAAE,YAAY,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB"}

package/dist/svelte/components/utils/types.js

@@ -0,0 +1 @@
+export {};