@tanstack/ai-svelte 0.19.4 → 0.20.0

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

@@ -0,0 +1,27 @@
+import type { InferredClientContext } from '@tanstack/ai-client';
+import type { ChatUIInterruptsOf, ChatUISchemaOf, ChatUIToolsOf } from '@tanstack/ai-client/ui';
+import type { CreateChatOptions } from '../types';
+import type { ChatUIFactoryConfig, ChatUIHost } from './create-ui';
+type HeadlessOptions<TOptions> = CreateChatOptions<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.
+ *
+ * Returns a bound `createAppChat`, the UI descriptor (`ui`), and
+ * `useChatContext`. Pass `{ui}` into `UIChat`. Pass instance overrides
+ * such as `threadId` into `createAppChat()`.
+ */
+export declare function createChatHook<const TOptions>({ options, ...chatComponents }: {
+    options: TOptions;
+} & ChatUIFactoryConfig<NoInfer<TOptions>>): {
+    createAppChat: (overrides?: ChatInstanceOverrides<TOptions>) => ChatUIHost<TOptions>;
+    ui: import("./create-ui").UIDescriptor<TOptions>;
+    useChatContext: () => ChatUIHost<TOptions>;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import { createChat as createUnboundChat } from '../create-chat.svelte';
+import { createChatUI } from './create-ui';
+/**
+ * Bind chat options and UI widgets once at module scope.
+ *
+ * Returns a bound `createAppChat`, the UI descriptor (`ui`), and
+ * `useChatContext`. Pass `{ui}` into `UIChat`. Pass instance overrides
+ * such as `threadId` into `createAppChat()`.
+ */
+export function createChatHook({ options, ...chatComponents }) {
+    const ui = createChatUI(options, chatComponents);
+    function createAppChat(overrides) {
+        if (!overrides) {
+            return createUnboundChat(options);
+        }
+        return createUnboundChat({
+            ...options,
+            ...overrides,
+        });
+    }
+    return {
+        createAppChat,
+        ui,
+        useChatContext: ui.useChatContext,
+    };
+}

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

@@ -0,0 +1,131 @@
+import type { ChatUIData, ChatUIHasNamedInterrupts, ChatUIHasNamedTools, ChatUIInterrupt, ChatUIInterruptName, ChatUIInterruptOf, ChatUIInterruptsOf, ChatUINamedInterruptId, ChatUIPartKey, ChatUIPartOf, ChatUISchemaOf, ChatUISelectedPart, ChatUIToolApproval, ChatUIToolName, ChatUIToolsOf } from '@tanstack/ai-client/ui';
+import type { QueuedMessage, ToolCallPart, ToolResultPart, UIMessage } from '@tanstack/ai-client';
+import type { CreateChatReturn } from '../types';
+export type ChatUIHost<TOptions = unknown> = CreateChatReturn<ChatUIToolsOf<TOptions>, ChatUISchemaOf<TOptions>, unknown, ChatUIInterruptsOf<TOptions>>;
+type GenericInterruptComponents<TOptions> = ChatUIHasNamedInterrupts<TOptions> extends true ? {
+    [K in ChatUINamedInterruptId<TOptions>]: unknown;
+} & {
+    fallback?: unknown;
+} : {
+    fallback?: unknown;
+};
+type ToolApprovalMap<TOptions> = {
+    [K in ChatUIToolName<TOptions>]?: unknown;
+};
+/** The chrome around the message list: `layout`, `message`, and `input`. */
+export type ChatUIChromeComponents = {
+    layout: unknown;
+    message: unknown;
+    input?: unknown;
+    queue?: unknown;
+};
+export type ChatUIPartsComponents = {
+    [K in ChatUIPartKey]?: unknown;
+} & {
+    fallback?: unknown;
+};
+export type ChatUIInterruptsComponents<TOptions> = {
+    tools?: ToolApprovalMap<TOptions>;
+    generic: GenericInterruptComponents<TOptions>;
+};
+/** The flat shape the runtime reads, assembled from the factory config. */
+export type ChatUIComponents<TOptions> = ChatUIChromeComponents & {
+    parts: ChatUIPartsComponents;
+    tools?: {
+        [K in ChatUIToolName<TOptions>]?: unknown;
+    };
+    interrupts?: {
+        tools?: ToolApprovalMap<TOptions>;
+        generic?: GenericInterruptComponents<TOptions>;
+    };
+};
+export type ChatUIFactoryConfig<TOptions> = {
+    components: ChatUIChromeComponents;
+    partsComponents: ChatUIPartsComponents;
+} & (ChatUIHasNamedTools<TOptions> extends true ? {
+    toolsComponents: {
+        [K in ChatUIToolName<TOptions>]: unknown;
+    };
+} : {
+    toolsComponents?: {
+        [K in ChatUIToolName<TOptions>]?: unknown;
+    };
+}) & (ChatUIHasNamedInterrupts<TOptions> extends true ? {
+    interruptsComponents: ChatUIInterruptsComponents<TOptions>;
+} : {
+    interruptsComponents?: {
+        tools?: ToolApprovalMap<TOptions>;
+        generic?: GenericInterruptComponents<TOptions>;
+    };
+});
+export type UIDescriptor<TOptions = unknown> = {
+    key: symbol;
+    warn: (key: string, message: string) => void;
+    components: ChatUIComponents<TOptions>;
+    useChatContext: () => ChatUIHost<TOptions>;
+};
+export type UIContextValue<TOptions = unknown> = {
+    chat: ChatUIHost<TOptions>;
+    components: ChatUIComponents<TOptions>;
+    ui: UIDescriptor<TOptions>;
+};
+type ComponentsValue<TOptions = unknown> = {
+    components: ChatUIComponents<TOptions>;
+    warn: (key: string, message: string) => void;
+    inlineToolNames: ReadonlyArray<string>;
+};
+export declare function createChatUI<const TOptions>(options: TOptions, config: ChatUIFactoryConfig<NoInfer<TOptions>>): UIDescriptor<TOptions>;
+export declare function setUIContext<TOptions>(value: UIContextValue<TOptions>): void;
+export declare function getChatContext<TOptions>(ui: UIDescriptor<TOptions>): ChatUIHost<TOptions>;
+export declare function getComponentsContext<TOptions>(ui: UIDescriptor<TOptions>): ComponentsValue<TOptions>;
+export declare function getUIContext<TOptions>(ui: UIDescriptor<TOptions>): {
+    ui: UIDescriptor<TOptions>;
+    chat: ChatUIHost<TOptions>;
+    components: ChatUIComponents<TOptions>;
+};
+export declare function readMessages<TOptions>(chat: ChatUIHost<TOptions>): UIMessage<ChatUIToolsOf<TOptions>, ChatUISchemaOf<TOptions> extends infer T ? T extends ChatUISchemaOf<TOptions> ? T extends import("@tanstack/ai").SchemaInput ? import("@tanstack/ai").InferSchemaType<T> : unknown : never : never>[];
+export declare function readInterrupts<TOptions>(chat: ChatUIHost<TOptions>): import("@tanstack/ai-client").BoundInterrupts<ChatUIToolsOf<TOptions>, ChatUIInterruptsOf<TOptions>>;
+export declare function readQueue<TOptions>(chat: ChatUIHost<TOptions>): {
+    cancelQueued: () => void;
+    id: string;
+    content: string | import("@tanstack/ai-client").MultimodalContent;
+    createdAt: number;
+}[];
+export declare function inlineNames<TOptions>(components: ChatUIComponents<TOptions>): string[];
+export declare function messageParts(message: UIMessage, interrupts: ReadonlyArray<ChatUIInterrupt>, inlineToolNames: ReadonlyArray<string>): Array<ChatUISelectedPart>;
+export declare function listInterrupts<TOptions>(chat: ChatUIHost<TOptions>, inlineToolNames: ReadonlyArray<string>): ChatUIInterrupt[];
+export declare function toolComponent<TOptions>(components: ChatUIComponents<TOptions>, name: string): undefined;
+export declare function partComponent<TOptions>(components: ChatUIComponents<TOptions>, key: string): unknown;
+export declare function interruptComponent<TOptions>(components: ChatUIComponents<TOptions>, interrupt: ChatUIInterrupt): unknown;
+export type ChatUIQueueItem = QueuedMessage & {
+    cancelQueued: () => void;
+};
+export type LayoutProps<TOptions> = {
+    readonly __ui?: TOptions;
+};
+export type MessageProps<TOptions> = {
+    message: UIMessage<ChatUIToolsOf<TOptions>, ChatUIData<TOptions>>;
+};
+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>;
+    readonly __ui?: TOptions;
+};
+export type InterruptProps<TOptions, TName extends ChatUIInterruptName<TOptions> = never> = {
+    interrupt: ChatUIInterruptOf<TOptions, TName>;
+    readonly __ui?: TOptions;
+};
+export {};

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

@@ -0,0 +1,100 @@
+import { getContext, setContext } from 'svelte';
+import { automaticPartsForMessage, collectInlineToolNames, resolveInterruptComponent, selectChatUI, selectMessageUI, } from '@tanstack/ai-client/ui';
+function createWarnOnce() {
+    const seen = new Set();
+    return (key, message) => {
+        if (process.env.NODE_ENV === 'production')
+            return;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        console.warn(message);
+    };
+}
+export function createChatUI(options, config) {
+    void options;
+    const { components: chrome, partsComponents, toolsComponents, interruptsComponents, } = config;
+    // The runtime keeps the flat shape the rest of this module reads.
+    const components = {
+        ...chrome,
+        parts: partsComponents,
+        tools: toolsComponents,
+        interrupts: interruptsComponents,
+    };
+    const ui = {
+        key: Symbol('tanstack-ai-ui-chat'),
+        componentsKey: Symbol('tanstack-ai-ui-components'),
+        warn: createWarnOnce(),
+        components,
+        useChatContext() {
+            return getChatContext(ui);
+        },
+    };
+    return ui;
+}
+export function setUIContext(value) {
+    setContext(value.ui.key, value.chat);
+    setContext(value.ui.componentsKey, {
+        components: value.components,
+        warn: value.ui.warn,
+        inlineToolNames: inlineNames(value.components),
+    });
+}
+export function getChatContext(ui) {
+    const chat = getContext(ui.key);
+    if (!chat) {
+        throw new Error('Chat UI components must be wrapped in UIProvider or UIChat.');
+    }
+    return chat;
+}
+export function getComponentsContext(ui) {
+    const value = getContext(ui.componentsKey);
+    if (!value) {
+        throw new Error('Chat UI components must be wrapped in UIProvider or UIChat.');
+    }
+    return value;
+}
+export function getUIContext(ui) {
+    return {
+        ui,
+        chat: getChatContext(ui),
+        components: getComponentsContext(ui).components,
+    };
+}
+export function readMessages(chat) {
+    return chat.messages ?? [];
+}
+export function readInterrupts(chat) {
+    return chat.interrupts ?? [];
+}
+export function readQueue(chat) {
+    const items = chat.queue ?? [];
+    return items.map((item) => ({
+        ...item,
+        cancelQueued: () => {
+            chat.cancelQueued(item.id);
+        },
+    }));
+}
+export function inlineNames(components) {
+    return collectInlineToolNames(components.interrupts?.tools, Object.keys(components.tools ?? {}));
+}
+export function messageParts(message, interrupts, inlineToolNames) {
+    return automaticPartsForMessage(selectMessageUI(message, { interrupts, inlineToolNames }));
+}
+export function listInterrupts(chat, inlineToolNames) {
+    return selectChatUI({
+        messages: readMessages(chat),
+        interrupts: readInterrupts(chat),
+        inlineToolNames,
+    }).interrupts;
+}
+export function toolComponent(components, name) {
+    return components.tools?.[name];
+}
+export function partComponent(components, key) {
+    return components.parts[key] ?? components.parts.fallback;
+}
+export function interruptComponent(components, interrupt) {
+    return resolveInterruptComponent(interrupt, components.interrupts);
+}

package/dist/chat-ui/selected-part.svelte

@@ -0,0 +1,45 @@
+<script lang="ts">
+  import {
+    getComponentsContext,
+    partComponent,
+    toolComponent,
+    type UIDescriptor,
+  } from './create-ui'
+  import type { ChatUISelectedPart } from '@tanstack/ai-client/ui'
+
+  let {
+    ui,
+    selected,
+  }: {
+    ui: UIDescriptor
+    selected: ChatUISelectedPart
+  } = $props()
+
+  const comps = $derived(getComponentsContext(ui))
+</script>
+
+{#if selected.key === 'toolCall'}
+  {@const Tool = toolComponent(comps.components, selected.part.name) as any}
+  {#if Tool}
+    <Tool
+      part={selected.part}
+      result={selected.result}
+      interrupt={selected.interrupt}
+    />
+  {:else}
+    {comps.warn(
+      `tool:${selected.part.name}`,
+      `[tanstack-ai-ui] Missing tools.${selected.part.name} component`,
+    )}
+  {/if}
+{:else}
+  {@const Part = partComponent(comps.components, selected.key) as any}
+  {#if Part}
+    <Part part={selected.part} />
+  {:else}
+    {comps.warn(
+      `part:${selected.key}`,
+      `[tanstack-ai-ui] Missing parts.${selected.key} component`,
+    )}
+  {/if}
+{/if}

package/dist/chat-ui/selected-part.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type UIDescriptor } from './create-ui';
+import type { ChatUISelectedPart } from '@tanstack/ai-client/ui';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    selected: ChatUISelectedPart;
+};
+declare const SelectedPart: import("svelte").Component<$$ComponentProps, {}, "">;
+type SelectedPart = ReturnType<typeof SelectedPart>;
+export default SelectedPart;

package/dist/chat-ui/ui-chat.svelte

@@ -0,0 +1,42 @@
+<script lang="ts">
+  import UIProvider from './ui-provider.svelte'
+  import UIMessages from './ui-messages.svelte'
+  import UIInterrupts from './ui-interrupts.svelte'
+  import UIQueue from './ui-queue.svelte'
+  import type { ChatUIComponents, UIDescriptor } from './create-ui'
+
+  let {
+    ui,
+    chat,
+    components,
+  }: {
+    ui: UIDescriptor
+    // ponytail: Svelte components are not generic, so ChatUIHost<TOptions> cannot
+    // accept a typed createChat() host with tool-approval interrupts.
+    chat: any
+    components?: ChatUIComponents<unknown>
+  } = $props()
+
+  const bound = $derived(components ?? ui.components)
+  const Layout = $derived(bound.layout as any)
+  const Input = $derived(bound.input as any)
+</script>
+
+<UIProvider {ui} {chat} components={bound}>
+  <Layout>
+    {#snippet messages()}
+      <UIMessages {ui} />
+    {/snippet}
+    {#snippet interrupts()}
+      <UIInterrupts {ui} />
+    {/snippet}
+    {#snippet queue()}
+      <UIQueue {ui} />
+    {/snippet}
+    {#snippet input()}
+      {#if Input}
+        <Input />
+      {/if}
+    {/snippet}
+  </Layout>
+</UIProvider>

package/dist/chat-ui/ui-chat.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { ChatUIComponents, UIDescriptor } from './create-ui';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    chat: any;
+    components?: ChatUIComponents<unknown>;
+};
+declare const UiChat: import("svelte").Component<$$ComponentProps, {}, "">;
+type UiChat = ReturnType<typeof UiChat>;
+export default UiChat;

package/dist/chat-ui/ui-interrupt.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+  import {
+    getComponentsContext,
+    interruptComponent,
+    type UIDescriptor,
+  } from './create-ui'
+  import type { ChatUIInterrupt } from '@tanstack/ai-client/ui'
+
+  let {
+    ui,
+    interrupt,
+  }: {
+    ui: UIDescriptor
+    interrupt: ChatUIInterrupt
+  } = $props()
+
+  const comps = $derived(getComponentsContext(ui))
+  const Component = $derived(
+    interruptComponent(comps.components, interrupt) as any,
+  )
+</script>
+
+{#if Component}
+  <Component {interrupt} />
+{:else}
+  {comps.warn(
+    `interrupt:${interrupt.id}`,
+    `[tanstack-ai-ui] Missing interrupt component for ${interrupt.kind}`,
+  )}
+{/if}

package/dist/chat-ui/ui-interrupt.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type UIDescriptor } from './create-ui';
+import type { ChatUIInterrupt } from '@tanstack/ai-client/ui';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    interrupt: ChatUIInterrupt;
+};
+declare const UiInterrupt: import("svelte").Component<$$ComponentProps, {}, "">;
+type UiInterrupt = ReturnType<typeof UiInterrupt>;
+export default UiInterrupt;

package/dist/chat-ui/ui-interrupts.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+  import {
+    getChatContext,
+    getComponentsContext,
+    listInterrupts,
+    type UIDescriptor,
+  } from './create-ui'
+  import UIInterrupt from './ui-interrupt.svelte'
+  import type { ChatUIInterrupt } from '@tanstack/ai-client/ui'
+
+  let {
+    ui,
+    children,
+  }: {
+    ui: UIDescriptor
+    children?: import('svelte').Snippet<[Array<ChatUIInterrupt>]>
+  } = $props()
+
+  const chat = $derived(getChatContext(ui))
+  const comps = $derived(getComponentsContext(ui))
+  const interrupts = $derived(listInterrupts(chat, comps.inlineToolNames))
+</script>
+
+{#if children}
+  {@render children(interrupts)}
+{:else}
+  {#each interrupts as interrupt (interrupt.id)}
+    <UIInterrupt {ui} {interrupt} />
+  {/each}
+{/if}

package/dist/chat-ui/ui-interrupts.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type UIDescriptor } from './create-ui';
+import type { ChatUIInterrupt } from '@tanstack/ai-client/ui';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    children?: import('svelte').Snippet<[Array<ChatUIInterrupt>]>;
+};
+declare const UiInterrupts: import("svelte").Component<$$ComponentProps, {}, "">;
+type UiInterrupts = ReturnType<typeof UiInterrupts>;
+export default UiInterrupts;

package/dist/chat-ui/ui-message.svelte

@@ -0,0 +1,45 @@
+<script lang="ts">
+  import {
+    getChatContext,
+    getComponentsContext,
+    messageParts,
+    readInterrupts,
+    type UIDescriptor,
+  } from './create-ui'
+  import SelectedPart from './selected-part.svelte'
+  import type { ChatUIInterrupt } from '@tanstack/ai-client/ui'
+  import type { UIMessage } from '@tanstack/ai-client'
+
+  let {
+    ui,
+    message,
+    interrupts,
+    children,
+  }: {
+    ui: UIDescriptor
+    message: UIMessage
+    interrupts?: ReadonlyArray<ChatUIInterrupt>
+    children?: import('svelte').Snippet<[unknown]>
+  } = $props()
+
+  const comps = $derived(getComponentsContext(ui))
+  const resolvedInterrupts = $derived(
+    interrupts ?? readInterrupts(getChatContext(ui)),
+  )
+  const selectedParts = $derived(
+    messageParts(message, resolvedInterrupts, comps.inlineToolNames),
+  )
+  const Message = $derived(comps.components.message as any)
+</script>
+
+{#if children}
+  {@render children(selectedParts)}
+{:else}
+  <Message {message}>
+    {#snippet parts()}
+      {#each selectedParts as part, index (`${message.id}-${index}`)}
+        <SelectedPart {ui} selected={part} />
+      {/each}
+    {/snippet}
+  </Message>
+{/if}

package/dist/chat-ui/ui-message.svelte.d.ts

@@ -0,0 +1,12 @@
+import { type UIDescriptor } from './create-ui';
+import type { ChatUIInterrupt } from '@tanstack/ai-client/ui';
+import type { UIMessage } from '@tanstack/ai-client';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    message: UIMessage;
+    interrupts?: ReadonlyArray<ChatUIInterrupt>;
+    children?: import('svelte').Snippet<[unknown]>;
+};
+declare const UiMessage: import("svelte").Component<$$ComponentProps, {}, "">;
+type UiMessage = ReturnType<typeof UiMessage>;
+export default UiMessage;

package/dist/chat-ui/ui-messages.svelte

@@ -0,0 +1,31 @@
+<script lang="ts">
+  import {
+    getChatContext,
+    readInterrupts,
+    readMessages,
+    type UIDescriptor,
+  } from './create-ui'
+  import UIMessage from './ui-message.svelte'
+  import type { Snippet } from 'svelte'
+  import type { UIMessage as UIMessageModel } from '@tanstack/ai-client'
+
+  let {
+    ui,
+    children,
+  }: {
+    ui: UIDescriptor
+    children?: Snippet<[ReadonlyArray<UIMessageModel>]>
+  } = $props()
+
+  const chat = $derived(getChatContext(ui))
+  const messages = $derived(readMessages(chat))
+  const interrupts = $derived(readInterrupts(chat))
+</script>
+
+{#if children}
+  {@render children(messages)}
+{:else}
+  {#each messages as message (message.id)}
+    <UIMessage {ui} {message} {interrupts} />
+  {/each}
+{/if}

package/dist/chat-ui/ui-messages.svelte.d.ts

@@ -0,0 +1,10 @@
+import { type UIDescriptor } from './create-ui';
+import type { Snippet } from 'svelte';
+import type { UIMessage as UIMessageModel } from '@tanstack/ai-client';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    children?: Snippet<[ReadonlyArray<UIMessageModel>]>;
+};
+declare const UiMessages: import("svelte").Component<$$ComponentProps, {}, "">;
+type UiMessages = ReturnType<typeof UiMessages>;
+export default UiMessages;

package/dist/chat-ui/ui-part.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+  import {
+    getChatContext,
+    readInterrupts,
+    type UIDescriptor,
+  } from './create-ui'
+  import { selectMessageUI } from '@tanstack/ai-client/ui'
+  import SelectedPart from './selected-part.svelte'
+  import type { MessagePart } from '@tanstack/ai-client'
+
+  let {
+    ui,
+    part,
+  }: {
+    ui: UIDescriptor
+    part: MessagePart
+  } = $props()
+
+  const chat = $derived(getChatContext(ui))
+  const selected = $derived(
+    selectMessageUI(
+      { id: 'part', role: 'assistant', parts: [part] },
+      { interrupts: readInterrupts(chat), inlineToolNames: [] },
+    ).parts[0],
+  )
+</script>
+
+{#if selected}
+  <SelectedPart {ui} {selected} />
+{/if}

package/dist/chat-ui/ui-part.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type UIDescriptor } from './create-ui';
+import type { MessagePart } from '@tanstack/ai-client';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    part: MessagePart;
+};
+declare const UiPart: import("svelte").Component<$$ComponentProps, {}, "">;
+type UiPart = ReturnType<typeof UiPart>;
+export default UiPart;

package/dist/chat-ui/ui-provider.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+  import {
+    setUIContext,
+    type ChatUIComponents,
+    type UIDescriptor,
+  } from './create-ui'
+
+  let {
+    ui,
+    chat,
+    components,
+    children,
+  }: {
+    ui: UIDescriptor
+    // ponytail: Svelte components are not generic, so ChatUIHost<TOptions> cannot
+    // accept a typed createChat() host with tool-approval interrupts.
+    chat: any
+    components?: ChatUIComponents<unknown>
+    children?: import('svelte').Snippet
+  } = $props()
+
+  setUIContext({
+    ui,
+    chat,
+    components: (components ?? ui.components) as never,
+  })
+</script>
+
+{@render children?.()}

package/dist/chat-ui/ui-provider.svelte.d.ts

@@ -0,0 +1,10 @@
+import { type ChatUIComponents, type UIDescriptor } from './create-ui';
+type $$ComponentProps = {
+    ui: UIDescriptor;
+    chat: any;
+    components?: ChatUIComponents<unknown>;
+    children?: import('svelte').Snippet;
+};
+declare const UiProvider: import("svelte").Component<$$ComponentProps, {}, "">;
+type UiProvider = ReturnType<typeof UiProvider>;
+export default UiProvider;