@tanstack/ai-react 0.22.4 → 0.23.0

package/dist/esm/chat-ui/chat.js

@@ -0,0 +1,57 @@
+import { useChat } from "../use-chat.js";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/chat-ui/chat.tsx
+/**
+* Chat context - provides chat state to all child components
+*/
+var ChatContext = createContext(null);
+/**
+* Hook to access chat context
+* @throws Error if used outside of Chat component
+*/
+/** @deprecated Use `createChatUI().useChatContext()` instead. Deprecated in 0.9.0. Removed in 1.0.0. */
+function useChatContext() {
+	const context = useContext(ChatContext);
+	if (!context) throw new Error("Chat components must be wrapped in <Chat>. Make sure you're using Chat.Messages, Chat.Input, etc. inside a <Chat> component.");
+	return context;
+}
+/**
+* @deprecated Since 0.9.0. Use `createChatHook()` from `@tanstack/ai-react/ui` instead.
+* See https://tanstack.com/ai/latest/docs/ui/react
+* Removed in 1.0.0.
+*
+* Root Chat component - provides context for all chat subcomponents
+*
+* @example
+* ```tsx
+* <Chat connection={fetchServerSentEvents("/api/chat")}>
+*   <Chat.Messages />
+*   <Chat.Input />
+* </Chat>
+* ```
+*/
+function Chat({ children, className, connection, initialMessages, id, body, onResponse, onChunk, onFinish, onError }) {
+	const chat = useChat({
+		connection,
+		...initialMessages !== void 0 ? { initialMessages } : {},
+		...id !== void 0 ? { id } : {},
+		...body !== void 0 ? { body } : {},
+		...onResponse !== void 0 ? { onResponse } : {},
+		...onChunk !== void 0 ? { onChunk } : {},
+		...onFinish !== void 0 ? { onFinish } : {},
+		...onError !== void 0 ? { onError } : {}
+	});
+	return /* @__PURE__ */ jsx(ChatContext.Provider, {
+		value: chat,
+		children: /* @__PURE__ */ jsx("div", {
+			className,
+			"data-chat-root": true,
+			children
+		})
+	});
+}
+//#endregion
+export { Chat, useChatContext };
+
+//# sourceMappingURL=chat.js.map

package/dist/esm/chat-ui/chat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.js","names":[],"sources":["../../../src/chat-ui/chat.tsx"],"sourcesContent":["import { createContext, useContext } from 'react'\nimport type { ConnectionAdapter } from '@tanstack/ai-client'\nimport { useChat } from '../use-chat'\nimport type { ReactNode } from 'react'\nimport type { UIMessage, UseChatReturn } from '../types'\n\n/**\n * Chat context - provides chat state to all child components\n */\nconst ChatContext = createContext<UseChatReturn | null>(null)\n\n/**\n * Hook to access chat context\n * @throws Error if used outside of Chat component\n */\n/** @deprecated Use `createChatUI().useChatContext()` instead. Deprecated in 0.9.0. Removed in 1.0.0. */\nexport function useChatContext() {\n  const context = useContext(ChatContext)\n  if (!context) {\n    throw new Error(\n      \"Chat components must be wrapped in <Chat>. Make sure you're using Chat.Messages, Chat.Input, etc. inside a <Chat> component.\",\n    )\n  }\n  return context\n}\n\n/** @deprecated Use `createChatUI()` Chat/Provider instead. Deprecated in 0.9.0. Removed in 1.0.0. */\nexport interface ChatProps {\n  /** Child components (Chat.Messages, Chat.Input, etc.) */\n  children: ReactNode\n  /** CSS class name for the root element */\n  className?: string\n  /** Connection adapter for communicating with your API */\n  connection: ConnectionAdapter\n  /** Initial messages to display */\n  initialMessages?: Array<UIMessage>\n  /** Custom message ID generator */\n  id?: string\n  /** Additional body data to send with requests */\n  body?: any\n  /** Callback when a response is received */\n  onResponse?: (response?: Response) => void | Promise<void>\n  /** Callback when each chunk arrives */\n  onChunk?: (chunk: any) => void\n  /** Callback when a message is complete */\n  onFinish?: (message: UIMessage) => void\n  /** Callback when an error occurs */\n  onError?: (error: Error) => void\n  /** Custom tool components registry */\n  tools?: Record<string, React.ComponentType<{ input: any; output?: any }>>\n}\n\n/**\n * @deprecated Since 0.9.0. Use `createChatHook()` from `@tanstack/ai-react/ui` instead.\n * See https://tanstack.com/ai/latest/docs/ui/react\n * Removed in 1.0.0.\n *\n * Root Chat component - provides context for all chat subcomponents\n *\n * @example\n * ```tsx\n * <Chat connection={fetchServerSentEvents(\"/api/chat\")}>\n *   <Chat.Messages />\n *   <Chat.Input />\n * </Chat>\n * ```\n */\nexport function Chat({\n  children,\n  className,\n  connection,\n  initialMessages,\n  id,\n  body,\n  onResponse,\n  onChunk,\n  onFinish,\n  onError,\n}: ChatProps) {\n  const chat = useChat({\n    connection,\n    ...(initialMessages !== undefined ? { initialMessages } : {}),\n    ...(id !== undefined ? { id } : {}),\n    ...(body !== undefined ? { body } : {}),\n    ...(onResponse !== undefined ? { onResponse } : {}),\n    ...(onChunk !== undefined ? { onChunk } : {}),\n    ...(onFinish !== undefined ? { onFinish } : {}),\n    ...(onError !== undefined ? { onError } : {}),\n  })\n\n  return (\n    <ChatContext.Provider value={chat}>\n      <div className={className} data-chat-root>\n        {children}\n      </div>\n    </ChatContext.Provider>\n  )\n}\n"],"mappings":";;;;;;;AASA,IAAM,cAAc,cAAoC,IAAI;;;;;;AAO5D,SAAgB,iBAAiB;CAC/B,MAAM,UAAU,WAAW,WAAW;CACtC,IAAI,CAAC,SACH,MAAM,IAAI,MACR,8HACF;CAEF,OAAO;AACT;;;;;;;;;;;;;;;;AA2CA,SAAgB,KAAK,EACnB,UACA,WACA,YACA,iBACA,IACA,MACA,YACA,SACA,UACA,WACY;CACZ,MAAM,OAAO,QAAQ;EACnB;EACA,GAAI,oBAAoB,KAAA,IAAY,EAAE,gBAAgB,IAAI,CAAC;EAC3D,GAAI,OAAO,KAAA,IAAY,EAAE,GAAG,IAAI,CAAC;EACjC,GAAI,SAAS,KAAA,IAAY,EAAE,KAAK,IAAI,CAAC;EACrC,GAAI,eAAe,KAAA,IAAY,EAAE,WAAW,IAAI,CAAC;EACjD,GAAI,YAAY,KAAA,IAAY,EAAE,QAAQ,IAAI,CAAC;EAC3C,GAAI,aAAa,KAAA,IAAY,EAAE,SAAS,IAAI,CAAC;EAC7C,GAAI,YAAY,KAAA,IAAY,EAAE,QAAQ,IAAI,CAAC;CAC7C,CAAC;CAED,OACE,oBAAC,YAAY,UAAb;EAAsB,OAAO;EAC3B,UAAA,oBAAC,OAAD;GAAgB;GAAW,kBAAA;GACxB;EACE,CAAA;CACe,CAAA;AAE1B"}

package/dist/esm/chat-ui/create-chat-hook.d.ts

@@ -0,0 +1,48 @@
+import { ComponentType } from 'react';
+import { InferredClientContext } from '@tanstack/ai-client';
+import { ChatUIInterruptsOf, ChatUISchemaOf, ChatUIToolsOf } from '@tanstack/ai-client/ui';
+import { UseChatOptions } from '../types.js';
+import { ChatUIFactoryConfig, ChatUIHost, InputProps } from './create-ui.js';
+type HeadlessOptions<TOptions> = UseChatOptions<ChatUIToolsOf<TOptions>, ChatUISchemaOf<TOptions>, InferredClientContext<ChatUIToolsOf<TOptions>>, ChatUIInterruptsOf<TOptions>>;
+type ChatInstanceOverrides<TOptions> = {
+    threadId?: string;
+    live?: boolean;
+    forwardedProps?: Record<string, any>;
+    body?: Record<string, any>;
+    initialMessages?: HeadlessOptions<TOptions>['initialMessages'];
+};
+/**
+ * Bind chat options and UI widgets once at module scope.
+ *
+ * This matches Form `createFormHook` and Table `createTableHook`. The
+ * returned `useAppChat` creates a chat instance. `chat.AppChat` renders it.
+ * `useChatContext` reads that instance. Part and interrupt widgets take
+ * `part` / `interrupt` as props. Do not read those from context.
+ *
+ * Pass instance overrides such as `threadId` into `useAppChat()`.
+ *
+ * @example
+ * ```tsx
+ * const { useAppChat, useChatContext } = createChatHook({
+ *   options: chatOptions,
+ *   components: { layout: ChatLayout, message: ChatMessage },
+ *   partsComponents: { fallback: FallbackPart },
+ *   toolsComponents: { getWeather: WeatherTool, purchaseItem: PurchaseTool },
+ *   interruptsComponents: { generic: { choosePlan: ChoosePlan } },
+ * })
+ *
+ * function Support() {
+ *   const chat = useAppChat({ threadId: 'support-1' })
+ *   return <chat.AppChat />
+ * }
+ * ```
+ */
+export declare function createChatHook<const TOptions, TInput extends ComponentType<any> | undefined = ComponentType<InputProps<NoInfer<TOptions>>> | undefined>({ options, ...chatComponents }: {
+    options: TOptions;
+} & ChatUIFactoryConfig<NoInfer<TOptions>, TInput>): {
+    useAppChat: (overrides?: ChatInstanceOverrides<TOptions>) => ChatUIHost<TOptions> & {
+        AppChat: ComponentType;
+    };
+    useChatContext: () => ChatUIHost<TOptions>;
+};
+export {};

package/dist/esm/chat-ui/create-chat-hook.js

@@ -0,0 +1,57 @@
+import { useChat } from "../use-chat.js";
+import { createChatUI } from "./create-ui.js";
+import { useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/chat-ui/create-chat-hook.tsx
+/**
+* Bind chat options and UI widgets once at module scope.
+*
+* This matches Form `createFormHook` and Table `createTableHook`. The
+* returned `useAppChat` creates a chat instance. `chat.AppChat` renders it.
+* `useChatContext` reads that instance. Part and interrupt widgets take
+* `part` / `interrupt` as props. Do not read those from context.
+*
+* Pass instance overrides such as `threadId` into `useAppChat()`.
+*
+* @example
+* ```tsx
+* const { useAppChat, useChatContext } = createChatHook({
+*   options: chatOptions,
+*   components: { layout: ChatLayout, message: ChatMessage },
+*   partsComponents: { fallback: FallbackPart },
+*   toolsComponents: { getWeather: WeatherTool, purchaseItem: PurchaseTool },
+*   interruptsComponents: { generic: { choosePlan: ChoosePlan } },
+* })
+*
+* function Support() {
+*   const chat = useAppChat({ threadId: 'support-1' })
+*   return <chat.AppChat />
+* }
+* ```
+*/
+function createChatHook({ options, ...chatComponents }) {
+	const ui = createChatUI(options, chatComponents);
+	function useAppChat(overrides) {
+		const chat = overrides ? useChat({
+			...options,
+			...overrides
+		}) : useChat(options);
+		const chatRef = useRef(chat);
+		chatRef.current = chat;
+		const AppChat = useMemo(() => {
+			function AppChatImpl() {
+				return /* @__PURE__ */ jsx(ui.Chat, { chat: chatRef.current });
+			}
+			return AppChatImpl;
+		}, []);
+		return Object.assign(chat, { AppChat });
+	}
+	return {
+		useAppChat,
+		useChatContext: ui.useChatContext
+	};
+}
+//#endregion
+export { createChatHook };
+
+//# sourceMappingURL=create-chat-hook.js.map

package/dist/esm/chat-ui/create-chat-hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-chat-hook.js","names":[],"sources":["../../../src/chat-ui/create-chat-hook.tsx"],"sourcesContent":["import { useMemo, useRef } from 'react'\nimport type { ComponentType } from 'react'\nimport type { InferredClientContext } from '@tanstack/ai-client'\nimport type {\n  ChatUIInterruptsOf,\n  ChatUISchemaOf,\n  ChatUIToolsOf,\n} from '@tanstack/ai-client/ui'\nimport { useChat as useUnboundChat } from '../use-chat'\nimport type { UseChatOptions } from '../types'\nimport { createChatUI } from './create-ui'\nimport type { ChatUIFactoryConfig, ChatUIHost, InputProps } from './create-ui'\n\ntype HeadlessOptions<TOptions> = UseChatOptions<\n  ChatUIToolsOf<TOptions>,\n  ChatUISchemaOf<TOptions>,\n  InferredClientContext<ChatUIToolsOf<TOptions>>,\n  ChatUIInterruptsOf<TOptions>\n>\n\ntype ChatInstanceOverrides<TOptions> = {\n  threadId?: string\n  live?: boolean\n  forwardedProps?: Record<string, any>\n  body?: Record<string, any>\n  initialMessages?: HeadlessOptions<TOptions>['initialMessages']\n}\n\n/**\n * Bind chat options and UI widgets once at module scope.\n *\n * This matches Form `createFormHook` and Table `createTableHook`. The\n * returned `useAppChat` creates a chat instance. `chat.AppChat` renders it.\n * `useChatContext` reads that instance. Part and interrupt widgets take\n * `part` / `interrupt` as props. Do not read those from context.\n *\n * Pass instance overrides such as `threadId` into `useAppChat()`.\n *\n * @example\n * ```tsx\n * const { useAppChat, useChatContext } = createChatHook({\n *   options: chatOptions,\n *   components: { layout: ChatLayout, message: ChatMessage },\n *   partsComponents: { fallback: FallbackPart },\n *   toolsComponents: { getWeather: WeatherTool, purchaseItem: PurchaseTool },\n *   interruptsComponents: { generic: { choosePlan: ChoosePlan } },\n * })\n *\n * function Support() {\n *   const chat = useAppChat({ threadId: 'support-1' })\n *   return <chat.AppChat />\n * }\n * ```\n */\nexport function createChatHook<\n  const TOptions,\n  TInput extends ComponentType<any> | undefined =\n    | ComponentType<InputProps<NoInfer<TOptions>>>\n    | undefined,\n>({\n  options,\n  ...chatComponents\n}: {\n  options: TOptions\n} & ChatUIFactoryConfig<NoInfer<TOptions>, TInput>) {\n  const ui = createChatUI(\n    options,\n    chatComponents as ChatUIFactoryConfig<NoInfer<TOptions>, TInput>,\n  )\n\n  function useAppChat(overrides?: ChatInstanceOverrides<TOptions>) {\n    const chat = (\n      overrides\n        ? useUnboundChat({\n            ...(options as HeadlessOptions<TOptions>),\n            ...overrides,\n          })\n        : useUnboundChat(options as HeadlessOptions<TOptions>)\n    ) as ChatUIHost<TOptions>\n\n    // `useChat` returns a fresh object on every render. The mixed Chat\n    // component must stay stable, or React remounts the tree on each\n    // update. Read the current instance from a ref.\n    const chatRef = useRef(chat)\n    chatRef.current = chat\n\n    const AppChat = useMemo(() => {\n      function AppChatImpl() {\n        return <ui.Chat chat={chatRef.current} />\n      }\n      return AppChatImpl\n    }, [])\n\n    return Object.assign(chat, { AppChat }) as ChatUIHost<TOptions> & {\n      AppChat: ComponentType\n    }\n  }\n\n  return {\n    useAppChat,\n    useChatContext: ui.useChatContext,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,eAKd,EACA,SACA,GAAG,kBAG+C;CAClD,MAAM,KAAK,aACT,SACA,cACF;CAEA,SAAS,WAAW,WAA6C;EAC/D,MAAM,OACJ,YACI,QAAe;GACb,GAAI;GACJ,GAAG;EACL,CAAC,IACD,QAAe,OAAoC;EAMzD,MAAM,UAAU,OAAO,IAAI;EAC3B,QAAQ,UAAU;EAElB,MAAM,UAAU,cAAc;GAC5B,SAAS,cAAc;IACrB,OAAO,oBAAC,GAAG,MAAJ,EAAS,MAAM,QAAQ,QAAU,CAAA;GAC1C;GACA,OAAO;EACT,GAAG,CAAC,CAAC;EAEL,OAAO,OAAO,OAAO,MAAM,EAAE,QAAQ,CAAC;CAGxC;CAEA,OAAO;EACL;EACA,gBAAgB,GAAG;CACrB;AACF"}

package/dist/esm/chat-ui/create-ui-contexts.d.ts

@@ -0,0 +1,29 @@
+import { Context } from 'react';
+import { ChatUIInterrupt, ChatUISelectedPart } from '@tanstack/ai-client/ui';
+import { UseChatReturn } from '../types.js';
+/**
+ * Scoped chat, part, and interrupt contexts plus matching context hooks.
+ * Pass these into {@link createChatHook} when widgets live in other files, or
+ * when two chat trees nest and must not share the default contexts.
+ */
+export interface ChatUIContexts {
+    chatContext: Context<UseChatReturn<any, any, any> | null>;
+    partContext: Context<ChatUISelectedPart | null>;
+    interruptContext: Context<ChatUIInterrupt | null>;
+    useChatContext: () => UseChatReturn<any, any, any>;
+}
+/**
+ * Create a fresh set of chat UI contexts. This matches Form
+ * `createFormHookContexts` and Table `createTableHookContexts`.
+ *
+ * Most apps can skip this. `createChatHook` uses shared module contexts by
+ * default. The hooks on this object are the escape hatch for a widget file
+ * that cannot import the `createChatHook` result (circular import), or for
+ * nested chats that need isolated providers.
+ *
+ * Prefer the `useChatContext` hook returned from `createChatHook` when you
+ * can import that result. That hook knows the `chatComponents` types. Part
+ * and interrupt widgets take `part` / `interrupt` as props.
+ */
+export declare function createChatHookContexts(): ChatUIContexts;
+export declare const defaultChatUIContexts: ChatUIContexts;

package/dist/esm/chat-ui/create-ui-contexts.js

@@ -0,0 +1,36 @@
+import { createContext, useContext } from "react";
+//#region src/chat-ui/create-ui-contexts.tsx
+/**
+* Create a fresh set of chat UI contexts. This matches Form
+* `createFormHookContexts` and Table `createTableHookContexts`.
+*
+* Most apps can skip this. `createChatHook` uses shared module contexts by
+* default. The hooks on this object are the escape hatch for a widget file
+* that cannot import the `createChatHook` result (circular import), or for
+* nested chats that need isolated providers.
+*
+* Prefer the `useChatContext` hook returned from `createChatHook` when you
+* can import that result. That hook knows the `chatComponents` types. Part
+* and interrupt widgets take `part` / `interrupt` as props.
+*/
+function createChatHookContexts() {
+	const chatContext = createContext(null);
+	const partContext = createContext(null);
+	const interruptContext = createContext(null);
+	function useChatContext() {
+		const chat = useContext(chatContext);
+		if (!chat) throw new Error("`useChatContext` must be used within `UI.Provider` or `UI.Chat`.");
+		return chat;
+	}
+	return {
+		chatContext,
+		partContext,
+		interruptContext,
+		useChatContext
+	};
+}
+var defaultChatUIContexts = createChatHookContexts();
+//#endregion
+export { createChatHookContexts, defaultChatUIContexts };
+
+//# sourceMappingURL=create-ui-contexts.js.map

package/dist/esm/chat-ui/create-ui-contexts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ui-contexts.js","names":[],"sources":["../../../src/chat-ui/create-ui-contexts.tsx"],"sourcesContent":["import { createContext, useContext } from 'react'\nimport type { Context } from 'react'\nimport type {\n  ChatUIInterrupt,\n  ChatUISelectedPart,\n} from '@tanstack/ai-client/ui'\nimport type { UseChatReturn } from '../types'\n\n/**\n * Scoped chat, part, and interrupt contexts plus matching context hooks.\n * Pass these into {@link createChatHook} when widgets live in other files, or\n * when two chat trees nest and must not share the default contexts.\n */\nexport interface ChatUIContexts {\n  chatContext: Context<UseChatReturn<any, any, any> | null>\n  partContext: Context<ChatUISelectedPart | null>\n  interruptContext: Context<ChatUIInterrupt | null>\n  useChatContext: () => UseChatReturn<any, any, any>\n}\n\n/**\n * Create a fresh set of chat UI contexts. This matches Form\n * `createFormHookContexts` and Table `createTableHookContexts`.\n *\n * Most apps can skip this. `createChatHook` uses shared module contexts by\n * default. The hooks on this object are the escape hatch for a widget file\n * that cannot import the `createChatHook` result (circular import), or for\n * nested chats that need isolated providers.\n *\n * Prefer the `useChatContext` hook returned from `createChatHook` when you\n * can import that result. That hook knows the `chatComponents` types. Part\n * and interrupt widgets take `part` / `interrupt` as props.\n */\nexport function createChatHookContexts(): ChatUIContexts {\n  const chatContext = createContext<UseChatReturn<any, any, any> | null>(null)\n  const partContext = createContext<ChatUISelectedPart | null>(null)\n  const interruptContext = createContext<ChatUIInterrupt | null>(null)\n\n  function useChatContext() {\n    const chat = useContext(chatContext)\n    if (!chat) {\n      throw new Error(\n        '`useChatContext` must be used within `UI.Provider` or `UI.Chat`.',\n      )\n    }\n    return chat\n  }\n\n  return {\n    chatContext,\n    partContext,\n    interruptContext,\n    useChatContext,\n  }\n}\n\nexport const defaultChatUIContexts = createChatHookContexts()\n"],"mappings":";;;;;;;;;;;;;;;AAiCA,SAAgB,yBAAyC;CACvD,MAAM,cAAc,cAAmD,IAAI;CAC3E,MAAM,cAAc,cAAyC,IAAI;CACjE,MAAM,mBAAmB,cAAsC,IAAI;CAEnE,SAAS,iBAAiB;EACxB,MAAM,OAAO,WAAW,WAAW;EACnC,IAAI,CAAC,MACH,MAAM,IAAI,MACR,kEACF;EAEF,OAAO;CACT;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF;AAEA,IAAa,wBAAwB,uBAAuB"}

package/dist/esm/chat-ui/create-ui.d.ts

@@ -0,0 +1,153 @@
+import { ComponentType, ReactNode } from 'react';
+import { ChatUIData, ChatUIHasNamedInterrupts, ChatUIHasNamedTools, ChatUIInterrupt, ChatUIInterruptName, ChatUIInterruptOf, ChatUIInterruptsOf, ChatUIMessages, ChatUINamedInterruptId, ChatUIPartKey, ChatUIPartOf, ChatUISchemaOf, ChatUISelectedPart, ChatUIToolApproval, ChatUIToolName, ChatUIToolsOf } from '@tanstack/ai-client/ui';
+import { MessagePart, QueuedMessage, ToolCallPart, ToolResultPart, UIMessage } from '@tanstack/ai-client';
+import { UseChatReturn } from '../types.js';
+import { ChatUIContexts } from './create-ui-contexts.js';
+export type ChatUIHost<TOptions = unknown> = UseChatReturn<ChatUIToolsOf<TOptions>, ChatUISchemaOf<TOptions>, ChatUIInterruptsOf<TOptions>>;
+export type ChatUIQueueItem = QueuedMessage & {
+    cancelQueued: () => void;
+};
+export type LayoutProps<TOptions, TInput extends ComponentType<any> | undefined = ComponentType<InputProps<TOptions>>> = {
+    Messages: ComponentType;
+    Interrupts: ComponentType;
+    Queue: ComponentType;
+    readonly __ui?: TOptions;
+} & (TInput extends ComponentType<any> ? {
+    Input: ComponentType;
+} : {});
+export type MessageProps<TOptions> = {
+    message: UIMessage<ChatUIToolsOf<TOptions>, ChatUIData<TOptions>>;
+    Parts: ComponentType;
+};
+export type InputProps<TOptions> = {
+    readonly __ui?: TOptions;
+};
+export type QueueProps<TOptions> = {
+    item: ChatUIQueueItem;
+    readonly __ui?: TOptions;
+};
+export type PartProps<TOptions, TKey extends ChatUIPartKey = ChatUIPartKey> = {
+    part: ChatUIPartOf<TOptions, TKey>;
+};
+export type ToolProps<TOptions, TName extends ChatUIToolName<TOptions> = ChatUIToolName<TOptions>> = {
+    part: Extract<ToolCallPart<ChatUIToolsOf<TOptions>>, {
+        name: TName;
+    }>;
+    result?: ToolResultPart;
+    interrupt?: ChatUIToolApproval<TOptions, TName>;
+};
+export type InterruptProps<TOptions, TName extends ChatUIInterruptName<TOptions> = never> = {
+    interrupt: ChatUIInterruptOf<TOptions, TName>;
+    readonly __ui?: TOptions;
+};
+type GenericInterruptComponents<TOptions> = ChatUIHasNamedInterrupts<TOptions> extends true ? {
+    [K in ChatUINamedInterruptId<TOptions>]: ComponentType<InterruptProps<TOptions, K & ChatUIInterruptName<TOptions>>>;
+} & {
+    fallback?: ComponentType<InterruptProps<TOptions>>;
+} : {
+    fallback?: ComponentType<InterruptProps<TOptions>>;
+};
+type ToolApprovalMap<TOptions> = {
+    [K in ChatUIToolName<TOptions>]?: ComponentType<InterruptProps<TOptions, K & ChatUIInterruptName<TOptions>>>;
+};
+/** The chrome around the message list: `layout`, `message`, and `input`. */
+export type ChatUIChromeComponents<TOptions, TInput extends ComponentType<InputProps<TOptions>> | undefined = ComponentType<InputProps<TOptions>>> = {
+    layout: ComponentType<LayoutProps<TOptions, TInput>>;
+    message: ComponentType<MessageProps<TOptions>>;
+    input?: TInput;
+    queue?: ComponentType<QueueProps<TOptions>>;
+};
+export type ChatUIPartsComponents<TOptions> = {
+    [K in ChatUIPartKey]?: ComponentType<PartProps<TOptions, K>>;
+} & {
+    fallback?: ComponentType<PartProps<TOptions>>;
+};
+export type ChatUIInterruptsComponents<TOptions> = {
+    tools?: ToolApprovalMap<TOptions>;
+    generic: GenericInterruptComponents<TOptions>;
+};
+export type ChatUIComponents<TOptions, TInput extends ComponentType<InputProps<TOptions>> | undefined = ComponentType<InputProps<TOptions>>> = {
+    components: ChatUIChromeComponents<TOptions, TInput>;
+    partsComponents: ChatUIPartsComponents<TOptions>;
+} & (ChatUIHasNamedTools<TOptions> extends true ? {
+    toolsComponents: {
+        [K in ChatUIToolName<TOptions>]: ComponentType<ToolProps<TOptions, K>>;
+    };
+} : {
+    toolsComponents?: {
+        [K in ChatUIToolName<TOptions>]?: ComponentType<ToolProps<TOptions, K>>;
+    };
+}) & (ChatUIHasNamedInterrupts<TOptions> extends true ? {
+    interruptsComponents: ChatUIInterruptsComponents<TOptions>;
+} : {
+    interruptsComponents?: {
+        tools?: ToolApprovalMap<TOptions>;
+        generic?: GenericInterruptComponents<TOptions>;
+    };
+});
+/** Scoped contexts, for widgets in other files or nested chat trees. */
+export type ChatUIContextConfig = {
+    chatContext?: ChatUIContexts['chatContext'];
+    partContext?: ChatUIContexts['partContext'];
+    interruptContext?: ChatUIContexts['interruptContext'];
+};
+export type ChatUIFactoryConfig<TOptions, TInput extends ComponentType<InputProps<TOptions>> | undefined = ComponentType<InputProps<TOptions>>> = ChatUIComponents<TOptions, TInput> & {
+    context?: ChatUIContextConfig;
+};
+type BoundWidget = ComponentType<Record<string, never>>;
+type PartMixins<TOptions> = {
+    [K in ChatUIPartKey]?: BoundWidget;
+} & {
+    [K in ChatUIToolName<TOptions>]: BoundWidget;
+} & {
+    Render: BoundWidget;
+};
+type InterruptMixins<TOptions> = {
+    [K in ChatUINamedInterruptId<TOptions>]: BoundWidget;
+} & {
+    [K in ChatUIToolName<TOptions>]?: BoundWidget;
+} & {
+    fallback?: BoundWidget;
+    Render: BoundWidget;
+};
+/**
+ * Bind chat options and UI widgets once at module scope. This matches Form
+ * `createFormHook` and Table `createTableHook`: widgets register here, mix
+ * onto Part / Interrupt / the UI kit, and automatic dispatch still walks the
+ * message list.
+ *
+ * `chatOptions` is type-only at runtime. Pass optional `chatContext`,
+ * `partContext`, and `interruptContext` from {@link createChatHookContexts}
+ * when widgets live in other files or when nested chats need isolation.
+ */
+export declare function createChatUI<const TOptions, TInput extends ComponentType<any> | undefined = ComponentType<InputProps<NoInfer<TOptions>>> | undefined>(options: TOptions, config: ChatUIFactoryConfig<NoInfer<TOptions>, TInput>): {
+    Chat: ({ chat }: {
+        chat: ChatUIHost<TOptions>;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Provider: ({ chat, children, }: {
+        chat: ChatUIHost<TOptions>;
+        children?: ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Messages: ({ children, }?: {
+        children?: (messages: ChatUIMessages<TOptions>) => ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Message: ({ message, children, }: {
+        message: ChatUIMessages<TOptions>[number];
+        children?: (parts: Array<ChatUISelectedPart>) => ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Part: ({ part, children, }: {
+        part: MessagePart | ChatUISelectedPart;
+        children?: (mixed: ChatUISelectedPart & PartMixins<TOptions>) => ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element | null;
+    Interrupts: ({ children, }?: {
+        children?: (interrupts: ReadonlyArray<ChatUIInterrupt>) => ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Interrupt: import('react').MemoExoticComponent<({ interrupt, children, }: {
+        interrupt: ChatUIInterrupt;
+        children?: (mixed: ChatUIInterrupt & InterruptMixins<TOptions>) => ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    Queue: () => import("react/jsx-runtime").JSX.Element | null;
+    useChatContext: () => ChatUIHost<TOptions>;
+    Input: TInput | undefined;
+};
+export {};