@jini-ai/chat 0.3.11 → 0.5.0

package/dist/embed-widget/browser/page-actions.d.ts

@@ -0,0 +1,121 @@
+/** Resolved target supplied by the host; the client never derives a path from a title. */
+export interface ResolvedPageTarget {
+    readonly slug: string;
+    readonly title: string;
+    readonly path: string;
+}
+export type PageAction = {
+    readonly type: 'navigate';
+    readonly target: ResolvedPageTarget;
+    readonly auto: boolean;
+} | {
+    readonly type: 'scroll_to' | 'highlight';
+    readonly target: ResolvedPageTarget;
+};
+export type NavigateAction = Extract<PageAction, {
+    type: 'navigate';
+}>;
+export type NonNavigateAction = Exclude<PageAction, {
+    type: 'navigate';
+}>;
+export interface DirectiveCarryingEvent {
+    readonly kind: string;
+    readonly name?: string;
+    readonly data?: unknown;
+}
+export interface SplitPageActions {
+    readonly navigate: NavigateAction | null;
+    readonly other: NonNavigateAction | null;
+}
+/** Narrows an untrusted, bare queued action. URL authorization remains a separate host policy. O(1). */
+export declare function isQueuedPageAction(args: {
+    value: unknown;
+}): args is {
+    value: PageAction;
+};
+/** Narrows an untrusted directive envelope, dropping unknown kinds. O(1). */
+export declare function isPageActionDirective(args: {
+    value: unknown;
+}): args is {
+    value: {
+        kind: 'page_action';
+        action: PageAction;
+    };
+};
+/** Preserves valid action order while ignoring unrelated events. O(events) time and output space. */
+export declare function extractPageActions({ events, directiveEventName }: {
+    events: readonly DirectiveCarryingEvent[] | undefined;
+    directiveEventName: string;
+}): PageAction[];
+/** Returns only the first navigation and first page treatment. O(actions), O(1) extra space. */
+export declare function splitPageActions({ actions }: {
+    actions: readonly PageAction[];
+}): SplitPageActions;
+export interface TargetSelectionPolicy {
+    readonly candidateSelector: string;
+    readonly excludedAncestorSelector: string;
+}
+/** Exact title match first, case-insensitive fallback; never searches excluded UI. O(candidates). */
+export declare function findTargetElement({ title, root, selection }: {
+    title: string;
+    root: Pick<ParentNode, 'querySelectorAll'>;
+    selection: TargetSelectionPolicy;
+}): Element | null;
+export interface PageActionTimerPort {
+    schedule(args: {
+        callback: () => void;
+        delayMs: number;
+    }): unknown;
+    cancel(args: {
+        handle: unknown;
+    }): void;
+}
+export interface PageActionPort {
+    allows(args: {
+        action: PageAction;
+    }): boolean;
+    navigate(args: {
+        action: NavigateAction;
+    }): boolean;
+    execute(args: {
+        action: NonNavigateAction;
+    }): boolean;
+    clearHighlight(args: Record<string, never>): void;
+}
+export interface BrowserPageActionController extends PageActionPort {
+    applyHighlight(args: {
+        element: Element;
+    }): void;
+    scrollToElement(args: {
+        element: Element;
+    }): void;
+}
+export interface BrowserPageActionsArgs {
+    readonly root: Pick<ParentNode, 'querySelectorAll'>;
+    readonly selection: TargetSelectionPolicy;
+    readonly allowPath: (args: {
+        path: string;
+    }) => boolean;
+    readonly navigate: (args: {
+        path: string;
+    }) => void;
+    readonly reducedMotion: (args: Record<string, never>) => boolean;
+    readonly scroll: (args: {
+        element: Element;
+        options: ScrollIntoViewOptions;
+    }) => void;
+    readonly timers: PageActionTimerPort;
+    readonly highlightClass: string;
+    readonly fadeAnimationName: string;
+    readonly cleanupFallbackMs: number;
+}
+/**
+ * Creates page effects with injected DOM, navigation, URL policy, scroll and timers.
+ * At most one highlight belongs to this instance; cleanup and navigation remove it.
+ * URL policy is checked before queueing, navigation or page effects. Stale timers and descendant
+ * animation events cannot remove the current highlight. Navigation paths are resolved by the host,
+ * never guessed from a title; each controller owns its mutable highlight state.
+ * @complexity Execute O(candidates); other operations O(1), with one timer/listener retained.
+ */
+export declare function createBrowserPageActions(args: BrowserPageActionsArgs): BrowserPageActionController;
+//# sourceMappingURL=page-actions.d.ts.map

package/dist/embed-widget/browser/page-actions.js

@@ -0,0 +1,113 @@
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function target(value) {
+    return record(value) && typeof value.slug === 'string' && typeof value.title === 'string' && typeof value.path === 'string';
+}
+/** Narrows an untrusted, bare queued action. URL authorization remains a separate host policy. O(1). */
+export function isQueuedPageAction(args) {
+    const { value } = args;
+    if (!record(value) || !target(value.target))
+        return false;
+    return value.type === 'navigate' ? typeof value.auto === 'boolean' : value.type === 'scroll_to' || value.type === 'highlight';
+}
+/** Narrows an untrusted directive envelope, dropping unknown kinds. O(1). */
+export function isPageActionDirective(args) {
+    const { value } = args;
+    return record(value) && value.kind === 'page_action' && isQueuedPageAction({ value: value.action });
+}
+/** Preserves valid action order while ignoring unrelated events. O(events) time and output space. */
+export function extractPageActions({ events, directiveEventName }) {
+    const actions = [];
+    for (const event of events ?? []) {
+        const envelope = { value: event.data };
+        if (event.kind === 'ext' && event.name === directiveEventName && isPageActionDirective(envelope)) {
+            actions.push(envelope.value.action);
+        }
+    }
+    return actions;
+}
+/** Returns only the first navigation and first page treatment. O(actions), O(1) extra space. */
+export function splitPageActions({ actions }) {
+    return {
+        navigate: actions.find((a) => a.type === 'navigate') ?? null,
+        other: actions.find((a) => a.type !== 'navigate') ?? null,
+    };
+}
+/** Exact title match first, case-insensitive fallback; never searches excluded UI. O(candidates). */
+export function findTargetElement({ title, root, selection }) {
+    const needle = title.trim();
+    if (!needle)
+        return null;
+    const candidates = Array.from(root.querySelectorAll(selection.candidateSelector))
+        .filter(el => !el.closest(selection.excludedAncestorSelector));
+    return candidates.find(el => (el.textContent ?? '').trim() === needle)
+        ?? candidates.find(el => (el.textContent ?? '').trim().toLowerCase() === needle.toLowerCase()) ?? null;
+}
+/**
+ * Creates page effects with injected DOM, navigation, URL policy, scroll and timers.
+ * At most one highlight belongs to this instance; cleanup and navigation remove it.
+ * URL policy is checked before queueing, navigation or page effects. Stale timers and descendant
+ * animation events cannot remove the current highlight. Navigation paths are resolved by the host,
+ * never guessed from a title; each controller owns its mutable highlight state.
+ * @complexity Execute O(candidates); other operations O(1), with one timer/listener retained.
+ */
+export function createBrowserPageActions(args) {
+    if (!Number.isFinite(args.cleanupFallbackMs) || args.cleanupFallbackMs < 0)
+        throw new Error('Invalid highlight deadline');
+    let current = null;
+    const clearHighlight = (_args) => {
+        if (!current)
+            return;
+        const old = current;
+        current = null;
+        args.timers.cancel({ handle: old.handle });
+        old.element.removeEventListener('animationend', old.onEnd);
+        old.element.classList.remove(args.highlightClass);
+    };
+    function highlight(element) {
+        if (current?.element === element)
+            return;
+        clearHighlight({});
+        const onEnd = event => {
+            if (event.target === element && event.animationName === args.fadeAnimationName)
+                clearHighlight({});
+        };
+        element.classList.add(args.highlightClass);
+        element.addEventListener('animationend', onEnd);
+        // Identity check makes even a late callback from a canceled timer harmless.
+        const handle = args.timers.schedule({ delayMs: args.cleanupFallbackMs, callback: () => {
+                if (current?.element === element && current.onEnd === onEnd)
+                    clearHighlight({});
+            } });
+        current = { element, handle, onEnd };
+    }
+    const scrollToElement = ({ element }) => {
+        args.scroll({ element, options: { behavior: args.reducedMotion({}) ? 'auto' : 'smooth', block: 'center' } });
+    };
+    return {
+        applyHighlight({ element }) { highlight(element); },
+        scrollToElement,
+        allows({ action }) { return args.allowPath({ path: action.target.path }); },
+        navigate({ action }) {
+            if (!args.allowPath({ path: action.target.path }))
+                return false;
+            clearHighlight({});
+            args.navigate({ path: action.target.path });
+            return true;
+        },
+        execute({ action }) {
+            if (!args.allowPath({ path: action.target.path }))
+                return false;
+            const element = findTargetElement({ title: action.target.title, root: args.root, selection: args.selection });
+            if (!element)
+                return false;
+            scrollToElement({ element });
+            if (action.type === 'highlight')
+                highlight(element);
+            return true;
+        },
+        clearHighlight,
+    };
+}
+//# sourceMappingURL=page-actions.js.map

package/dist/embed-widget/browser/session-store.d.ts

@@ -0,0 +1,44 @@
+import type { ChatMessage } from '../../core/messages.js';
+/** Host-owned per-tab storage. No browser global or storage backend is selected here. */
+export interface SessionStoragePort {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export interface PersistedEmbedState {
+    readonly open: boolean;
+    readonly messages: ChatMessage[];
+}
+export interface BrowserSessionStore {
+    load(args: Record<string, never>): PersistedEmbedState;
+    save(args: {
+        state: PersistedEmbedState;
+    }): void;
+    clear(args: Record<string, never>): void;
+    enqueue(args: {
+        action: unknown;
+    }): void;
+    drain(args: Record<string, never>): unknown | null;
+}
+export interface BrowserSessionStoreArgs {
+    readonly storage: SessionStoragePort;
+    readonly transcriptKey: string;
+    readonly actionKey: string;
+    readonly maxMessages: number;
+    readonly maxBytes: number;
+    readonly validateMessage: (args: {
+        value: unknown;
+    }) => boolean;
+}
+/**
+ * Creates bounded, fail-soft transcript storage and a single-slot action queue.
+ * Corrupt transcripts are cleared as a whole. Actions are deleted before delivery,
+ * and a failed delete prevents delivery. Serialization/storage failures never escape.
+ * Reject oversized stored envelopes before parsing, validate the whole message batch, then trim
+ * oldest messages first. Circular serialization is fail-soft. Keys, limits, validator and Storage
+ * are injected so separate controllers never accidentally share a product-selected namespace.
+ * @complexity Load O(bytes + messages); save O(messages * serialized bytes) in the
+ * worst trimming case; queue O(serialized action bytes). State is instance-local.
+ */
+export declare function createBrowserSessionStore(args: BrowserSessionStoreArgs): BrowserSessionStore;
+//# sourceMappingURL=session-store.d.ts.map

package/dist/embed-widget/browser/session-store.js

@@ -0,0 +1,103 @@
+/**
+ * Creates bounded, fail-soft transcript storage and a single-slot action queue.
+ * Corrupt transcripts are cleared as a whole. Actions are deleted before delivery,
+ * and a failed delete prevents delivery. Serialization/storage failures never escape.
+ * Reject oversized stored envelopes before parsing, validate the whole message batch, then trim
+ * oldest messages first. Circular serialization is fail-soft. Keys, limits, validator and Storage
+ * are injected so separate controllers never accidentally share a product-selected namespace.
+ * @complexity Load O(bytes + messages); save O(messages * serialized bytes) in the
+ * worst trimming case; queue O(serialized action bytes). State is instance-local.
+ */
+export function createBrowserSessionStore(args) {
+    const { storage, transcriptKey, actionKey, maxMessages, maxBytes, validateMessage } = args;
+    if (!transcriptKey || !actionKey || transcriptKey === actionKey) {
+        throw new Error('Transcript and action keys must be nonempty and distinct');
+    }
+    if (!Number.isSafeInteger(maxMessages) || maxMessages < 0)
+        throw new Error('Invalid message limit');
+    // The smallest envelope (open=false) is 28 UTF-8 bytes.
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 28)
+        throw new Error('Invalid byte limit');
+    const empty = () => ({ open: false, messages: [] });
+    const bytes = (value) => new TextEncoder().encode(value).length;
+    const clear = (_args) => {
+        try {
+            storage.removeItem(transcriptKey);
+        }
+        catch { /* unavailable storage */ }
+    };
+    return {
+        load(_args) {
+            let raw;
+            try {
+                raw = storage.getItem(transcriptKey);
+            }
+            catch {
+                return empty();
+            }
+            if (raw === null)
+                return empty();
+            try {
+                if (bytes(raw) > maxBytes)
+                    throw new Error('Transcript exceeds byte limit');
+                const value = JSON.parse(raw);
+                if (typeof value !== 'object' || value === null || Array.isArray(value))
+                    throw new Error('Invalid envelope');
+                const state = value;
+                if (typeof state.open !== 'boolean' || !Array.isArray(state.messages)
+                    || state.messages.length > maxMessages || !state.messages.every(value => validateMessage({ value })))
+                    throw new Error('Invalid transcript');
+                return { open: state.open, messages: state.messages };
+            }
+            catch {
+                clear({});
+                return empty();
+            }
+        },
+        save({ state }) {
+            try {
+                let messages = maxMessages === 0 ? [] : state.messages.slice(-maxMessages);
+                let serialized = JSON.stringify({ open: state.open, messages });
+                while (messages.length > 0 && bytes(serialized) > maxBytes) {
+                    messages = messages.slice(1);
+                    serialized = JSON.stringify({ open: state.open, messages });
+                }
+                storage.setItem(transcriptKey, serialized);
+            }
+            catch { /* The live conversation continues even when serialization or storage fails. */ }
+        },
+        clear,
+        enqueue({ action }) {
+            try {
+                const serialized = JSON.stringify(action);
+                if (serialized !== undefined)
+                    storage.setItem(actionKey, serialized);
+            }
+            catch { /* The live page continues without a queued action. */ }
+        },
+        drain(_args) {
+            let raw;
+            try {
+                raw = storage.getItem(actionKey);
+            }
+            catch {
+                return null;
+            }
+            if (raw === null)
+                return null;
+            try {
+                storage.removeItem(actionKey);
+            }
+            catch {
+                return null;
+            }
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+//# sourceMappingURL=session-store.js.map

package/dist/embed-widget/react/embed.d.ts

@@ -0,0 +1,45 @@
+import type { ChatTransport } from '../../core/transport.js';
+import type { ChatPaneAgent } from '../../react/chat-pane.js';
+import type { BrowserSessionStore } from '../browser/session-store.js';
+import type { PageActionPort } from '../browser/page-actions.js';
+import type { EmbedHeaderCopy, EscapeKeyPort } from './header.js';
+export { EmbedChatHeader } from './header.js';
+export type { EmbedChatHeaderArgs, EmbedHeaderCopy, EscapeKeyPort } from './header.js';
+export interface EmbedChatCopy extends EmbedHeaderCopy {
+    readonly title: string;
+    readonly fabLabel: string;
+    readonly placeholder: string;
+    readonly proposalLabel: (args: {
+        title: string;
+    }) => string;
+    readonly proposalGo: string;
+}
+export interface EmbedChatWidgetArgs {
+    readonly agent: ChatPaneAgent;
+    readonly copy: EmbedChatCopy;
+    readonly transport: ChatTransport;
+    readonly session: BrowserSessionStore;
+    readonly pageActions: PageActionPort;
+    readonly directiveEventName: string;
+    readonly keyboard: EscapeKeyPort;
+    /** Schedules after host layout; returns cancellation. No browser global is captured. */
+    readonly scheduleFrame: (args: {
+        callback: () => void;
+    }) => () => void;
+}
+/**
+ * Wires the existing pane/fab to per-instance transcript and page-action ports.
+ * Keep effect ports stable for the lifetime of a mounted widget; remount for a new
+ * session/agent. Restored replies are marked processed before the pane mounts, so
+ * rehydration cannot replay navigation. Reset remounts the pane after confirmation.
+ * @complexity O(messages + latest reply events) per transcript update; O(message IDs) retained.
+ */
+export declare function EmbedChatWidget(args: EmbedChatWidgetArgs): import("react").JSX.Element;
+/** Mounts into a host-provided node and returns lifecycle cleanup. O(1) plus React rendering. */
+export declare function mountEmbedChat({ element, widget }: {
+    element: Element;
+    widget: EmbedChatWidgetArgs;
+}): {
+    unmount: (args: Record<string, never>) => void;
+};
+//# sourceMappingURL=embed.d.ts.map

package/dist/embed-widget/react/embed.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { isTerminalRunStatus } from '../../core/messages.js';
+import { ChatPane } from '../../react/chat-pane.js';
+import { ChatFab } from '../../react/components/ChatFab.js';
+import { JiniChatProvider } from '../../react/components/JiniChatProvider.js';
+import { extractPageActions, splitPageActions, isQueuedPageAction } from '../browser/page-actions.js';
+import { EmbedChatHeader } from './header.js';
+export { EmbedChatHeader } from './header.js';
+const shellStyles = `
+.jini-chat-embed__panel { position:fixed; right:var(--jini-embed-right,24px); bottom:var(--jini-embed-bottom,88px); width:min(var(--jini-embed-width,440px),calc(100vw - 32px)); height:min(var(--jini-embed-height,620px),calc(100dvh - 120px)); z-index:var(--jini-embed-z-index,1000); display:flex; flex-direction:column; }
+.jini-chat-embed__panel[hidden] { display:none; }
+.jini-chat-embed__panel > .jini-chat-pane { flex:1; min-height:0; }
+.jini-chat-embed__reset-confirm,.jini-chat-embed__proposal { display:flex; align-items:center; gap:8px; }
+.jini-chat-embed__proposal { padding:12px; background:var(--jini-embed-proposal-background,Canvas); color:var(--jini-embed-proposal-color,CanvasText); }
+`;
+/**
+ * Wires the existing pane/fab to per-instance transcript and page-action ports.
+ * Keep effect ports stable for the lifetime of a mounted widget; remount for a new
+ * session/agent. Restored replies are marked processed before the pane mounts, so
+ * rehydration cannot replay navigation. Reset remounts the pane after confirmation.
+ * @complexity O(messages + latest reply events) per transcript update; O(message IDs) retained.
+ */
+export function EmbedChatWidget(args) {
+    const { agent, copy, transport, session, pageActions, directiveEventName, keyboard, scheduleFrame } = args;
+    const [initial] = useState(() => session.load({}));
+    const [open, setOpen] = useState(initial.open);
+    const [messages, setMessages] = useState(initial.messages);
+    const [paneKey, setPaneKey] = useState(0);
+    const [pending, setPending] = useState(null);
+    const processed = useRef(new Set(initial.messages.map(message => message.id)));
+    useEffect(() => { session.save({ state: { open, messages } }); }, [session, open, messages]);
+    useEffect(() => {
+        const queued = { value: session.drain({}) };
+        if (!isQueuedPageAction(queued) || queued.value.type === 'navigate')
+            return;
+        const action = queued.value;
+        return scheduleFrame({ callback: () => { pageActions.execute({ action }); } });
+    }, [session, pageActions, scheduleFrame]);
+    useEffect(() => () => pageActions.clearHighlight({}), [pageActions]);
+    const reset = useCallback(() => {
+        session.clear({});
+        setMessages([]);
+        setPaneKey(key => key + 1);
+        setPending(null);
+        processed.current.clear();
+    }, [session]);
+    const go = useCallback((proposal, transcript) => {
+        if (!pageActions.allows({ action: proposal.navigate }))
+            return;
+        if (proposal.bundled && pageActions.allows({ action: proposal.bundled }))
+            session.enqueue({ action: proposal.bundled });
+        // Both writes must finish before the host navigation can tear down this page.
+        session.save({ state: { open, messages: transcript } });
+        pageActions.navigate({ action: proposal.navigate });
+    }, [session, pageActions, open]);
+    const onMessagesChange = useCallback((next) => {
+        setMessages(next);
+        const latest = next.at(-1);
+        if (!latest || latest.role !== 'assistant' || !isTerminalRunStatus({ status: latest.runStatus }) || processed.current.has(latest.id))
+            return;
+        processed.current.add(latest.id);
+        setPending(null);
+        const actions = extractPageActions({ events: latest.events, directiveEventName })
+            .filter(action => pageActions.allows({ action }));
+        const { navigate, other } = splitPageActions({ actions });
+        if (!navigate) {
+            if (other)
+                pageActions.execute({ action: other });
+            return;
+        }
+        const proposal = { navigate, bundled: other };
+        if (navigate.auto)
+            go(proposal, next);
+        else
+            setPending(proposal);
+    }, [directiveEventName, pageActions, go]);
+    return _jsxs("div", { className: "jini-chat-embed", children: [_jsx("style", { children: shellStyles }), _jsx(ChatFab, { open: open, onToggle: () => setOpen(current => !current), label: copy.fabLabel }), _jsx(JiniChatProvider, { transport: transport, children: _jsxs("div", { className: "jini-chat-embed__panel", hidden: !open, children: [_jsx(ChatPane, { transport: transport, agents: [agent], initialSelection: { agentId: agent.id }, initialMessages: messages, title: copy.title, placeholder: copy.placeholder, workingDirectoryControlPlacement: "none", header: _jsx(EmbedChatHeader, { title: copy.title, hasMessages: messages.length > 0, onReset: reset, copy: copy, keyboard: keyboard }), onMessagesChange: onMessagesChange }, paneKey), pending ? _jsxs("div", { className: "jini-chat-embed__proposal", children: [_jsx("span", { children: copy.proposalLabel({ title: pending.navigate.target.title }) }), _jsx("button", { type: "button", onClick: () => { setPending(null); go(pending, messages); }, children: copy.proposalGo })] }) : null] }) })] });
+}
+/** Mounts into a host-provided node and returns lifecycle cleanup. O(1) plus React rendering. */
+export function mountEmbedChat({ element, widget }) {
+    const root = createRoot(element);
+    root.render(_jsx(EmbedChatWidget, { ...widget }));
+    return { unmount: (_args) => root.unmount() };
+}
+//# sourceMappingURL=embed.js.map

package/dist/embed-widget/react/header.d.ts

@@ -0,0 +1,21 @@
+export interface EmbedHeaderCopy {
+    readonly eyebrow: string;
+    readonly newThread: string;
+    readonly cancel: string;
+    readonly discard: string;
+}
+export interface EscapeKeyPort {
+    subscribe(args: {
+        onEscape: () => void;
+    }): () => void;
+}
+export interface EmbedChatHeaderArgs {
+    readonly title: string;
+    readonly hasMessages: boolean;
+    readonly onReset: () => void;
+    readonly copy: EmbedHeaderCopy;
+    readonly keyboard: EscapeKeyPort;
+}
+/** Two-step reset with safe initial focus, Cancel and host-wide Escape. O(1) state and listeners. */
+export declare function EmbedChatHeader({ title, hasMessages, onReset, copy, keyboard }: EmbedChatHeaderArgs): import("react").JSX.Element;
+//# sourceMappingURL=header.d.ts.map

package/dist/embed-widget/react/header.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+/** Two-step reset with safe initial focus, Cancel and host-wide Escape. O(1) state and listeners. */
+export function EmbedChatHeader({ title, hasMessages, onReset, copy, keyboard }) {
+    const [confirming, setConfirming] = useState(false);
+    useEffect(() => {
+        if (!confirming)
+            return;
+        return keyboard.subscribe({ onEscape: () => setConfirming(false) });
+    }, [confirming, keyboard]);
+    return _jsxs("div", { className: "jini-chat-pane__header", children: [_jsxs("div", { className: "jini-chat-pane__heading", children: [_jsx("span", { className: "jini-chat-pane__eyebrow", children: copy.eyebrow }), _jsx("h2", { className: "jini-chat-pane__title", children: title })] }), confirming ? _jsxs("div", { className: "jini-chat-embed__reset-confirm", children: [_jsx("button", { type: "button", className: "jini-chat-embed__reset-cancel", autoFocus: true, onClick: () => setConfirming(false), children: copy.cancel }), _jsx("button", { type: "button", className: "jini-chat-pane__new-thread", onClick: () => { setConfirming(false); onReset(); }, children: copy.discard })] }) : _jsx("button", { type: "button", className: "jini-chat-pane__new-thread", onClick: () => {
+                    if (hasMessages)
+                        setConfirming(true);
+                    else
+                        onReset();
+                }, children: copy.newThread })] });
+}
+//# sourceMappingURL=header.js.map

package/dist/embed-widget/transports/fetch-sse.d.ts

@@ -0,0 +1,75 @@
+import type { AgentEvent } from '../../core/events.js';
+import type { ChatMessage } from '../../core/messages.js';
+import type { ChatTransport, StartRunInput } from '../../core/transport.js';
+export interface DecodedSseFrame {
+    readonly event: string | null;
+    readonly data: string;
+}
+/** Structurally satisfied by the existing agent-runtime decodeSseStream; host binds it. */
+export type SseDecoderPort = (args: {
+    source: AsyncIterable<Uint8Array | string>;
+}) => AsyncIterable<DecodedSseFrame>;
+export interface HistoryTurn {
+    readonly role: ChatMessage['role'];
+    readonly content: string;
+}
+export interface FetchSseRequest {
+    readonly endpoint: string;
+    readonly agentId: string;
+    readonly message: string;
+    readonly history: readonly HistoryTurn[];
+    readonly input: StartRunInput;
+}
+export type FetchSseFrameResult = {
+    readonly event?: AgentEvent;
+    readonly error?: Error;
+    readonly done?: boolean;
+};
+export interface FetchSseTransportArgs {
+    readonly endpoint: string;
+    readonly agentId: string;
+    readonly fetch: (url: string, init: RequestInit) => Promise<Response>;
+    readonly ids: (args: Record<string, never>) => string;
+    readonly decode: SseDecoderPort;
+    readonly requestBuilder: (args: FetchSseRequest) => RequestInit;
+    readonly frameMapper: (args: {
+        frame: DecodedSseFrame;
+    }) => FetchSseFrameResult;
+    readonly maxHistoryMessages: number;
+    readonly maxHistoryMessageChars: number;
+    readonly copy: {
+        readonly noUserMessage: string;
+        readonly missingBody: string;
+        readonly requestFailed: (args: {
+            status: number;
+        }) => string;
+    };
+}
+export interface FetchSseTransportOptions {
+    readonly createAbortController?: (args: Record<string, never>) => AbortController;
+    readonly onLifecycle?: (args: {
+        runId: string;
+        phase: 'started' | 'settled' | 'error' | 'aborted';
+    }) => void;
+}
+/** Default JSON wire request is an explicit host choice, never a hidden endpoint default. O(history). */
+export declare function buildJsonChatRequest({ message, history }: FetchSseRequest): RequestInit;
+/** Maps the text/error/end/directive JSON protocol with required directive vocabulary and copy. O(data). */
+export declare function mapJsonChatSseFrame({ frame, directiveEventName, streamError }: {
+    frame: DecodedSseFrame;
+    directiveEventName: string;
+    streamError: string;
+}): FetchSseFrameResult;
+/**
+ * Creates a cancellable, one-POST-per-run transport with no reattachable server state.
+ * Uses the host-bound SSE decoder rather than implementing another parser. Every run
+ * owns its controller, listeners and event log; cancellation and end settle once and
+ * prevent late events. Input and cancelSignal aborts release readers/listeners, and frames after
+ * end cannot mutate the settled reply. A later settlement clears an earlier pending directive.
+ * Default request bytes retain the {message, history} wire shape; a host requestBuilder may carry
+ * required agent identity differently. No browser module imports a Node-backed runtime barrel.
+ * The returned positional methods implement the existing ChatTransport.
+ * @complexity O(history + streamed bytes + emitted events); O(emitted events + decoder buffer) space.
+ */
+export declare function createFetchSseTransport(args: FetchSseTransportArgs, options?: FetchSseTransportOptions): ChatTransport;
+//# sourceMappingURL=fetch-sse.d.ts.map