glirastes 0.2.1 → 0.3.1

package/dist/cjs/react/transports/langgraph/langgraph-ai-chat.js

@@ -0,0 +1,94 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangGraphAiChat = LangGraphAiChat;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ai_chat_provider_js_1 = require("../../provider/ai-chat-provider.js");
+const floating_chat_ui_js_1 = require("../../components/floating-chat-ui.js");
+const langgraph_js_1 = require("../langgraph.js");
+/**
+ * Drop-in LangGraph chat widget. Bundles transport, provider, and a
+ * floating (trigger button + draggable window) chat UI into one component.
+ * Zero dependency on `@ai-sdk/react` or `ai`.
+ *
+ * ```tsx
+ * 'use client';
+ * import { LangGraphAiChat } from 'glirastes/react/langgraph';
+ *
+ * export default function Layout({ children }) {
+ *   return (
+ *     <>
+ *       {children}
+ *       <LangGraphAiChat endpoint="/api/chat" />
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * All `AiChatProviderConfig` fields (session, mentions, classNames, etc.)
+ * and `FloatingChatUIProps` (title, defaultOpen, width, height, draggable,
+ * resizable) are accepted as top-level props.
+ */
+function LangGraphAiChat({ endpoint, headers, threadId, bodyExtras, credentials, onCustomEvent, renderUpdate, sessions, title, open, onOpenChange, defaultOpen, draggable, resizable, size, hideTriggerWhenOpen, shortcut, showClearButton, confirmClear, showSessionSwitcher, headerActions, triggerIcon, showMic, welcomeMessage, children, ...providerConfig }) {
+    // The widget owns its own copy of the active id so it can feed it to
+    // the LangGraph transport as `threadId`. The provider is left in
+    // *uncontrolled* mode — we only pass `defaultActiveId` (initial seed)
+    // and `onActiveIdChange` (so the provider's auto-select / switchSession
+    // calls update our local state). This lets the provider's bootstrap
+    // skip ('default' sentinel) work correctly.
+    const [activeId, setActiveId] = (0, react_1.useState)(() => {
+        if (sessions?.activeId)
+            return sessions.activeId;
+        if (sessions?.defaultActiveId)
+            return sessions.defaultActiveId;
+        return threadId ?? 'default';
+    });
+    // If the caller controls `activeId` externally, mirror it.
+    (0, react_1.useEffect)(() => {
+        if (sessions?.activeId && sessions.activeId !== activeId) {
+            setActiveId(sessions.activeId);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [sessions?.activeId]);
+    const effectiveThreadId = sessions ? activeId : threadId;
+    // When multi-session mode is active, also surface the active id as
+    // `sessionId` in the request body. LangGraph projects vary on the
+    // canonical name (`threadId` vs `sessionId`); shipping both is harmless
+    // and lets backends like chaingrow's `/chat/stream` handler — which
+    // reads `body.sessionId` — pick up the active session without the
+    // consumer having to wire `bodyExtras` themselves.
+    const effectiveBodyExtras = (0, react_1.useMemo)(() => {
+        if (!sessions)
+            return bodyExtras;
+        return () => {
+            const base = typeof bodyExtras === 'function' ? bodyExtras() : bodyExtras ?? {};
+            return { ...base, sessionId: activeId };
+        };
+    }, [sessions, bodyExtras, activeId]);
+    const transport = (0, langgraph_js_1.useLangGraphChatTransport)({
+        endpoint,
+        headers,
+        threadId: effectiveThreadId,
+        bodyExtras: effectiveBodyExtras,
+        credentials,
+        onCustomEvent,
+        renderUpdate,
+    });
+    const effectiveSession = (0, react_1.useMemo)(() => {
+        if (!sessions)
+            return providerConfig.session;
+        // Strip any consumer-supplied `activeId` and replace with a seed
+        // (`defaultActiveId`) so the provider stays uncontrolled.
+        const { activeId: _consumerActiveId, ...rest } = sessions;
+        return {
+            ...rest,
+            defaultActiveId: activeId,
+            onActiveIdChange: (id) => {
+                setActiveId(id);
+                sessions.onActiveIdChange?.(id);
+            },
+        };
+    }, [sessions, activeId, providerConfig.session]);
+    return ((0, jsx_runtime_1.jsx)(ai_chat_provider_js_1.AiChatProvider, { transport: transport, ...providerConfig, session: effectiveSession, children: children ?? ((0, jsx_runtime_1.jsx)(floating_chat_ui_js_1.FloatingChatUI, { title: title, open: open, onOpenChange: onOpenChange, defaultOpen: defaultOpen, draggable: draggable, resizable: resizable, size: size, hideTriggerWhenOpen: hideTriggerWhenOpen, shortcut: shortcut, showClearButton: showClearButton, confirmClear: confirmClear, showSessionSwitcher: showSessionSwitcher, headerActions: headerActions, triggerIcon: triggerIcon, showMic: showMic, welcomeMessage: welcomeMessage })) }));
+}

package/dist/cjs/react/transports/langgraph.d.ts

@@ -0,0 +1,71 @@
+/**
+ * LangGraph chat transport.
+ *
+ * A React hook that implements the `ChatTransport` interface against a
+ * LangGraph backend that emits Server-Sent Events in the wire format
+ * documented below.
+ *
+ * Unlike the Vercel transport, this transport does NOT import
+ * `@langchain/langgraph`, `@langchain/core`, or `ai` at runtime — it is
+ * purely a fetch + SSE parser. A consumer's backend is free to use
+ * LangGraph JS's native `.stream()` API (or anything else that produces
+ * the same event channels) without leaking LangChain types into the
+ * frontend bundle.
+ */
+import type { ChatTransport, ChatTransportConfig, ChatTransportDataPart } from '../types.js';
+/** `event: updates` — a LangGraph node finished and produced a state delta. */
+export interface LangGraphUpdatesEvent {
+    node: string;
+    update: Record<string, unknown>;
+}
+/** `event: message` — an LLM token chunk for the assistant bubble. */
+export interface LangGraphMessageEvent {
+    content: string;
+    node?: string;
+    role: 'assistant';
+}
+/** `event: custom` — domain-specific signal emitted via LangGraph `config.writer()`. */
+export interface LangGraphCustomEvent {
+    type: string;
+    payload: unknown;
+}
+/** `event: tool_call` — a tool invocation began. */
+export interface LangGraphToolCallEvent {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+/** `event: tool_result` — a tool invocation produced a result. */
+export interface LangGraphToolResultEvent {
+    id: string;
+    result: unknown;
+}
+/** `event: error` — stream-level error. */
+export interface LangGraphErrorEvent {
+    message: string;
+    code?: string;
+}
+/**
+ * Outgoing POST body sent to the LangGraph endpoint.
+ */
+export interface LangGraphRequestBody {
+    messages: Array<{
+        role: 'user' | 'assistant' | 'system';
+        content: string;
+    }>;
+    threadId?: string;
+    [key: string]: unknown;
+}
+export interface SseEvent {
+    event: string;
+    data: string;
+}
+export declare function parseSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent, void, unknown>;
+export interface UseLangGraphChatTransportOptions extends ChatTransportConfig {
+    threadId?: string;
+    bodyExtras?: Record<string, unknown> | (() => Record<string, unknown>);
+    credentials?: RequestCredentials;
+    onCustomEvent?: (evt: LangGraphCustomEvent) => ChatTransportDataPart | null;
+    renderUpdate?: (node: string, update: Record<string, unknown>) => string | null;
+}
+export declare function useLangGraphChatTransport(options: UseLangGraphChatTransportOptions): ChatTransport;

package/dist/cjs/react/transports/langgraph.js

@@ -0,0 +1,369 @@
+"use strict";
+/**
+ * LangGraph chat transport.
+ *
+ * A React hook that implements the `ChatTransport` interface against a
+ * LangGraph backend that emits Server-Sent Events in the wire format
+ * documented below.
+ *
+ * Unlike the Vercel transport, this transport does NOT import
+ * `@langchain/langgraph`, `@langchain/core`, or `ai` at runtime — it is
+ * purely a fetch + SSE parser. A consumer's backend is free to use
+ * LangGraph JS's native `.stream()` API (or anything else that produces
+ * the same event channels) without leaking LangChain types into the
+ * frontend bundle.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSseStream = parseSseStream;
+exports.useLangGraphChatTransport = useLangGraphChatTransport;
+const react_1 = require("react");
+async function* parseSseStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    let eventName = '';
+    let dataLines = [];
+    const flush = () => {
+        if (dataLines.length === 0) {
+            eventName = '';
+            return null;
+        }
+        const evt = {
+            event: eventName || 'message',
+            data: dataLines.join('\n'),
+        };
+        eventName = '';
+        dataLines = [];
+        return evt;
+    };
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            buffer = buffer.replace(/\r\n?/g, '\n');
+            let newlineIdx;
+            while ((newlineIdx = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, newlineIdx);
+                buffer = buffer.slice(newlineIdx + 1);
+                if (line === '') {
+                    const evt = flush();
+                    if (evt)
+                        yield evt;
+                    continue;
+                }
+                if (line.startsWith(':'))
+                    continue;
+                const colonIdx = line.indexOf(':');
+                let field;
+                let value;
+                if (colonIdx === -1) {
+                    field = line;
+                    value = '';
+                }
+                else {
+                    field = line.slice(0, colonIdx);
+                    value = line.slice(colonIdx + 1);
+                    if (value.startsWith(' '))
+                        value = value.slice(1);
+                }
+                if (field === 'event') {
+                    eventName = value;
+                }
+                else if (field === 'data') {
+                    dataLines.push(value);
+                }
+            }
+        }
+        buffer += decoder.decode();
+        if (buffer.length > 0) {
+            const tail = buffer;
+            buffer = '';
+            if (!tail.startsWith(':')) {
+                const colonIdx = tail.indexOf(':');
+                if (colonIdx !== -1) {
+                    const field = tail.slice(0, colonIdx);
+                    let value = tail.slice(colonIdx + 1);
+                    if (value.startsWith(' '))
+                        value = value.slice(1);
+                    if (field === 'event')
+                        eventName = value;
+                    else if (field === 'data')
+                        dataLines.push(value);
+                }
+            }
+        }
+        const finalEvt = flush();
+        if (finalEvt)
+            yield finalEvt;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function defaultRenderUpdate(node) {
+    return `${node} running…`;
+}
+function emptyAssistantMessage(id) {
+    return {
+        id,
+        role: 'assistant',
+        parts: [],
+        createdAt: new Date(),
+    };
+}
+function appendTextDelta(message, delta) {
+    const parts = [...message.parts];
+    const last = parts[parts.length - 1];
+    if (last && last.type === 'text') {
+        const updated = { type: 'text', text: last.text + delta };
+        parts[parts.length - 1] = updated;
+    }
+    else {
+        parts.push({ type: 'text', text: delta });
+    }
+    return { ...message, parts };
+}
+function appendPart(message, part) {
+    return { ...message, parts: [...message.parts, part] };
+}
+function upsertToolInvocation(message, evt) {
+    const existing = message.parts.findIndex((p) => p.type === 'tool-invocation' && p.toolInvocationId === evt.id);
+    const invocation = {
+        type: 'tool-invocation',
+        toolInvocationId: evt.id,
+        toolName: evt.name,
+        args: evt.args ?? {},
+        state: 'call',
+    };
+    if (existing === -1)
+        return appendPart(message, invocation);
+    const parts = [...message.parts];
+    parts[existing] = invocation;
+    return { ...message, parts };
+}
+function applyToolResult(message, evt) {
+    const parts = [...message.parts];
+    const idx = parts.findIndex((p) => p.type === 'tool-invocation' && p.toolInvocationId === evt.id);
+    if (idx !== -1) {
+        const invocation = parts[idx];
+        parts[idx] = { ...invocation, state: 'output-available', result: evt.result };
+    }
+    const result = {
+        type: 'tool-result',
+        toolInvocationId: evt.id,
+        toolName: parts[idx]?.toolName ?? 'unknown',
+        result: evt.result,
+    };
+    parts.push(result);
+    return { ...message, parts };
+}
+function toWireMessages(messages) {
+    return messages.map((m) => ({
+        role: m.role,
+        content: m.parts
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text)
+            .join(''),
+    }));
+}
+function resolveHeaders(headers) {
+    if (!headers)
+        return {};
+    return typeof headers === 'function' ? headers() : headers;
+}
+function resolveBodyExtras(extras) {
+    if (!extras)
+        return {};
+    return typeof extras === 'function' ? extras() : extras;
+}
+function useLangGraphChatTransport(options) {
+    const { endpoint, headers, onData, threadId, bodyExtras, credentials = 'same-origin', onCustomEvent, renderUpdate = defaultRenderUpdate, } = options;
+    const [messages, setMessagesState] = (0, react_1.useState)([]);
+    const [status, setStatus] = (0, react_1.useState)('ready');
+    const [error, setError] = (0, react_1.useState)(null);
+    const abortRef = (0, react_1.useRef)(null);
+    const statusLabelRef = (0, react_1.useRef)(null);
+    // Mirror of the latest messages list. Used by `sendMessage` to compute
+    // the wire history *synchronously*, before the React state update
+    // has been committed — passing the result through a function updater
+    // ran into batching/timing where the closure captured the pre-update
+    // value and we shipped `messages: []` to the backend.
+    const messagesRef = (0, react_1.useRef)([]);
+    messagesRef.current = messages;
+    const headersRef = (0, react_1.useRef)(headers);
+    headersRef.current = headers;
+    const onDataRef = (0, react_1.useRef)(onData);
+    onDataRef.current = onData;
+    const bodyExtrasRef = (0, react_1.useRef)(bodyExtras);
+    bodyExtrasRef.current = bodyExtras;
+    // Thread id is stored in a ref so session switches picked up by the
+    // provider propagate into the next sendMessage without re-binding it.
+    const threadIdRef = (0, react_1.useRef)(threadId);
+    threadIdRef.current = threadId;
+    const subscribersRef = (0, react_1.useRef)(new Set());
+    const subscribeToData = (0, react_1.useCallback)((handler) => {
+        subscribersRef.current.add(handler);
+        return () => {
+            subscribersRef.current.delete(handler);
+        };
+    }, []);
+    const emitData = (0, react_1.useCallback)((part) => {
+        onDataRef.current?.(part);
+        subscribersRef.current.forEach((fn) => fn(part));
+    }, []);
+    const onCustomEventRef = (0, react_1.useRef)(onCustomEvent);
+    onCustomEventRef.current = onCustomEvent;
+    const renderUpdateRef = (0, react_1.useRef)(renderUpdate);
+    renderUpdateRef.current = renderUpdate;
+    const setMessages = (0, react_1.useCallback)((next) => {
+        setMessagesState(next);
+    }, []);
+    const stop = (0, react_1.useCallback)(() => {
+        abortRef.current?.abort();
+        abortRef.current = null;
+        setStatus((prev) => (prev === 'streaming' || prev === 'submitted' ? 'ready' : prev));
+    }, []);
+    const sendMessage = (0, react_1.useCallback)(async ({ text }) => {
+        const controller = new AbortController();
+        abortRef.current = controller;
+        setError(null);
+        setStatus('submitted');
+        statusLabelRef.current = null;
+        const userMessage = {
+            id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            role: 'user',
+            parts: [{ type: 'text', text }],
+            createdAt: new Date(),
+        };
+        const assistantId = `assistant-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const assistantPlaceholder = emptyAssistantMessage(assistantId);
+        // Compute the request payload from the synchronous mirror so we
+        // don't depend on React having committed the state update yet.
+        const previousMessages = messagesRef.current;
+        const historyForRequest = [...previousMessages, userMessage];
+        const nextMessages = [
+            ...previousMessages,
+            userMessage,
+            assistantPlaceholder,
+        ];
+        messagesRef.current = nextMessages;
+        setMessagesState(nextMessages);
+        const updateAssistant = (updater) => {
+            setMessagesState((prev) => {
+                const idx = prev.findIndex((m) => m.id === assistantId);
+                if (idx === -1)
+                    return prev;
+                const next = [...prev];
+                next[idx] = updater(prev[idx]);
+                return next;
+            });
+        };
+        try {
+            const res = await fetch(endpoint, {
+                method: 'POST',
+                signal: controller.signal,
+                credentials,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'text/event-stream',
+                    ...resolveHeaders(headersRef.current),
+                },
+                body: JSON.stringify({
+                    messages: toWireMessages(historyForRequest),
+                    ...(threadIdRef.current ? { threadId: threadIdRef.current } : {}),
+                    ...resolveBodyExtras(bodyExtrasRef.current),
+                }),
+            });
+            if (!res.ok || !res.body) {
+                throw new Error(`LangGraph transport: HTTP ${res.status}${res.statusText ? ` ${res.statusText}` : ''}`);
+            }
+            setStatus('streaming');
+            let sawDone = false;
+            for await (const evt of parseSseStream(res.body)) {
+                switch (evt.event) {
+                    case 'message': {
+                        const data = JSON.parse(evt.data);
+                        if (typeof data.content === 'string' && data.content.length > 0) {
+                            updateAssistant((m) => appendTextDelta(m, data.content));
+                        }
+                        break;
+                    }
+                    case 'updates': {
+                        const data = JSON.parse(evt.data);
+                        const label = renderUpdateRef.current?.(data.node, data.update ?? {});
+                        if (label) {
+                            statusLabelRef.current = label;
+                            emitData({
+                                type: 'data-langgraph-update',
+                                data: { node: data.node, update: data.update, label },
+                            });
+                        }
+                        break;
+                    }
+                    case 'custom': {
+                        const data = JSON.parse(evt.data);
+                        const forwarded = onCustomEventRef.current?.(data);
+                        if (forwarded) {
+                            emitData(forwarded);
+                        }
+                        break;
+                    }
+                    case 'tool_call': {
+                        const data = JSON.parse(evt.data);
+                        updateAssistant((m) => upsertToolInvocation(m, data));
+                        break;
+                    }
+                    case 'tool_result': {
+                        const data = JSON.parse(evt.data);
+                        updateAssistant((m) => applyToolResult(m, data));
+                        break;
+                    }
+                    case 'error': {
+                        const data = JSON.parse(evt.data);
+                        throw new Error(data.message || 'LangGraph stream error');
+                    }
+                    case 'done': {
+                        sawDone = true;
+                        break;
+                    }
+                    default:
+                        break;
+                }
+                if (sawDone)
+                    break;
+            }
+            if (!sawDone) {
+                throw new Error('LangGraph transport: stream closed without `done` event');
+            }
+            setStatus('ready');
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                setStatus('ready');
+                return;
+            }
+            setError(err);
+            setStatus('error');
+        }
+        finally {
+            if (abortRef.current === controller)
+                abortRef.current = null;
+        }
+    }, [endpoint, credentials, threadId, emitData]);
+    const addToolApprovalResponse = (0, react_1.useCallback)(async (_response) => {
+        // LangGraph's approval story is consumer-driven: the backend decides
+        // how to resume from an interrupted graph. No-op here.
+    }, []);
+    return (0, react_1.useMemo)(() => ({
+        messages,
+        status,
+        error,
+        sendMessage,
+        stop,
+        setMessages,
+        addToolApprovalResponse,
+        subscribeToData,
+    }), [messages, status, error, sendMessage, stop, setMessages, addToolApprovalResponse, subscribeToData]);
+}

package/dist/cjs/react/transports/vercel/index.d.ts

@@ -0,0 +1,2 @@
+export { useVercelAiChatTransport, useVercelAiChatTransport as useVercel, type UseVercelAiChatTransportOptions, } from '../vercel.js';
+export { VercelAiChat, type VercelAiChatProps } from './vercel-ai-chat.js';

package/dist/cjs/react/transports/vercel/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VercelAiChat = exports.useVercel = exports.useVercelAiChatTransport = void 0;
+var vercel_js_1 = require("../vercel.js");
+Object.defineProperty(exports, "useVercelAiChatTransport", { enumerable: true, get: function () { return vercel_js_1.useVercelAiChatTransport; } });
+Object.defineProperty(exports, "useVercel", { enumerable: true, get: function () { return vercel_js_1.useVercelAiChatTransport; } });
+var vercel_ai_chat_js_1 = require("./vercel-ai-chat.js");
+Object.defineProperty(exports, "VercelAiChat", { enumerable: true, get: function () { return vercel_ai_chat_js_1.VercelAiChat; } });

package/dist/cjs/react/transports/vercel/vercel-ai-chat.d.ts

@@ -0,0 +1,49 @@
+import { type ReactNode } from 'react';
+import { type FloatingChatUIProps } from '../../components/floating-chat-ui.js';
+import type { AiChatProviderConfig, SessionConfig } from '../../types.js';
+export interface VercelAiChatProps extends AiChatProviderConfig, FloatingChatUIProps {
+    /** Chat API endpoint URL (e.g. `/api/chat`). */
+    endpoint: string;
+    /** Static headers or a function that returns headers per request. */
+    headers?: Record<string, string> | (() => Record<string, string>);
+    /** Auto-resume generation after all pending approvals are provided. Default: true. */
+    autoResumeOnApproval?: boolean;
+    /** Extra fields merged into every outgoing request body. */
+    bodyExtras?: Record<string, unknown> | (() => Record<string, unknown>);
+    /**
+     * Multi-session hooks. When provided, the drop-in renders a session
+     * switcher in the header and sends the active session id as `sessionId`
+     * in the request body (merged with `bodyExtras`). Your backend owns
+     * how to interpret it — the Vercel AI SDK itself has no thread concept.
+     */
+    sessions?: SessionConfig;
+    /**
+     * Replace the default floating UI with custom children. Useful when you
+     * want to compose `<MessageList />`, `<ChatInput />`, etc. yourself or
+     * render an inline `<AiChatPanel />` instead of a floating window.
+     */
+    children?: ReactNode;
+}
+/**
+ * Drop-in Vercel AI SDK chat widget. Bundles transport, provider, and a
+ * floating (trigger button + draggable window) chat UI into one component.
+ *
+ * ```tsx
+ * 'use client';
+ * import { VercelAiChat } from 'glirastes/react/vercel';
+ *
+ * export default function Layout({ children }) {
+ *   return (
+ *     <>
+ *       {children}
+ *       <VercelAiChat endpoint="/api/chat" sessions={mySessionBridge} />
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * All `AiChatProviderConfig` fields (session, mentions, classNames, etc.)
+ * and `FloatingChatUIProps` (title, defaultOpen, width, height, draggable,
+ * resizable, shortcut, showClearButton) are accepted as top-level props.
+ */
+export declare function VercelAiChat({ endpoint, headers, autoResumeOnApproval, bodyExtras, sessions, title, defaultOpen, draggable, resizable, size, hideTriggerWhenOpen, shortcut, showClearButton, confirmClear, showSessionSwitcher, headerActions, triggerIcon, showMic, children, ...providerConfig }: VercelAiChatProps): import("react/jsx-runtime").JSX.Element;

package/dist/cjs/react/transports/vercel/vercel-ai-chat.js

@@ -0,0 +1,81 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VercelAiChat = VercelAiChat;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ai_chat_provider_js_1 = require("../../provider/ai-chat-provider.js");
+const floating_chat_ui_js_1 = require("../../components/floating-chat-ui.js");
+const vercel_js_1 = require("../vercel.js");
+/**
+ * Drop-in Vercel AI SDK chat widget. Bundles transport, provider, and a
+ * floating (trigger button + draggable window) chat UI into one component.
+ *
+ * ```tsx
+ * 'use client';
+ * import { VercelAiChat } from 'glirastes/react/vercel';
+ *
+ * export default function Layout({ children }) {
+ *   return (
+ *     <>
+ *       {children}
+ *       <VercelAiChat endpoint="/api/chat" sessions={mySessionBridge} />
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * All `AiChatProviderConfig` fields (session, mentions, classNames, etc.)
+ * and `FloatingChatUIProps` (title, defaultOpen, width, height, draggable,
+ * resizable, shortcut, showClearButton) are accepted as top-level props.
+ */
+function VercelAiChat({ endpoint, headers, autoResumeOnApproval, bodyExtras, sessions, title, defaultOpen, draggable, resizable, size, hideTriggerWhenOpen, shortcut, showClearButton, confirmClear, showSessionSwitcher, headerActions, triggerIcon, showMic, children, ...providerConfig }) {
+    const [activeId, setActiveId] = (0, react_1.useState)(() => {
+        if (sessions?.activeId)
+            return sessions.activeId;
+        if (sessions?.defaultActiveId)
+            return sessions.defaultActiveId;
+        return 'default';
+    });
+    (0, react_1.useEffect)(() => {
+        if (sessions?.activeId && sessions.activeId !== activeId) {
+            setActiveId(sessions.activeId);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [sessions?.activeId]);
+    // When sessions are enabled, merge `sessionId` into the outgoing body
+    // on every request — the backend is responsible for routing.
+    const mergedBodyExtras = (0, react_1.useMemo)(() => {
+        if (!sessions)
+            return bodyExtras;
+        return () => {
+            const base = typeof bodyExtras === 'function'
+                ? bodyExtras()
+                : bodyExtras ?? {};
+            return { ...base, sessionId: activeId };
+        };
+    }, [sessions, bodyExtras, activeId]);
+    const transport = (0, vercel_js_1.useVercelAiChatTransport)({
+        endpoint,
+        headers,
+        autoResumeOnApproval,
+        bodyExtras: mergedBodyExtras,
+    });
+    const effectiveSession = (0, react_1.useMemo)(() => {
+        if (!sessions)
+            return providerConfig.session;
+        // Strip any consumer-supplied `activeId` and use `defaultActiveId`
+        // (seed-only) so the provider stays uncontrolled. Auto-select +
+        // switchSession both flow back through `onActiveIdChange`.
+        const { activeId: _consumerActiveId, ...rest } = sessions;
+        return {
+            ...rest,
+            defaultActiveId: activeId,
+            onActiveIdChange: (id) => {
+                setActiveId(id);
+                sessions.onActiveIdChange?.(id);
+            },
+        };
+    }, [sessions, activeId, providerConfig.session]);
+    return ((0, jsx_runtime_1.jsx)(ai_chat_provider_js_1.AiChatProvider, { transport: transport, ...providerConfig, session: effectiveSession, children: children ?? ((0, jsx_runtime_1.jsx)(floating_chat_ui_js_1.FloatingChatUI, { title: title, defaultOpen: defaultOpen, draggable: draggable, resizable: resizable, size: size, hideTriggerWhenOpen: hideTriggerWhenOpen, shortcut: shortcut, showClearButton: showClearButton, confirmClear: confirmClear, showSessionSwitcher: showSessionSwitcher, headerActions: headerActions, triggerIcon: triggerIcon, showMic: showMic })) }));
+}