@ai-sdk/svelte 1.1.24 → 2.0.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @ai-sdk/svelte
 
+## 2.0.1
+
+### Patch Changes
+
+- @ai-sdk/provider-utils@2.1.14
+- @ai-sdk/ui-utils@1.1.20
+
+## 2.0.0
+
+### Major Changes
+
+- 9e2cb6f: feat (ui/svelte): Modern Svelte 5 (**breaking change**)
+
 ## 1.1.24
 
 ### Patch Changes

package/README.md

@@ -2,6 +2,8 @@
 
 [Svelte](https://svelte.dev/) UI components for the [AI SDK](https://sdk.vercel.ai/docs):
 
-- [`useChat`](https://sdk.vercel.ai/docs/reference/ai-sdk-ui/use-chat) hook
-- [`useCompletion`](https://sdk.vercel.ai/docs/reference/ai-sdk-ui/use-completion) hook
-- [`useAssistant`](https://sdk.vercel.ai/docs/reference/ai-sdk-ui/use-assistant) hook
+- [`Chat`](https://sdk.vercel.ai/docs/reference/ai-sdk-ui/use-chat)
+- [`Completion`](https://sdk.vercel.ai/docs/reference/ai-sdk-ui/use-completion)
+- [`StructuredObject`](https://sdk.vercel.ai/docs/reference/ai-sdk-ui/use-object)
+
+For information on the few ways the Svelte APIs differ from the React ones, see [the docs](https://sdk.vercel.ai/docs/getting-started/svelte#how-does-ai-sdksvelte-differ-from-ai-sdkreact)

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

@@ -0,0 +1,14 @@
+import type { JSONValue, UIMessage } from '@ai-sdk/ui-utils';
+import { KeyedStore } from './utils.svelte.js';
+declare class ChatStore {
+    messages: UIMessage[];
+    data: JSONValue[] | undefined;
+    status: "submitted" | "streaming" | "ready" | "error";
+    error: Error | undefined;
+}
+export declare class KeyedChatStore extends KeyedStore<ChatStore> {
+    constructor(value?: Iterable<readonly [string, ChatStore]> | null | undefined);
+}
+export declare const hasChatContext: () => boolean, getChatContext: () => KeyedChatStore, setChatContext: (value: KeyedChatStore) => KeyedChatStore;
+export {};
+//# sourceMappingURL=chat-context.svelte.d.ts.map

package/dist/chat-context.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-context.svelte.d.ts","sourceRoot":"","sources":["../src/chat-context.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAiB,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE9D,cAAM,SAAS;IACb,QAAQ,cAA2B;IACnC,IAAI,0BAAyB;IAC7B,MAAM,gDAAkE;IACxE,KAAK,oBAAmB;CACzB;AAED,qBAAa,cAAe,SAAQ,UAAU,CAAC,SAAS,CAAC;gBAErD,KAAK,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS;CAIpE;AAED,eAAO,MACO,cAAc,iBACd,cAAc,wBACd,cAAc,2CACa,CAAC"}

package/dist/chat-context.svelte.js

@@ -0,0 +1,13 @@
+import { createContext, KeyedStore } from './utils.svelte.js';
+class ChatStore {
+    messages = $state([]);
+    data = $state();
+    status = $state('ready');
+    error = $state();
+}
+export class KeyedChatStore extends KeyedStore {
+    constructor(value) {
+        super(ChatStore, value);
+    }
+}
+export const { hasContext: hasChatContext, getContext: getChatContext, setContext: setChatContext, } = createContext('Chat');

package/dist/chat.svelte.d.ts

@@ -0,0 +1,75 @@
+import { type UIMessage, type UseChatOptions, type JSONValue, type Message, type CreateMessage, type ChatRequestOptions } from '@ai-sdk/ui-utils';
+export type ChatOptions = Readonly<Omit<UseChatOptions, 'keepLastMessageOnError'> & {
+    /**
+     * Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
+     * Must be at least 1.
+     * A maximum number is required to prevent infinite loops in the case of misconfigured tools.
+     * By default, it's set to 1, which means that only a single LLM call is made.
+     * @default 1
+     */
+    maxSteps?: number;
+}>;
+export type { CreateMessage, Message, UIMessage };
+export declare class Chat {
+    #private;
+    /**
+     * The id of the chat. If not provided through the constructor, a random ID will be generated
+     * using the provided `generateId` function, or a built-in function if not provided.
+     */
+    readonly id: string;
+    /**
+     * Additional data added on the server via StreamData.
+     *
+     * This is writable, so you can use it to transform or clear the chat data.
+     */
+    get data(): JSONValue[] | undefined;
+    set data(value: JSONValue[] | undefined);
+    /**
+     * Hook status:
+     *
+     * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
+     * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
+     * - `ready`: The full response has been received and processed; a new user message can be submitted.
+     * - `error`: An error occurred during the API request, preventing successful completion.
+     */
+    get status(): "submitted" | "streaming" | "ready" | "error";
+    /** The error object of the API request */
+    get error(): Error | undefined;
+    /** The current value of the input. Writable, so it can be bound to form inputs. */
+    input: string;
+    /**
+     * Current messages in the chat.
+     *
+     * This is writable, which is useful when you want to edit the messages on the client, and then
+     * trigger {@link reload} to regenerate the AI response.
+     */
+    get messages(): UIMessage[];
+    set messages(value: Message[]);
+    constructor(options?: ChatOptions);
+    /**
+     * Append a user message to the chat list. This triggers the API call to fetch
+     * the assistant's response.
+     * @param message The message to append
+     * @param options Additional options to pass to the API call
+     */
+    append: (message: Message | CreateMessage, { data, headers, body, experimental_attachments }?: ChatRequestOptions) => Promise<void>;
+    /**
+     * Reload the last AI chat response for the given chat history. If the last
+     * message isn't from the assistant, it will request the API to generate a
+     * new response.
+     */
+    reload: ({ data, headers, body }?: ChatRequestOptions) => Promise<void>;
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop: () => void;
+    /** Form submission handler to automatically reset input and append a user message */
+    handleSubmit: (event?: {
+        preventDefault?: () => void;
+    }, options?: ChatRequestOptions) => Promise<void>;
+    addToolResult: ({ toolCallId, result, }: {
+        toolCallId: string;
+        result: unknown;
+    }) => Promise<void>;
+}
+//# sourceMappingURL=chat.svelte.d.ts.map

package/dist/chat.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.svelte.d.ts","sourceRoot":"","sources":["../src/chat.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,SAAS,EAKd,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAKxB,MAAM,kBAAkB,CAAC;AAQ1B,MAAM,MAAM,WAAW,GAAG,QAAQ,CAChC,IAAI,CAAC,cAAc,EAAE,wBAAwB,CAAC,GAAG;IAC/C;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CACF,CAAC;AAEF,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;AAElD,qBAAa,IAAI;;IAOf;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAoD;IAI/D;;;;OAIG;IACH,IAAI,IAAI,IAGQ,SAAS,EAAE,GAAG,SAAS,CADtC;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS,EAEtC;IAED;;;;;;;OAOG;IACH,IAAI,MAAM,kDAET;IAED,0CAA0C;IAC1C,IAAI,KAAK,sBAER;IAED,mFAAmF;IACnF,KAAK,SAAqB;IAE1B;;;;;OAKG;IACH,IAAI,QAAQ,IAAI,SAAS,EAAE,CAE1B;IACD,IAAI,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,EAE5B;gBAEW,OAAO,GAAE,WAAgB;IAYrC;;;;;OAKG;IACH,MAAM,YACK,OAAO,GAAG,aAAa,sDACmB,kBAAkB,mBAgBrE;IAEF;;;;OAIG;IACH,MAAM,6BAAmC,kBAAkB,mBAezD;IAEF;;OAEG;IACH,IAAI,aASF;IAEF,qFAAqF;IACrF,YAAY,WACF;QAAE,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;KAAE,YAC9B,kBAAkB,mBA6B3B;IAEF,aAAa,4BAGV;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;KACjB,mBAWC;CAmHH"}

package/dist/chat.svelte.js

@@ -0,0 +1,244 @@
+import { fillMessageParts, generateId, extractMaxToolInvocationStep, callChatApi, shouldResubmitMessages, prepareAttachmentsForRequest, getMessageParts, updateToolCallResult, isAssistantMessageWithCompletedToolCalls, } from '@ai-sdk/ui-utils';
+import { isAbortError } from '@ai-sdk/provider-utils';
+import { KeyedChatStore, getChatContext, hasChatContext, } from './chat-context.svelte.js';
+export class Chat {
+    #options = {};
+    #api = $derived(this.#options.api ?? '/api/chat');
+    #generateId = $derived(this.#options.generateId ?? generateId);
+    #maxSteps = $derived(this.#options.maxSteps ?? 1);
+    #streamProtocol = $derived(this.#options.streamProtocol ?? 'data');
+    #keyedStore = $state();
+    /**
+     * The id of the chat. If not provided through the constructor, a random ID will be generated
+     * using the provided `generateId` function, or a built-in function if not provided.
+     */
+    id = $derived(this.#options.id ?? this.#generateId());
+    #store = $derived(this.#keyedStore.get(this.id));
+    #abortController;
+    /**
+     * Additional data added on the server via StreamData.
+     *
+     * This is writable, so you can use it to transform or clear the chat data.
+     */
+    get data() {
+        return this.#store.data;
+    }
+    set data(value) {
+        this.#store.data = value;
+    }
+    /**
+     * Hook status:
+     *
+     * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
+     * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
+     * - `ready`: The full response has been received and processed; a new user message can be submitted.
+     * - `error`: An error occurred during the API request, preventing successful completion.
+     */
+    get status() {
+        return this.#store.status;
+    }
+    /** The error object of the API request */
+    get error() {
+        return this.#store.error;
+    }
+    /** The current value of the input. Writable, so it can be bound to form inputs. */
+    input = $state();
+    /**
+     * Current messages in the chat.
+     *
+     * This is writable, which is useful when you want to edit the messages on the client, and then
+     * trigger {@link reload} to regenerate the AI response.
+     */
+    get messages() {
+        return this.#store.messages;
+    }
+    set messages(value) {
+        this.#store.messages = fillMessageParts(value);
+    }
+    constructor(options = {}) {
+        if (hasChatContext()) {
+            this.#keyedStore = getChatContext();
+        }
+        else {
+            this.#keyedStore = new KeyedChatStore();
+        }
+        this.#options = options;
+        this.messages = options.initialMessages ?? [];
+        this.input = options.initialInput ?? '';
+    }
+    /**
+     * Append a user message to the chat list. This triggers the API call to fetch
+     * the assistant's response.
+     * @param message The message to append
+     * @param options Additional options to pass to the API call
+     */
+    append = async (message, { data, headers, body, experimental_attachments } = {}) => {
+        const attachmentsForRequest = await prepareAttachmentsForRequest(experimental_attachments);
+        const messages = this.messages.concat({
+            ...message,
+            id: message.id ?? generateId(),
+            createdAt: message.createdAt ?? new Date(),
+            experimental_attachments: attachmentsForRequest.length > 0 ? attachmentsForRequest : undefined,
+            parts: getMessageParts(message),
+        });
+        return this.#triggerRequest({ messages, headers, body, data });
+    };
+    /**
+     * Reload the last AI chat response for the given chat history. If the last
+     * message isn't from the assistant, it will request the API to generate a
+     * new response.
+     */
+    reload = async ({ data, headers, body } = {}) => {
+        if (this.messages.length === 0) {
+            return;
+        }
+        const lastMessage = this.messages[this.messages.length - 1];
+        await this.#triggerRequest({
+            messages: lastMessage.role === 'assistant'
+                ? this.messages.slice(0, -1)
+                : this.messages,
+            headers,
+            body,
+            data,
+        });
+    };
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop = () => {
+        try {
+            this.#abortController?.abort();
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            this.#store.status = 'ready';
+            this.#abortController = undefined;
+        }
+    };
+    /** Form submission handler to automatically reset input and append a user message */
+    handleSubmit = async (event, options = {}) => {
+        event?.preventDefault?.();
+        if (!this.input && !options.allowEmptySubmit)
+            return;
+        const attachmentsForRequest = await prepareAttachmentsForRequest(options.experimental_attachments);
+        const messages = this.messages.concat({
+            id: generateId(),
+            createdAt: new Date(),
+            role: 'user',
+            content: this.input,
+            experimental_attachments: attachmentsForRequest.length > 0 ? attachmentsForRequest : undefined,
+            parts: [{ type: 'text', text: this.input }],
+        });
+        const chatRequest = {
+            messages,
+            headers: options.headers,
+            body: options.body,
+            data: options.data,
+        };
+        const request = this.#triggerRequest(chatRequest);
+        this.input = '';
+        await request;
+    };
+    addToolResult = async ({ toolCallId, result, }) => {
+        updateToolCallResult({
+            messages: this.messages,
+            toolCallId,
+            toolResult: result,
+        });
+        const lastMessage = this.messages[this.messages.length - 1];
+        if (isAssistantMessageWithCompletedToolCalls(lastMessage)) {
+            await this.#triggerRequest({ messages: this.messages });
+        }
+    };
+    #triggerRequest = async (chatRequest) => {
+        this.#store.status = 'submitted';
+        this.#store.error = undefined;
+        const messages = fillMessageParts(chatRequest.messages);
+        const messageCount = messages.length;
+        const maxStep = extractMaxToolInvocationStep(messages[messages.length - 1]?.toolInvocations);
+        try {
+            const abortController = new AbortController();
+            this.#abortController = abortController;
+            // Optimistically update messages
+            this.messages = messages;
+            const constructedMessagesPayload = this.#options.sendExtraMessageFields
+                ? messages
+                : messages.map(({ role, content, experimental_attachments, data, annotations, toolInvocations, parts, }) => ({
+                    role,
+                    content,
+                    ...(experimental_attachments !== undefined && {
+                        experimental_attachments,
+                    }),
+                    ...(data !== undefined && { data }),
+                    ...(annotations !== undefined && { annotations }),
+                    ...(toolInvocations !== undefined && { toolInvocations }),
+                    ...(parts !== undefined && { parts }),
+                }));
+            const existingData = this.data ?? [];
+            await callChatApi({
+                api: this.#api,
+                body: {
+                    id: this.id,
+                    messages: constructedMessagesPayload,
+                    data: chatRequest.data,
+                    ...$state.snapshot(this.#options.body),
+                    ...chatRequest.body,
+                },
+                streamProtocol: this.#streamProtocol,
+                credentials: this.#options.credentials,
+                headers: {
+                    ...this.#options.headers,
+                    ...chatRequest.headers,
+                },
+                abortController: () => abortController,
+                restoreMessagesOnFailure: () => { },
+                onResponse: this.#options.onResponse,
+                onUpdate: ({ message, data, replaceLastMessage }) => {
+                    this.#store.status = 'streaming';
+                    this.messages = messages;
+                    if (replaceLastMessage) {
+                        this.messages[this.messages.length - 1] = message;
+                    }
+                    else {
+                        this.messages.push(message);
+                    }
+                    if (data?.length) {
+                        this.data = existingData;
+                        this.data.push(...data);
+                    }
+                },
+                onToolCall: this.#options.onToolCall,
+                onFinish: this.#options.onFinish,
+                generateId: this.#generateId,
+                fetch: this.#options.fetch,
+                // callChatApi calls structuredClone on the message
+                lastMessage: $state.snapshot(this.messages[this.messages.length - 1]),
+            });
+            this.#abortController = undefined;
+            this.#store.status = 'ready';
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                return;
+            }
+            const coalescedError = error instanceof Error ? error : new Error(String(error));
+            if (this.#options.onError) {
+                this.#options.onError(coalescedError);
+            }
+            this.#store.status = 'error';
+            this.#store.error = coalescedError;
+        }
+        // auto-submit when all tool calls in the last assistant message have results
+        // and assistant has not answered yet
+        if (shouldResubmitMessages({
+            originalMaxToolInvocationStep: maxStep,
+            originalMessageCount: messageCount,
+            maxSteps: this.#maxSteps,
+            messages: this.messages,
+        })) {
+            await this.#triggerRequest({ messages: this.messages });
+        }
+    };
+}

package/dist/completion-context.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { JSONValue } from '@ai-sdk/ui-utils';
+import { SvelteMap } from 'svelte/reactivity';
+import { KeyedStore } from './utils.svelte.js';
+declare class CompletionStore {
+    completions: SvelteMap<string, string>;
+    data: JSONValue[];
+    loading: boolean;
+    error: Error | undefined;
+}
+export declare class KeyedCompletionStore extends KeyedStore<CompletionStore> {
+    constructor(value?: Iterable<readonly [string, CompletionStore]> | null | undefined);
+}
+export declare const hasCompletionContext: () => boolean, getCompletionContext: () => KeyedCompletionStore, setCompletionContext: (value: KeyedCompletionStore) => KeyedCompletionStore;
+export {};
+//# sourceMappingURL=completion-context.svelte.d.ts.map

package/dist/completion-context.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-context.svelte.d.ts","sourceRoot":"","sources":["../src/completion-context.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAiB,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE9D,cAAM,eAAe;IACnB,WAAW,4BAAmC;IAC9C,IAAI,cAA2B;IAC/B,OAAO,UAAiB;IACxB,KAAK,oBAAmB;CACzB;AAED,qBAAa,oBAAqB,SAAQ,UAAU,CAAC,eAAe,CAAC;gBAEjE,KAAK,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS;CAI1E;AAED,eAAO,MACO,oBAAoB,iBACpB,oBAAoB,8BACpB,oBAAoB,uDACmB,CAAC"}

package/dist/completion-context.svelte.js

@@ -0,0 +1,14 @@
+import { SvelteMap } from 'svelte/reactivity';
+import { createContext, KeyedStore } from './utils.svelte.js';
+class CompletionStore {
+    completions = new SvelteMap();
+    data = $state([]);
+    loading = $state(false);
+    error = $state();
+}
+export class KeyedCompletionStore extends KeyedStore {
+    constructor(value) {
+        super(CompletionStore, value);
+    }
+}
+export const { hasContext: hasCompletionContext, getContext: getCompletionContext, setContext: setCompletionContext, } = createContext('Completion');

package/dist/completion.svelte.d.ts

@@ -0,0 +1,37 @@
+import { type UseCompletionOptions, type JSONValue, type RequestOptions } from '@ai-sdk/ui-utils';
+export type CompletionOptions = Readonly<UseCompletionOptions>;
+export declare class Completion {
+    #private;
+    /** The current completion result */
+    get completion(): string;
+    set completion(value: string);
+    /**
+     * Additional data added on the server via StreamData.
+     *
+     * This is writable, so you can use it to transform or clear the chat data.
+     */
+    get data(): JSONValue[];
+    set data(value: JSONValue[]);
+    /** The error object of the API request */
+    get error(): Error | undefined;
+    /** The current value of the input. Writable, so it can be bound to form inputs. */
+    input: string;
+    /**
+     * Flag that indicates whether an API request is in progress.
+     */
+    get loading(): boolean;
+    constructor(options?: CompletionOptions);
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop: () => void;
+    /**
+     * Send a new prompt to the API endpoint and update the completion state.
+     */
+    complete: (prompt: string, options?: RequestOptions) => Promise<string | null | undefined>;
+    /** Form submission handler to automatically reset input and call the completion API */
+    handleSubmit: (event?: {
+        preventDefault?: () => void;
+    }) => Promise<void>;
+}
+//# sourceMappingURL=completion.svelte.d.ts.map

package/dist/completion.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.svelte.d.ts","sourceRoot":"","sources":["../src/completion.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAC;AAO1B,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAE/D,qBAAa,UAAU;;IASrB,oCAAoC;IACpC,IAAI,UAAU,IAAI,MAAM,CAEvB;IACD,IAAI,UAAU,CAAC,KAAK,EAAE,MAAM,EAE3B;IAED;;;;OAIG;IACH,IAAI,IAAI,IAGQ,SAAS,EAAE,CAD1B;IACD,IAAI,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,EAE1B;IAED,0CAA0C;IAC1C,IAAI,KAAK,sBAER;IAED,mFAAmF;IACnF,KAAK,SAAqB;IAE1B;;OAEG;IACH,IAAI,OAAO,YAEV;gBAEW,OAAO,GAAE,iBAAsB;IAY3C;;OAEG;IACH,IAAI,aASF;IAEF;;OAEG;IACH,QAAQ,WAAkB,MAAM,YAAY,cAAc,wCAClB;IAExC,uFAAuF;IACvF,YAAY,WAAkB;QAAE,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;KAAE,mBAK3D;CAmCH"}

package/dist/completion.svelte.js

@@ -0,0 +1,111 @@
+import { generateId, callCompletionApi, } from '@ai-sdk/ui-utils';
+import { KeyedCompletionStore, getCompletionContext, hasCompletionContext, } from './completion-context.svelte.js';
+export class Completion {
+    #options = {};
+    #api = $derived(this.#options.api ?? '/api/completion');
+    #id = $derived(this.#options.id ?? generateId());
+    #streamProtocol = $derived(this.#options.streamProtocol ?? 'data');
+    #keyedStore = $state();
+    #store = $derived(this.#keyedStore.get(this.#id));
+    #abortController;
+    /** The current completion result */
+    get completion() {
+        return this.#store.completions.get(this.#id) ?? '';
+    }
+    set completion(value) {
+        this.#store.completions.set(this.#id, value);
+    }
+    /**
+     * Additional data added on the server via StreamData.
+     *
+     * This is writable, so you can use it to transform or clear the chat data.
+     */
+    get data() {
+        return this.#store.data;
+    }
+    set data(value) {
+        this.#store.data = value;
+    }
+    /** The error object of the API request */
+    get error() {
+        return this.#store.error;
+    }
+    /** The current value of the input. Writable, so it can be bound to form inputs. */
+    input = $state();
+    /**
+     * Flag that indicates whether an API request is in progress.
+     */
+    get loading() {
+        return this.#store.loading;
+    }
+    constructor(options = {}) {
+        if (hasCompletionContext()) {
+            this.#keyedStore = getCompletionContext();
+        }
+        else {
+            this.#keyedStore = new KeyedCompletionStore();
+        }
+        this.#options = options;
+        this.completion = options.initialCompletion ?? '';
+        this.input = options.initialInput ?? '';
+    }
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop = () => {
+        try {
+            this.#abortController?.abort();
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            this.#store.loading = false;
+            this.#abortController = undefined;
+        }
+    };
+    /**
+     * Send a new prompt to the API endpoint and update the completion state.
+     */
+    complete = async (prompt, options) => this.#triggerRequest(prompt, options);
+    /** Form submission handler to automatically reset input and call the completion API */
+    handleSubmit = async (event) => {
+        event?.preventDefault?.();
+        if (this.input) {
+            await this.complete(this.input);
+        }
+    };
+    #triggerRequest = async (prompt, options) => {
+        return callCompletionApi({
+            api: this.#api,
+            prompt,
+            credentials: this.#options.credentials,
+            headers: { ...this.#options.headers, ...options?.headers },
+            body: {
+                ...this.#options.body,
+                ...options?.body,
+            },
+            streamProtocol: this.#streamProtocol,
+            fetch: this.#options.fetch,
+            // throttle streamed ui updates:
+            setCompletion: completion => {
+                this.completion = completion;
+            },
+            onData: data => {
+                this.data.push(...data);
+            },
+            setLoading: loading => {
+                this.#store.loading = loading;
+            },
+            setError: error => {
+                this.#store.error = error;
+            },
+            setAbortController: abortController => {
+                this.#abortController = abortController ?? undefined;
+            },
+            onResponse: this.#options.onResponse,
+            onFinish: this.#options.onFinish,
+            onError: this.#options.onError,
+        });
+    };
+}

package/dist/context-provider.d.ts

@@ -0,0 +1,2 @@
+export declare function createAIContext(): void;
+//# sourceMappingURL=context-provider.d.ts.map

package/dist/context-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-provider.d.ts","sourceRoot":"","sources":["../src/context-provider.ts"],"names":[],"mappings":"AAUA,wBAAgB,eAAe,SAS9B"}

package/dist/context-provider.js

@@ -0,0 +1,11 @@
+import { KeyedChatStore, setChatContext } from './chat-context.svelte.js';
+import { KeyedCompletionStore, setCompletionContext, } from './completion-context.svelte.js';
+import { KeyedStructuredObjectStore, setStructuredObjectContext, } from './structured-object-context.svelte.js';
+export function createAIContext() {
+    const chatStore = new KeyedChatStore();
+    setChatContext(chatStore);
+    const completionStore = new KeyedCompletionStore();
+    setCompletionContext(completionStore);
+    const objectStore = new KeyedStructuredObjectStore();
+    setStructuredObjectContext(objectStore);
+}