@ai-sdk/svelte 0.0.43 → 0.0.45

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/svelte
 
+## 0.0.45
+
+### Patch Changes
+
+- Updated dependencies [aa2dc58]
+  - @ai-sdk/ui-utils@0.0.40
+
+## 0.0.44
+
+### Patch Changes
+
+- @ai-sdk/provider-utils@1.0.17
+- @ai-sdk/ui-utils@0.0.39
+
 ## 0.0.43
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/svelte",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -14,9 +14,13 @@
       "require": "./dist/index.js"
     }
   },
+  "files": [
+    "dist/**/*",
+    "CHANGELOG.md"
+  ],
   "dependencies": {
-    "@ai-sdk/provider-utils": "1.0.16",
-    "@ai-sdk/ui-utils": "0.0.38",
+    "@ai-sdk/provider-utils": "1.0.17",
+    "@ai-sdk/ui-utils": "0.0.40",
     "sswr": "2.1.0"
   },
   "devDependencies": {

package/.eslintrc.js

@@ -1,4 +0,0 @@
-module.exports = {
-  root: true,
-  extends: ['vercel-ai'],
-};

package/.turbo/turbo-build.log

@@ -1,21 +0,0 @@
-
-> @ai-sdk/svelte@0.0.43 build /home/runner/work/ai/ai/packages/svelte
-> tsup
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v7.2.0
-CLI Using tsup config: /home/runner/work/ai/ai/packages/svelte/tsup.config.ts
-CLI Target: es2018
-CJS Build start
-ESM Build start
-CJS dist/index.js     19.63 KB
-CJS dist/index.js.map 39.25 KB
-CJS ⚡️ Build success in 40ms
-ESM dist/index.mjs     17.87 KB
-ESM dist/index.mjs.map 39.11 KB
-ESM ⚡️ Build success in 52ms
-DTS Build start
-DTS ⚡️ Build success in 4881ms
-DTS dist/index.d.ts  6.53 KB
-DTS dist/index.d.mts 6.53 KB

package/.turbo/turbo-clean.log

@@ -1,4 +0,0 @@
-
-> @ai-sdk/svelte@0.0.43 clean /home/runner/work/ai/ai/packages/svelte
-> rm -rf dist
-

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './use-chat';
-export * from './use-completion';
-export * from './use-assistant';

package/src/package.json

@@ -1,10 +0,0 @@
-{
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "exports": "./dist/index.mjs",
-  "private": true,
-  "peerDependencies": {
-    "svelte": "*"
-  }
-}

package/src/use-assistant.ts

@@ -1,262 +0,0 @@
-import { isAbortError } from '@ai-sdk/provider-utils';
-import type {
-  AssistantStatus,
-  CreateMessage,
-  Message,
-  UseAssistantOptions,
-} from '@ai-sdk/ui-utils';
-import { generateId, readDataStream } from '@ai-sdk/ui-utils';
-import { Readable, Writable, get, writable } from 'svelte/store';
-
-// use function to allow for mocking in tests:
-const getOriginalFetch = () => fetch;
-
-let uniqueId = 0;
-
-const store: Record<string, any> = {};
-
-export type UseAssistantHelpers = {
-  /**
-   * The current array of chat messages.
-   */
-  messages: Readable<Message[]>;
-
-  /**
-   * Update the message store with a new array of messages.
-   */
-  setMessages: (messages: Message[]) => void;
-
-  /**
-   * The current thread ID.
-   */
-  threadId: Readable<string | undefined>;
-
-  /**
-   * The current value of the input field.
-   */
-  input: Writable<string>;
-
-  /**
-   * 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 requestOptions Additional options to pass to the API call
-   */
-  append: (
-    message: Message | CreateMessage,
-    requestOptions?: { data?: Record<string, string> },
-  ) => Promise<void>;
-
-  /**
-Abort the current request immediately, keep the generated tokens if any.
-   */
-  stop: () => void;
-
-  /**
-   * Form submission handler that automatically resets the input field and appends a user message.
-   */
-  submitMessage: (
-    event?: { preventDefault?: () => void },
-    requestOptions?: { data?: Record<string, string> },
-  ) => Promise<void>;
-
-  /**
-   * The current status of the assistant. This can be used to show a loading indicator.
-   */
-  status: Readable<AssistantStatus>;
-
-  /**
-   * The error thrown during the assistant message processing, if any.
-   */
-  error: Readable<undefined | Error>;
-};
-
-export function useAssistant({
-  api,
-  threadId: threadIdParam,
-  credentials,
-  headers,
-  body,
-  onError,
-  fetch,
-}: UseAssistantOptions): UseAssistantHelpers {
-  // Generate a unique thread ID
-  const threadIdStore = writable<string | undefined>(threadIdParam);
-
-  // Initialize message, input, status, and error stores
-  const key = `${api}|${threadIdParam ?? `completion-${uniqueId++}`}`;
-  const messages = writable<Message[]>(store[key] || []);
-  const input = writable('');
-  const status = writable<AssistantStatus>('awaiting_message');
-  const error = writable<undefined | Error>(undefined);
-
-  // To manage aborting the current fetch request
-  let abortController: AbortController | null = null;
-
-  // Update the message store
-  const mutateMessages = (newMessages: Message[]) => {
-    store[key] = newMessages;
-    messages.set(newMessages);
-  };
-
-  // Function to handle API calls and state management
-  async function append(
-    message: Message | CreateMessage,
-    requestOptions?: { data?: Record<string, string> },
-  ) {
-    status.set('in_progress');
-    abortController = new AbortController(); // Initialize a new AbortController
-
-    // Add the new message to the existing array
-    mutateMessages([
-      ...get(messages),
-      { ...message, id: message.id ?? generateId() },
-    ]);
-
-    input.set('');
-
-    try {
-      const actualFetch = fetch ?? getOriginalFetch();
-      const response = await actualFetch(api, {
-        method: 'POST',
-        credentials,
-        signal: abortController.signal,
-        headers: { 'Content-Type': 'application/json', ...headers },
-        body: JSON.stringify({
-          ...body,
-          // always use user-provided threadId when available:
-          threadId: threadIdParam ?? get(threadIdStore) ?? null,
-          message: message.content,
-
-          // optional request data:
-          data: requestOptions?.data,
-        }),
-      });
-
-      if (!response.ok) {
-        throw new Error(
-          (await response.text()) ?? 'Failed to fetch the assistant response.',
-        );
-      }
-
-      if (response.body == null) {
-        throw new Error('The response body is empty.');
-      }
-
-      // Read the streamed response data
-      for await (const { type, value } of readDataStream(
-        response.body.getReader(),
-      )) {
-        switch (type) {
-          case 'assistant_message': {
-            mutateMessages([
-              ...get(messages),
-              {
-                id: value.id,
-                role: value.role,
-                content: value.content[0].text.value,
-              },
-            ]);
-            break;
-          }
-
-          case 'text': {
-            // text delta - add to last message:
-            mutateMessages(
-              get(messages).map((msg, index, array) => {
-                if (index === array.length - 1) {
-                  return { ...msg, content: msg.content + value };
-                }
-                return msg;
-              }),
-            );
-            break;
-          }
-
-          case 'data_message': {
-            mutateMessages([
-              ...get(messages),
-              {
-                id: value.id ?? generateId(),
-                role: 'data',
-                content: '',
-                data: value.data,
-              },
-            ]);
-            break;
-          }
-
-          case 'assistant_control_data': {
-            threadIdStore.set(value.threadId);
-
-            mutateMessages(
-              get(messages).map((msg, index, array) => {
-                if (index === array.length - 1) {
-                  return { ...msg, id: value.messageId };
-                }
-                return msg;
-              }),
-            );
-
-            break;
-          }
-
-          case 'error': {
-            error.set(new Error(value));
-            break;
-          }
-        }
-      }
-    } catch (err) {
-      // Ignore abort errors as they are expected when the user cancels the request:
-      if (isAbortError(error) && abortController?.signal?.aborted) {
-        abortController = null;
-        return;
-      }
-
-      if (onError && err instanceof Error) {
-        onError(err);
-      }
-
-      error.set(err as Error);
-    } finally {
-      abortController = null;
-      status.set('awaiting_message');
-    }
-  }
-
-  function setMessages(messages: Message[]) {
-    mutateMessages(messages);
-  }
-
-  function stop() {
-    if (abortController) {
-      abortController.abort();
-      abortController = null;
-    }
-  }
-
-  // Function to handle form submission
-  async function submitMessage(
-    event?: { preventDefault?: () => void },
-    requestOptions?: { data?: Record<string, string> },
-  ) {
-    event?.preventDefault?.();
-    const inputValue = get(input);
-    if (!inputValue) return;
-
-    await append({ role: 'user', content: inputValue }, requestOptions);
-  }
-
-  return {
-    messages,
-    error,
-    threadId: threadIdStore,
-    input,
-    append,
-    submitMessage,
-    status,
-    setMessages,
-    stop,
-  };
-}

package/src/use-chat.ts

@@ -1,574 +0,0 @@
-import { FetchFunction } from '@ai-sdk/provider-utils';
-import type {
-  ChatRequest,
-  ChatRequestOptions,
-  CreateMessage,
-  IdGenerator,
-  JSONValue,
-  Message,
-  UseChatOptions as SharedUseChatOptions,
-} from '@ai-sdk/ui-utils';
-import {
-  callChatApi,
-  generateId as generateIdFunc,
-  processChatStream,
-} from '@ai-sdk/ui-utils';
-import { useSWR } from 'sswr';
-import { Readable, Writable, derived, get, writable } from 'svelte/store';
-export type { CreateMessage, Message };
-
-export type UseChatOptions = SharedUseChatOptions & {
-  /**
-  Maximal number of automatic roundtrips for tool calls.
-
-  An automatic tool call roundtrip is a call to the server with the
-  tool call results when all tool calls in the last assistant
-  message have results.
-
-  A maximum number is required to prevent infinite loops in the
-  case of misconfigured tools.
-
-  By default, it's set to 0, which will disable the feature.
-  */
-  maxToolRoundtrips?: number;
-};
-
-export type UseChatHelpers = {
-  /** Current messages in the chat */
-  messages: Readable<Message[]>;
-  /** The error object of the API request */
-  error: Readable<undefined | Error>;
-  /**
-   * 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 chatRequestOptions Additional options to pass to the API call
-   */
-  append: (
-    message: Message | CreateMessage,
-    chatRequestOptions?: ChatRequestOptions,
-  ) => Promise<string | null | undefined>;
-  /**
-   * 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: (
-    chatRequestOptions?: ChatRequestOptions,
-  ) => Promise<string | null | undefined>;
-  /**
-   * Abort the current request immediately, keep the generated tokens if any.
-   */
-  stop: () => void;
-  /**
-   * Update the `messages` state locally. This is useful when you want to
-   * edit the messages on the client, and then trigger the `reload` method
-   * manually to regenerate the AI response.
-   */
-  setMessages: (
-    messages: Message[] | ((messages: Message[]) => Message[]),
-  ) => void;
-
-  /** The current value of the input */
-  input: Writable<string>;
-  /** Form submission handler to automatically reset input and append a user message  */
-  handleSubmit: (
-    event?: { preventDefault?: () => void },
-    chatRequestOptions?: ChatRequestOptions,
-  ) => void;
-  metadata?: Object;
-  /** Whether the API request is in progress */
-  isLoading: Readable<boolean | undefined>;
-
-  /** Additional data added on the server via StreamData */
-  data: Readable<JSONValue[] | undefined>;
-  /**
-  Maximal number of automatic roundtrips for tool calls.
-
-  An automatic tool call roundtrip is a call to the server with the
-  tool call results when all tool calls in the last assistant
-  message have results.
-
-  A maximum number is required to prevent infinite loops in the
-  case of misconfigured tools.
-
-  By default, it's set to 0, which will disable the feature.
-  */
-  maxToolRoundtrips?: number;
-};
-
-const getStreamedResponse = async (
-  api: string,
-  chatRequest: ChatRequest,
-  mutate: (messages: Message[]) => void,
-  mutateStreamData: (data: JSONValue[] | undefined) => void,
-  existingData: JSONValue[] | undefined,
-  extraMetadata: {
-    credentials?: RequestCredentials;
-    headers?: Record<string, string> | Headers;
-    body?: any;
-  },
-  previousMessages: Message[],
-  abortControllerRef: AbortController | null,
-  generateId: IdGenerator,
-  streamProtocol: UseChatOptions['streamProtocol'],
-  onFinish: UseChatOptions['onFinish'],
-  onResponse: ((response: Response) => void | Promise<void>) | undefined,
-  onToolCall: UseChatOptions['onToolCall'] | undefined,
-  sendExtraMessageFields: boolean | undefined,
-  fetch: FetchFunction | undefined,
-  keepLastMessageOnError: boolean | undefined,
-) => {
-  // Do an optimistic update to the chat state to show the updated messages
-  // immediately.
-  mutate(chatRequest.messages);
-
-  const constructedMessagesPayload = sendExtraMessageFields
-    ? chatRequest.messages
-    : chatRequest.messages.map(
-        ({
-          role,
-          content,
-          name,
-          data,
-          annotations,
-          function_call,
-          tool_calls,
-          tool_call_id,
-          toolInvocations,
-        }) => ({
-          role,
-          content,
-          ...(name !== undefined && { name }),
-          ...(data !== undefined && { data }),
-          ...(annotations !== undefined && { annotations }),
-          ...(toolInvocations !== undefined && { toolInvocations }),
-          // outdated function/tool call handling (TODO deprecate):
-          tool_call_id,
-          ...(function_call !== undefined && { function_call }),
-          ...(tool_calls !== undefined && { tool_calls }),
-        }),
-      );
-
-  return await callChatApi({
-    api,
-    body: {
-      messages: constructedMessagesPayload,
-      data: chatRequest.data,
-      ...extraMetadata.body,
-      ...chatRequest.body,
-      ...(chatRequest.functions !== undefined && {
-        functions: chatRequest.functions,
-      }),
-      ...(chatRequest.function_call !== undefined && {
-        function_call: chatRequest.function_call,
-      }),
-      ...(chatRequest.tools !== undefined && {
-        tools: chatRequest.tools,
-      }),
-      ...(chatRequest.tool_choice !== undefined && {
-        tool_choice: chatRequest.tool_choice,
-      }),
-    },
-    streamProtocol,
-    credentials: extraMetadata.credentials,
-    headers: {
-      ...extraMetadata.headers,
-      ...chatRequest.headers,
-    },
-    abortController: () => abortControllerRef,
-    restoreMessagesOnFailure() {
-      if (!keepLastMessageOnError) {
-        mutate(previousMessages);
-      }
-    },
-    onResponse,
-    onUpdate(merged, data) {
-      mutate([...chatRequest.messages, ...merged]);
-      mutateStreamData([...(existingData || []), ...(data || [])]);
-    },
-    onFinish,
-    generateId,
-    onToolCall,
-    fetch,
-  });
-};
-
-let uniqueId = 0;
-
-const store: Record<string, Message[] | undefined> = {};
-
-/**
-Check if the message is an assistant message with completed tool calls.
-The message must have at least one tool invocation and all tool invocations
-must have a result.
- */
-function isAssistantMessageWithCompletedToolCalls(message: Message) {
-  return (
-    message.role === 'assistant' &&
-    message.toolInvocations &&
-    message.toolInvocations.length > 0 &&
-    message.toolInvocations.every(toolInvocation => 'result' in toolInvocation)
-  );
-}
-
-/**
-Returns the number of trailing assistant messages in the array.
- */
-function countTrailingAssistantMessages(messages: Message[]) {
-  let count = 0;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === 'assistant') {
-      count++;
-    } else {
-      break;
-    }
-  }
-
-  return count;
-}
-
-export function useChat({
-  api = '/api/chat',
-  id,
-  initialMessages = [],
-  initialInput = '',
-  sendExtraMessageFields,
-  experimental_onFunctionCall,
-  experimental_onToolCall,
-  streamMode,
-  streamProtocol,
-  onResponse,
-  onFinish,
-  onError,
-  onToolCall,
-  credentials,
-  headers,
-  body,
-  generateId = generateIdFunc,
-  fetch,
-  keepLastMessageOnError = false,
-  maxToolRoundtrips = 0,
-}: UseChatOptions = {}): UseChatHelpers & {
-  addToolResult: ({
-    toolCallId,
-    result,
-  }: {
-    toolCallId: string;
-    result: any;
-  }) => void;
-} {
-  // streamMode is deprecated, use streamProtocol instead.
-  if (streamMode) {
-    streamProtocol ??= streamMode === 'text' ? 'text' : undefined;
-  }
-
-  // Generate a unique id for the chat if not provided.
-  const chatId = id || `chat-${uniqueId++}`;
-
-  const key = `${api}|${chatId}`;
-  const {
-    data,
-    mutate: originalMutate,
-    isLoading: isSWRLoading,
-  } = useSWR<Message[]>(key, {
-    fetcher: () => store[key] || initialMessages,
-    fallbackData: initialMessages,
-  });
-
-  const streamData = writable<JSONValue[] | undefined>(undefined);
-
-  const loading = writable<boolean>(false);
-
-  // Force the `data` to be `initialMessages` if it's `undefined`.
-  data.set(initialMessages);
-
-  const mutate = (data: Message[]) => {
-    store[key] = data;
-    return originalMutate(data);
-  };
-
-  // Because of the `fallbackData` option, the `data` will never be `undefined`.
-  const messages = data as Writable<Message[]>;
-
-  // Abort controller to cancel the current API call.
-  let abortController: AbortController | null = null;
-
-  const extraMetadata = {
-    credentials,
-    headers,
-    body,
-  };
-
-  const error = writable<undefined | Error>(undefined);
-
-  // Actual mutation hook to send messages to the API endpoint and update the
-  // chat state.
-  async function triggerRequest(chatRequest: ChatRequest) {
-    const messagesSnapshot = get(messages);
-    const messageCount = messagesSnapshot.length;
-
-    try {
-      error.set(undefined);
-      loading.set(true);
-      abortController = new AbortController();
-
-      await processChatStream({
-        getStreamedResponse: () =>
-          getStreamedResponse(
-            api,
-            chatRequest,
-            mutate,
-            data => {
-              streamData.set(data);
-            },
-            get(streamData),
-            extraMetadata,
-            get(messages),
-            abortController,
-            generateId,
-            streamProtocol,
-            onFinish,
-            onResponse,
-            onToolCall,
-            sendExtraMessageFields,
-            fetch,
-            keepLastMessageOnError,
-          ),
-        experimental_onFunctionCall,
-        experimental_onToolCall,
-        updateChatRequest: chatRequestParam => {
-          chatRequest = chatRequestParam;
-        },
-        getCurrentMessages: () => get(messages),
-      });
-
-      abortController = null;
-    } catch (err) {
-      // Ignore abort errors as they are expected.
-      if ((err as any).name === 'AbortError') {
-        abortController = null;
-        return null;
-      }
-
-      if (onError && err instanceof Error) {
-        onError(err);
-      }
-
-      error.set(err as Error);
-    } finally {
-      loading.set(false);
-    }
-
-    // auto-submit when all tool calls in the last assistant message have results:
-    const newMessagesSnapshot = get(messages);
-    const lastMessage = newMessagesSnapshot[newMessagesSnapshot.length - 1];
-
-    if (
-      // ensure we actually have new messages (to prevent infinite loops in case of errors):
-      newMessagesSnapshot.length > messageCount &&
-      // ensure there is a last message:
-      lastMessage != null &&
-      // check if the feature is enabled:
-      maxToolRoundtrips > 0 &&
-      // check that roundtrip is possible:
-      isAssistantMessageWithCompletedToolCalls(lastMessage) &&
-      // limit the number of automatic roundtrips:
-      countTrailingAssistantMessages(newMessagesSnapshot) <= maxToolRoundtrips
-    ) {
-      await triggerRequest({ messages: newMessagesSnapshot });
-    }
-  }
-
-  const append: UseChatHelpers['append'] = async (
-    message: Message | CreateMessage,
-    {
-      options,
-      functions,
-      function_call,
-      tools,
-      tool_choice,
-      data,
-      headers,
-      body,
-    }: ChatRequestOptions = {},
-  ) => {
-    if (!message.id) {
-      message.id = generateId();
-    }
-
-    const requestOptions = {
-      headers: headers ?? options?.headers,
-      body: body ?? options?.body,
-    };
-
-    const chatRequest: ChatRequest = {
-      messages: get(messages).concat(message as Message),
-      options: requestOptions,
-      headers: requestOptions.headers,
-      body: requestOptions.body,
-      data,
-      ...(functions !== undefined && { functions }),
-      ...(function_call !== undefined && { function_call }),
-      ...(tools !== undefined && { tools }),
-      ...(tool_choice !== undefined && { tool_choice }),
-    };
-    return triggerRequest(chatRequest);
-  };
-
-  const reload: UseChatHelpers['reload'] = async ({
-    options,
-    functions,
-    function_call,
-    tools,
-    tool_choice,
-    data,
-    headers,
-    body,
-  }: ChatRequestOptions = {}) => {
-    const messagesSnapshot = get(messages);
-    if (messagesSnapshot.length === 0) return null;
-
-    const requestOptions = {
-      headers: headers ?? options?.headers,
-      body: body ?? options?.body,
-    };
-
-    // Remove last assistant message and retry last user message.
-    const lastMessage = messagesSnapshot.at(-1);
-    if (lastMessage?.role === 'assistant') {
-      const chatRequest: ChatRequest = {
-        messages: messagesSnapshot.slice(0, -1),
-        options: requestOptions,
-        headers: requestOptions.headers,
-        body: requestOptions.body,
-        data,
-        ...(functions !== undefined && { functions }),
-        ...(function_call !== undefined && { function_call }),
-        ...(tools !== undefined && { tools }),
-        ...(tool_choice !== undefined && { tool_choice }),
-      };
-
-      return triggerRequest(chatRequest);
-    }
-
-    const chatRequest: ChatRequest = {
-      messages: messagesSnapshot,
-      options: requestOptions,
-      headers: requestOptions.headers,
-      body: requestOptions.body,
-      data,
-    };
-
-    return triggerRequest(chatRequest);
-  };
-
-  const stop = () => {
-    if (abortController) {
-      abortController.abort();
-      abortController = null;
-    }
-  };
-
-  const setMessages = (
-    messagesArg: Message[] | ((messages: Message[]) => Message[]),
-  ) => {
-    if (typeof messagesArg === 'function') {
-      messagesArg = messagesArg(get(messages));
-    }
-
-    mutate(messagesArg);
-  };
-
-  const input = writable(initialInput);
-
-  const handleSubmit = (
-    event?: { preventDefault?: () => void },
-    options: ChatRequestOptions = {},
-  ) => {
-    event?.preventDefault?.();
-    const inputValue = get(input);
-
-    if (!inputValue && !options.allowEmptySubmit) return;
-
-    const requestOptions = {
-      headers: options.headers ?? options.options?.headers,
-      body: options.body ?? options.options?.body,
-    };
-
-    const chatRequest: ChatRequest = {
-      messages:
-        !inputValue && options.allowEmptySubmit
-          ? get(messages)
-          : get(messages).concat({
-              id: generateId(),
-              content: inputValue,
-              role: 'user',
-              createdAt: new Date(),
-            } as Message),
-      options: requestOptions,
-      body: requestOptions.body,
-      headers: requestOptions.headers,
-      data: options.data,
-    };
-
-    triggerRequest(chatRequest);
-
-    input.set('');
-  };
-
-  const isLoading = derived(
-    [isSWRLoading, loading],
-    ([$isSWRLoading, $loading]) => {
-      return $isSWRLoading || $loading;
-    },
-  );
-
-  const addToolResult = ({
-    toolCallId,
-    result,
-  }: {
-    toolCallId: string;
-    result: any;
-  }) => {
-    const messagesSnapshot = get(messages) ?? [];
-    const updatedMessages = messagesSnapshot.map((message, index, arr) =>
-      // update the tool calls in the last assistant message:
-      index === arr.length - 1 &&
-      message.role === 'assistant' &&
-      message.toolInvocations
-        ? {
-            ...message,
-            toolInvocations: message.toolInvocations.map(toolInvocation =>
-              toolInvocation.toolCallId === toolCallId
-                ? { ...toolInvocation, result }
-                : toolInvocation,
-            ),
-          }
-        : message,
-    );
-
-    messages.set(updatedMessages);
-
-    // auto-submit when all tool calls in the last assistant message have results:
-    const lastMessage = updatedMessages[updatedMessages.length - 1];
-
-    if (isAssistantMessageWithCompletedToolCalls(lastMessage)) {
-      triggerRequest({ messages: updatedMessages });
-    }
-  };
-
-  return {
-    messages,
-    error,
-    append,
-    reload,
-    stop,
-    setMessages,
-    input,
-    handleSubmit,
-    isLoading,
-    data: streamData,
-    addToolResult,
-  };
-}

package/src/use-completion.ts

@@ -1,179 +0,0 @@
-import type {
-  JSONValue,
-  RequestOptions,
-  UseCompletionOptions,
-} from '@ai-sdk/ui-utils';
-import { callCompletionApi } from '@ai-sdk/ui-utils';
-import { useSWR } from 'sswr';
-import { Readable, Writable, derived, get, writable } from 'svelte/store';
-
-export type { UseCompletionOptions };
-
-export type UseCompletionHelpers = {
-  /** The current completion result */
-  completion: Readable<string>;
-  /** The error object of the API request */
-  error: Readable<undefined | Error>;
-  /**
-   * Send a new prompt to the API endpoint and update the completion state.
-   */
-  complete: (
-    prompt: string,
-    options?: RequestOptions,
-  ) => Promise<string | null | undefined>;
-  /**
-   * Abort the current API request but keep the generated tokens.
-   */
-  stop: () => void;
-  /**
-   * Update the `completion` state locally.
-   */
-  setCompletion: (completion: string) => void;
-  /** The current value of the input */
-  input: Writable<string>;
-  /**
-   * Form submission handler to automatically reset input and append a user message
-   * @example
-   * ```jsx
-   * <form onSubmit={handleSubmit}>
-   *  <input onChange={handleInputChange} value={input} />
-   * </form>
-   * ```
-   */
-  handleSubmit: (event?: { preventDefault?: () => void }) => void;
-  /** Whether the API request is in progress */
-  isLoading: Readable<boolean | undefined>;
-
-  /** Additional data added on the server via StreamData */
-  data: Readable<JSONValue[] | undefined>;
-};
-
-let uniqueId = 0;
-
-const store: Record<string, any> = {};
-
-export function useCompletion({
-  api = '/api/completion',
-  id,
-  initialCompletion = '',
-  initialInput = '',
-  credentials,
-  headers,
-  body,
-  streamMode,
-  streamProtocol,
-  onResponse,
-  onFinish,
-  onError,
-  fetch,
-}: UseCompletionOptions = {}): UseCompletionHelpers {
-  // streamMode is deprecated, use streamProtocol instead.
-  if (streamMode) {
-    streamProtocol ??= streamMode === 'text' ? 'text' : undefined;
-  }
-
-  // Generate an unique id for the completion if not provided.
-  const completionId = id || `completion-${uniqueId++}`;
-
-  const key = `${api}|${completionId}`;
-  const {
-    data,
-    mutate: originalMutate,
-    isLoading: isSWRLoading,
-  } = useSWR<string>(key, {
-    fetcher: () => store[key] || initialCompletion,
-    fallbackData: initialCompletion,
-  });
-
-  const streamData = writable<JSONValue[] | undefined>(undefined);
-
-  const loading = writable<boolean>(false);
-
-  // Force the `data` to be `initialCompletion` if it's `undefined`.
-  data.set(initialCompletion);
-
-  const mutate = (data: string) => {
-    store[key] = data;
-    return originalMutate(data);
-  };
-
-  // Because of the `fallbackData` option, the `data` will never be `undefined`.
-  const completion = data as Writable<string>;
-
-  const error = writable<undefined | Error>(undefined);
-
-  let abortController: AbortController | null = null;
-
-  const complete: UseCompletionHelpers['complete'] = async (
-    prompt: string,
-    options?: RequestOptions,
-  ) => {
-    const existingData = get(streamData);
-    return callCompletionApi({
-      api,
-      prompt,
-      credentials,
-      headers: {
-        ...headers,
-        ...options?.headers,
-      },
-      body: {
-        ...body,
-        ...options?.body,
-      },
-      streamProtocol,
-      setCompletion: mutate,
-      setLoading: loadingState => loading.set(loadingState),
-      setError: err => error.set(err),
-      setAbortController: controller => {
-        abortController = controller;
-      },
-      onResponse,
-      onFinish,
-      onError,
-      onData(data) {
-        streamData.set([...(existingData || []), ...(data || [])]);
-      },
-      fetch,
-    });
-  };
-
-  const stop = () => {
-    if (abortController) {
-      abortController.abort();
-      abortController = null;
-    }
-  };
-
-  const setCompletion = (completion: string) => {
-    mutate(completion);
-  };
-
-  const input = writable(initialInput);
-
-  const handleSubmit = (event?: { preventDefault?: () => void }) => {
-    event?.preventDefault?.();
-
-    const inputValue = get(input);
-    return inputValue ? complete(inputValue) : undefined;
-  };
-
-  const isLoading = derived(
-    [isSWRLoading, loading],
-    ([$isSWRLoading, $loading]) => {
-      return $isSWRLoading || $loading;
-    },
-  );
-
-  return {
-    completion,
-    complete,
-    error,
-    stop,
-    setCompletion,
-    input,
-    handleSubmit,
-    isLoading,
-    data: streamData,
-  };
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./node_modules/@vercel/ai-tsconfig/react-library.json",
-  "compilerOptions": {
-    "target": "ES2018",
-    "stripInternal": true
-  },
-  "include": ["."],
-  "exclude": ["*/dist", "dist", "build", "node_modules"]
-}

package/tsup.config.ts

@@ -1,13 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig([
-  {
-    entry: ['src/index.ts'],
-    outDir: 'dist',
-    banner: {},
-    format: ['cjs', 'esm'],
-    external: ['vue'],
-    dts: true,
-    sourcemap: true,
-  },
-]);

package/turbo.json

@@ -1,8 +0,0 @@
-{
-  "extends": ["//"],
-  "pipeline": {
-    "build": {
-      "outputs": ["**/dist/**"]
-    }
-  }
-}