@windmill-labs/chat-sdk 0.0.0-stage → 1.831.0

package/dist/follow.d.ts

@@ -0,0 +1,33 @@
+import { type WindmillChatApi } from './api';
+import { type AgentStreamEvent } from './stream';
+export type FollowEvent = 
+/** Agent events decoded from the job's result stream; empty when a chunk ended mid-line. */
+{
+    type: 'stream';
+    events: AgentStreamEvent[];
+}
+/** `streamLost`: the result was polled after the stream failed, so what streamed may stop short. */
+ | {
+    type: 'completed';
+    result: unknown;
+    streamLost?: boolean;
+};
+/**
+ * Follows a job to completion across the server's stream timeouts: every
+ * connection resumes from the last `stream_offset`, so no delta is repeated and
+ * the flow is never re-run. `onOffset` reports each offset, and its loss, so a
+ * caller can resume later from another connection (see the AI SDK transport).
+ *
+ * The offset indexes the stream of one sub-job (`flow_stream_job_id`, the flow's
+ * streaming step). A retried step gets a new one, so when the id changes the
+ * offset is dropped and the connection reopened from that sub-job's start.
+ *
+ * A connection that fails (a proxy restarting, the network dropping) is retried with
+ * backoff. The run is still going, so after a few failures in a row the job's result is
+ * polled instead: the rest of the answer is not streamed, but the turn still ends.
+ */
+export declare function followJob(api: WindmillChatApi, jobId: string, options?: {
+    signal?: AbortSignal;
+    streamOffset?: number;
+    onOffset?: (offset: number | undefined) => void;
+}): AsyncGenerator<FollowEvent>;

package/dist/history.d.ts

@@ -0,0 +1,17 @@
+import type { ChatMessage, Conversation, StorageLike } from './types';
+export interface LocalHistory {
+    listConversations(): Conversation[];
+    getMessages(conversationId: string): ChatMessage[];
+    upsertConversation(conversation: Conversation): void;
+    /** Changes a stored conversation's title in place; unlike `upsertConversation`, its position is kept. */
+    renameConversation(conversationId: string, title: string): void;
+    saveMessages(conversationId: string, messages: ChatMessage[]): void;
+    deleteConversation(conversationId: string): void;
+}
+/**
+ * Conversation history in the browser, for a credential shared by every visitor
+ * (server history would show them each other's chats). One key per flow, and per
+ * `storageKey` when the caller sets one; every operation re-reads the store so
+ * several tabs stay consistent.
+ */
+export declare function createLocalHistory(storage: StorageLike | undefined, key: string): LocalHistory;

package/dist/index.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_follow = require("./follow-Dug-Afeu.cjs");
+const require_chat = require("./chat-u1tspn7Q.cjs");
+exports.CHAT_UPLOADS_PREFIX = require_chat.CHAT_UPLOADS_PREFIX;
+exports.TurnRunningError = require_follow.TurnRunningError;
+exports.WindmillApiError = require_follow.WindmillApiError;
+exports.WindmillChatApi = require_follow.WindmillChatApi;
+exports.conversationIdFor = require_follow.conversationIdFor;
+exports.createChat = require_chat.createChat;
+exports.createStreamEventParser = require_follow.createStreamEventParser;
+exports.detectRawApp = require_chat.detectRawApp;
+exports.extractChatAnswer = require_follow.extractChatAnswer;
+exports.followJob = require_follow.followJob;
+exports.parseStreamEvents = require_follow.parseStreamEvents;
+exports.readServerSentEvents = require_follow.readServerSentEvents;
+exports.storedAttachmentName = require_chat.storedAttachmentName;
+exports.turnRunningError = require_follow.turnRunningError;
+exports.uploadAttachments = require_chat.uploadAttachments;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createChat } from './chat';
+export { detectRawApp, type RawAppContext } from './config';
+export { WindmillChatApi, WindmillApiError, TurnRunningError, turnRunningError, readServerSentEvents, type RunningTurn, type WindmillChatApiOptions, type ConversationKind, type FlowConversation, type FlowConversationMessage, type JobUpdateEvent, type CompletedJobResult } from './api';
+export { parseStreamEvents, createStreamEventParser, type AgentStreamEvent } from './stream';
+export { followJob, type FollowEvent } from './follow';
+export { extractChatAnswer, conversationIdFor } from './utils';
+export { storedAttachmentName, uploadAttachments, CHAT_UPLOADS_PREFIX, type UploadedAttachment } from './attachments';
+export type { AttachmentsInput, AttachmentUpload, Chat, ChatAttachment, ChatMessage, ChatOptions, ChatRole, ChatState, ChatStatus, Conversation, FetchLike, HistoryMode, SendMessageOptions, StorageLike, TokenSource, ToolInvocation } from './types';

package/dist/index.js

@@ -0,0 +1,3 @@
+import { _ as WindmillApiError, b as turnRunningError, g as TurnRunningError, h as parseStreamEvents, m as createStreamEventParser, o as extractChatAnswer, r as conversationIdFor, t as followJob, v as WindmillChatApi, y as readServerSentEvents } from "./follow-DXfmfPfr.js";
+import { a as detectRawApp, i as uploadAttachments, n as CHAT_UPLOADS_PREFIX, r as storedAttachmentName, t as createChat } from "./chat-DgINfcUU.js";
+export { CHAT_UPLOADS_PREFIX, TurnRunningError, WindmillApiError, WindmillChatApi, conversationIdFor, createChat, createStreamEventParser, detectRawApp, extractChatAnswer, followJob, parseStreamEvents, readServerSentEvents, storedAttachmentName, turnRunningError, uploadAttachments };

package/dist/react.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chat = require("./chat-u1tspn7Q.cjs");
+let react = require("react");
+//#region src/react.ts
+/**
+* A chat on a chat-mode flow. The chat is created once per `flowPath`, `baseUrl`,
+* `workspace`, `history`, `storageKey`, credential and presence of `run`, and
+* destroyed on unmount. A credential change is a new user, whose chat must not
+* carry the previous one's state: a different token string, or a switch between no
+* token, a token string and a token function, all recreate it. A token function is
+* read through a ref on every call, so a new closure per render changes what the
+* next call runs and nothing else; pass a `storageKey` per user when local history
+* must not be shared. `run`, the callbacks and `inputs` are read the same way: the
+* latest render's values go with the next message.
+*/
+function useWindmillChat(options) {
+	const latest = (0, react.useRef)(options);
+	latest.current = options;
+	const credential = typeof options.token === "function" ? "fn" : typeof options.token === "string" ? `str:${options.token}` : "none";
+	const customRun = options.run !== void 0;
+	const chat = (0, react.useMemo)(() => require_chat.createChat({
+		...options,
+		inputs: void 0,
+		token: typeof options.token === "function" ? () => {
+			const token = latest.current.token;
+			return typeof token === "function" ? token() : token ?? "";
+		} : options.token,
+		run: customRun ? (args, turn) => (latest.current.run ?? options.run)(args, turn) : void 0,
+		onFinish: (turn) => latest.current.onFinish?.(turn),
+		onError: (error, turn) => latest.current.onError?.(error, turn)
+	}), [
+		options.flowPath,
+		options.baseUrl,
+		options.workspace,
+		options.history,
+		options.storageKey,
+		credential,
+		customRun
+	]);
+	(0, react.useEffect)(() => () => chat.destroy(), [chat]);
+	const state = (0, react.useSyncExternalStore)(chat.subscribe, chat.getState, chat.getState);
+	return (0, react.useMemo)(() => ({
+		...state,
+		chat,
+		sendMessage: (text, options) => chat.sendMessage(text, {
+			...options,
+			inputs: {
+				...latest.current.inputs,
+				...options?.inputs
+			}
+		}),
+		resumeTurn: chat.resumeTurn,
+		stop: chat.stop,
+		newConversation: chat.newConversation,
+		selectConversation: chat.selectConversation,
+		loadConversations: chat.loadConversations,
+		deleteConversation: chat.deleteConversation,
+		renameConversation: chat.renameConversation,
+		loadOlderMessages: chat.loadOlderMessages,
+		refreshMessages: chat.refreshMessages
+	}), [state, chat]);
+}
+//#endregion
+exports.useWindmillChat = useWindmillChat;

package/dist/react.d.ts

@@ -0,0 +1,16 @@
+import type { Chat, ChatOptions, ChatState } from './types';
+export type UseWindmillChat = ChatState & Pick<Chat, 'sendMessage' | 'resumeTurn' | 'stop' | 'newConversation' | 'selectConversation' | 'loadConversations' | 'deleteConversation' | 'renameConversation' | 'loadOlderMessages' | 'refreshMessages'> & {
+    chat: Chat;
+};
+/**
+ * A chat on a chat-mode flow. The chat is created once per `flowPath`, `baseUrl`,
+ * `workspace`, `history`, `storageKey`, credential and presence of `run`, and
+ * destroyed on unmount. A credential change is a new user, whose chat must not
+ * carry the previous one's state: a different token string, or a switch between no
+ * token, a token string and a token function, all recreate it. A token function is
+ * read through a ref on every call, so a new closure per render changes what the
+ * next call runs and nothing else; pass a `storageKey` per user when local history
+ * must not be shared. `run`, the callbacks and `inputs` are read the same way: the
+ * latest render's values go with the next message.
+ */
+export declare function useWindmillChat(options: ChatOptions): UseWindmillChat;

package/dist/react.js

@@ -0,0 +1,63 @@
+import { t as createChat } from "./chat-DgINfcUU.js";
+import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
+//#region src/react.ts
+/**
+* A chat on a chat-mode flow. The chat is created once per `flowPath`, `baseUrl`,
+* `workspace`, `history`, `storageKey`, credential and presence of `run`, and
+* destroyed on unmount. A credential change is a new user, whose chat must not
+* carry the previous one's state: a different token string, or a switch between no
+* token, a token string and a token function, all recreate it. A token function is
+* read through a ref on every call, so a new closure per render changes what the
+* next call runs and nothing else; pass a `storageKey` per user when local history
+* must not be shared. `run`, the callbacks and `inputs` are read the same way: the
+* latest render's values go with the next message.
+*/
+function useWindmillChat(options) {
+	const latest = useRef(options);
+	latest.current = options;
+	const credential = typeof options.token === "function" ? "fn" : typeof options.token === "string" ? `str:${options.token}` : "none";
+	const customRun = options.run !== void 0;
+	const chat = useMemo(() => createChat({
+		...options,
+		inputs: void 0,
+		token: typeof options.token === "function" ? () => {
+			const token = latest.current.token;
+			return typeof token === "function" ? token() : token ?? "";
+		} : options.token,
+		run: customRun ? (args, turn) => (latest.current.run ?? options.run)(args, turn) : void 0,
+		onFinish: (turn) => latest.current.onFinish?.(turn),
+		onError: (error, turn) => latest.current.onError?.(error, turn)
+	}), [
+		options.flowPath,
+		options.baseUrl,
+		options.workspace,
+		options.history,
+		options.storageKey,
+		credential,
+		customRun
+	]);
+	useEffect(() => () => chat.destroy(), [chat]);
+	const state = useSyncExternalStore(chat.subscribe, chat.getState, chat.getState);
+	return useMemo(() => ({
+		...state,
+		chat,
+		sendMessage: (text, options) => chat.sendMessage(text, {
+			...options,
+			inputs: {
+				...latest.current.inputs,
+				...options?.inputs
+			}
+		}),
+		resumeTurn: chat.resumeTurn,
+		stop: chat.stop,
+		newConversation: chat.newConversation,
+		selectConversation: chat.selectConversation,
+		loadConversations: chat.loadConversations,
+		deleteConversation: chat.deleteConversation,
+		renameConversation: chat.renameConversation,
+		loadOlderMessages: chat.loadOlderMessages,
+		refreshMessages: chat.refreshMessages
+	}), [state, chat]);
+}
+//#endregion
+export { useWindmillChat };

package/dist/stream.d.ts

@@ -0,0 +1,38 @@
+/** The events an AI agent step streams, one JSON object per line of the job's result stream. */
+export type AgentStreamEvent = {
+    type: 'token_delta';
+    content: string;
+} | {
+    type: 'reasoning_token_delta';
+    content: string;
+} | {
+    type: 'tool_call';
+    call_id: string;
+    function_name: string;
+} | {
+    type: 'tool_call_arguments';
+    call_id: string;
+    function_name: string;
+    arguments: string;
+} | {
+    type: 'tool_execution';
+    call_id: string;
+    function_name: string;
+} | {
+    type: 'tool_result';
+    call_id: string;
+    function_name: string;
+    result: string;
+    success: boolean;
+};
+/**
+ * Incremental parser for the `new_result_stream` chunks of a job update. A chunk is
+ * not guaranteed to end on a line boundary, so an incomplete last line waits for the
+ * next `push` (or `flush` once the job completes).
+ */
+export declare function createStreamEventParser(): {
+    push(chunk: string): AgentStreamEvent[];
+    flush(): AgentStreamEvent[];
+};
+/** Parses complete NDJSON lines; lines that aren't agent events are skipped. */
+export declare function parseStreamEvents(ndjson: string): AgentStreamEvent[];

package/dist/types.d.ts

@@ -0,0 +1,208 @@
+import type { RunningTurn } from './api';
+export type ChatRole = 'user' | 'assistant' | 'tool' | 'system';
+/**
+ * - `idle`: ready for a message
+ * - `submitted`: the message was sent, no answer has started streaming yet
+ * - `streaming`: the answer is arriving
+ * - `error`: the last turn failed; `error` holds why. Sending again is allowed.
+ */
+export type ChatStatus = 'idle' | 'submitted' | 'streaming' | 'error';
+/**
+ * Where conversation history lives.
+ * - `server`: Windmill's conversation store. Each Windmill user only sees their own
+ *   conversations, so use it with the viewer's own session or a per-user token.
+ * - `local`: the browser's storage. Right for a token shared by every visitor.
+ * - `none`: nothing is kept beyond the current page.
+ */
+export type HistoryMode = 'server' | 'local' | 'none';
+export interface ToolInvocation {
+    callId?: string;
+    name: string;
+    /** The arguments the model passed, as a JSON string. */
+    arguments?: string;
+    result?: string;
+    status: 'running' | 'success' | 'error';
+}
+export interface ChatAttachment {
+    input: string;
+    s3: string;
+    storage?: string;
+    filename?: string;
+}
+export interface ChatMessage {
+    id: string;
+    role: ChatRole;
+    content: string;
+    /** The model's reasoning summary, when the provider streams one. */
+    reasoning?: string;
+    /** The call on a `tool` message, from the live stream or its stored row; `callId` is only known from the stream. */
+    tool?: ToolInvocation;
+    success: boolean;
+    createdAt: string;
+    jobId?: string;
+    /** The flow step that produced the message. */
+    stepName?: string;
+    /** The files a user message carried, as object-storage references. */
+    attachments?: ChatAttachment[];
+    /** True while the message is optimistic or still streaming. */
+    pending: boolean;
+    /** Id of the persisted row once the server has it; `id` itself never changes, so list keys stay stable. */
+    serverId?: string;
+    /** The server's cursor for a persisted message; unset for one created on the client. */
+    seq?: number;
+}
+export interface Conversation {
+    id: string;
+    title: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Started from the flow editor's test panel rather than a deployed run. Known once the
+     * server has listed the conversation; unset for one only this client has seen.
+     */
+    isTest?: boolean;
+    /**
+     * The turn the conversation was still answering when the server listed it: started in
+     * another tab, or before this chat was created. Pass it to `resumeTurn` to follow it.
+     */
+    runningTurn?: RunningTurn;
+}
+export interface ChatState {
+    conversationId: string | undefined;
+    messages: ChatMessage[];
+    status: ChatStatus;
+    error: Error | undefined;
+    conversations: Conversation[];
+    /** Where history is read from. Starts as configured; drops from `server` to `local` when the credential cannot read conversations. */
+    history: HistoryMode;
+    loadingMessages: boolean;
+    hasMoreMessages: boolean;
+}
+export type TokenSource = string | (() => string | Promise<string>);
+export type StorageLike = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface ChatOptions {
+    /** Path of a deployed flow with chat mode enabled, e.g. `f/support/assistant`. */
+    flowPath: string;
+    /** Windmill origin, e.g. `https://app.windmill.dev`. Detected inside a raw app. */
+    baseUrl?: string;
+    /** Detected inside a raw app. */
+    workspace?: string;
+    /**
+     * A Windmill token, or a function returning one (called before every request, so it
+     * can fetch a short-lived token from your backend). Omit it to use the viewer's
+     * session: the cookie on the Windmill origin, or a sandboxed raw app's SDK token.
+     */
+    token?: TokenSource;
+    /** Defaults to `server` with the viewer's session and `local` with an explicit token. */
+    history?: HistoryMode;
+    /** Extra flow inputs sent with every message, next to `user_message`. */
+    inputs?: Record<string, unknown>;
+    fetch?: FetchLike;
+    /** Backing store for `local` history. Defaults to `localStorage`. */
+    storage?: StorageLike;
+    /**
+     * Namespace for `local` history, e.g. the signed-in user's id. Local history is
+     * per browser, per flow; without this, users sharing a browser share it.
+     */
+    storageKey?: string;
+    /** Messages fetched per page of server history. */
+    pageSize?: number;
+    /**
+     * How often, in milliseconds, the server polls a running turn for the stream
+     * (Enterprise; 50 at the fastest, other servers ignore it). Unset, the server
+     * relaxes from 100 ms to 3 s over a long turn.
+     */
+    pollDelayMs?: number;
+    /**
+     * Runs the flow for a turn and returns the job id, instead of the deployed flow at
+     * `flowPath`. `args` carries `user_message` and the extra inputs; the run must set
+     * `memory_id` to the conversation id for the conversation and its memory to line up.
+     * Windmill's own editor uses this to chat with an undeployed flow through a preview run.
+     */
+    run?: (args: Record<string, unknown>, turn: {
+        conversationId: string;
+        signal: AbortSignal;
+    }) => Promise<string>;
+    /** Called once a turn has its answer (a failed flow included: its error is the answer). */
+    onFinish?: (turn: {
+        conversationId: string;
+        jobId?: string;
+        messages: ChatMessage[];
+    }) => void;
+    /** Called when a turn could not run or be followed; `state.error` holds the same error. */
+    onError?: (error: Error, turn: {
+        conversationId: string;
+        jobId?: string;
+    }) => void;
+}
+/** A file sent with a message. It is uploaded to the workspace's object storage before the run starts. */
+export interface AttachmentUpload {
+    /** Kept as the last segment of the stored key, its extension corrected to the media type for PNG, JPEG and PDF. */
+    name: string;
+    /** The bytes: a Blob, or a `data:` URL of them. */
+    data: Blob | string;
+    /** The file's media type. Defaults to the Blob's own type, or the data URL's. */
+    mediaType?: string;
+}
+/** The flow input the uploaded attachments are handed to: an `s3object` (`multiple: false`) or an `s3object[]`. */
+export interface AttachmentsInput {
+    name: string;
+    multiple: boolean;
+}
+export interface SendMessageOptions {
+    /** Extra flow inputs for this message, on top of `ChatOptions.inputs`. */
+    inputs?: Record<string, unknown>;
+    /**
+     * Files to upload and hand to the flow as `{ s3, filename }` objects in `attachmentsInput`,
+     * the way an AI agent step reads `user_attachments`. A failed upload rejects `sendMessage`
+     * and the run never starts; `stop()` during the upload does the same with an `AbortError`.
+     */
+    attachments?: AttachmentUpload[];
+    /** Required with `attachments`, which also need message text. With `multiple: false`, more than one attachment is refused before anything uploads. */
+    attachmentsInput?: AttachmentsInput;
+}
+export interface Chat {
+    getState(): ChatState;
+    /** Calls `listener` now and on every change; returns the unsubscribe function (Svelte store contract). */
+    subscribe(listener: (state: ChatState) => void): () => void;
+    /**
+     * Sends a message in the current conversation, starting one when there is none. Resolves
+     * when the answer is complete. Rejects when the message could not be sent at all — a turn
+     * already running, an attachment that failed to upload — without touching the transcript.
+     * A conversation still answering a message sent elsewhere rejects with `TurnRunningError`:
+     * follow that turn with `resumeTurn`, then send again.
+     */
+    sendMessage(text: string, options?: SendMessageOptions): Promise<void>;
+    /**
+     * Follows a turn of the current conversation that this chat did not start, as named by
+     * `Conversation.runningTurn` or a `TurnRunningError`: its answer streams into `messages`
+     * from the start and the turn finishes like one sent here. Server history only; resolves
+     * when the answer is complete, at once when a turn is already being followed.
+     */
+    resumeTurn(turn: RunningTurn): Promise<void>;
+    /** Stops following the answer and asks Windmill to cancel the run. */
+    stop(): Promise<void>;
+    newConversation(): void;
+    selectConversation(conversationId: string): Promise<void>;
+    /**
+     * `kind` narrows server history to the flow editor's test chats, the deployed flow's
+     * own (the server's default), or both. Local history has no test chats and ignores it.
+     */
+    loadConversations(options?: {
+        page?: number;
+        perPage?: number;
+        kind?: 'test' | 'deployed' | 'all';
+    }): Promise<Conversation[]>;
+    deleteConversation(conversationId: string): Promise<void>;
+    /** Sets a conversation's title. The list keeps its order: only a turn moves a conversation. */
+    renameConversation(conversationId: string, title: string): Promise<void>;
+    loadOlderMessages(): Promise<void>;
+    /**
+     * Reads what the current conversation gained since its newest message held here, such
+     * as a turn another tab ran. Server history only; does nothing while a turn is followed.
+     */
+    refreshMessages(): Promise<void>;
+    /** Stops background work (stream, polling) and writes local history out. The chat stays usable. */
+    destroy(): void;
+}

package/dist/utils.d.ts

@@ -0,0 +1,33 @@
+export declare function randomId(): string;
+export declare function isUuid(value: string): boolean;
+/**
+ * The Windmill conversation id for an arbitrary chat id. A UUID is used as is;
+ * anything else (an AI SDK chat id, for instance) maps to the same UUID every time,
+ * so a page can reopen its conversation without storing a second id. Hashed in plain
+ * JS: `crypto.subtle` only exists in secure contexts, and the mapping must not depend
+ * on the origin's scheme.
+ */
+export declare function conversationIdFor(chatId: string): string;
+export declare function parseJsonOr(text: string | undefined): unknown;
+export declare function now(): string;
+/** Same rule as the server: the first message, cut to 25 characters. */
+export declare function conversationTitle(firstMessage: string): string;
+/** The server's bound on a typed title: 252 characters plus an ellipsis fits its 255-char column. */
+export declare function truncateTitle(title: string): string;
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function abortError(): Error;
+export declare function isAbortError(e: unknown): boolean;
+/**
+ * The text a chat shows for a flow result, following what Windmill persists as the
+ * assistant message when the last step is not an AI agent: `windmill_chat_answer`
+ * when the result carries one (null means no message), an agent result's `output`,
+ * a string as is, anything else as JSON.
+ */
+export declare function extractChatAnswer(result: unknown): string | undefined;
+/** A completed job whose result is Windmill's error envelope. */
+export declare function isErrorResult(result: unknown): result is {
+    error: Record<string, unknown>;
+};
+export declare function errorResultMessage(result: {
+    error: Record<string, unknown>;
+}): string;

package/package.json

@@ -1,6 +1,108 @@
 {
   "name": "@windmill-labs/chat-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Build chat interfaces on Windmill flows deployed in chat mode, from any frontend or raw app",
+  "version": "1.831.0",
+  "author": "Ruben Fiszel",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/windmill-labs/windmill/tree/main/chat-sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/windmill-labs/windmill.git",
+    "directory": "chat-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/windmill-labs/windmill/issues"
+  },
+  "keywords": [
+    "windmill",
+    "chat",
+    "ai",
+    "agent",
+    "react"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./react": {
+      "import": {
+        "types": "./dist/react.d.ts",
+        "default": "./dist/react.js"
+      },
+      "require": {
+        "types": "./dist/react.d.ts",
+        "default": "./dist/react.cjs"
+      }
+    },
+    "./ai-sdk": {
+      "import": {
+        "types": "./dist/ai-sdk.d.ts",
+        "default": "./dist/ai-sdk.js"
+      },
+      "require": {
+        "types": "./dist/ai-sdk.d.ts",
+        "default": "./dist/ai-sdk.cjs"
+      }
+    },
+    "./assistant-ui": {
+      "import": {
+        "types": "./dist/assistant-ui.d.ts",
+        "default": "./dist/assistant-ui.js"
+      },
+      "require": {
+        "types": "./dist/assistant-ui.d.ts",
+        "default": "./dist/assistant-ui.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsdown && tsc -p tsconfig.build.json",
+    "check": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "peerDependencies": {
+    "@assistant-ui/react": ">=0.15",
+    "ai": ">=5",
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@assistant-ui/react": {
+      "optional": true
+    },
+    "ai": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ai-sdk/react": "^4.0.102",
+    "@assistant-ui/react": "^0.15.19",
+    "@happy-dom/global-registrator": "^20.14.5",
+    "@types/bun": "^1.3.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.3.0",
+    "ai": "^7.0.99",
+    "react": "^19.0.0",
+    "react-dom": "^19.3.0",
+    "tsdown": "^0.12.9",
+    "typescript": "^5.4.5"
+  }
+}