@ai-sdk/svelte 0.0.24 → 0.0.26

package/src/use-chat.ts

@@ -6,7 +6,7 @@ import type {
   IdGenerator,
   JSONValue,
   Message,
-  UseChatOptions,
+  UseChatOptions as SharedUseChatOptions,
 } from '@ai-sdk/ui-utils';
 import {
   callChatApi,
@@ -15,7 +15,23 @@ import {
 } from '@ai-sdk/ui-utils';
 import { useSWR } from 'sswr';
 import { Readable, Writable, derived, get, writable } from 'svelte/store';
-export type { CreateMessage, Message, UseChatOptions };
+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 */
@@ -66,7 +82,21 @@ export type UseChatHelpers = {
 
   /** 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,
@@ -81,9 +111,10 @@ const getStreamedResponse = async (
   previousMessages: Message[],
   abortControllerRef: AbortController | null,
   generateId: IdGenerator,
-  streamMode: 'stream-data' | 'text' | undefined,
-  onFinish: ((message: Message) => void) | undefined,
+  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,
@@ -104,12 +135,14 @@ const getStreamedResponse = async (
           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 }),
@@ -137,7 +170,7 @@ const getStreamedResponse = async (
         tool_choice: chatRequest.tool_choice,
       }),
     },
-    streamMode,
+    streamProtocol,
     credentials: extraMetadata.credentials,
     headers: {
       ...extraMetadata.headers,
@@ -156,7 +189,7 @@ const getStreamedResponse = async (
     },
     onFinish,
     generateId,
-    onToolCall: undefined, // not implemented yet
+    onToolCall,
     fetch,
   });
 };
@@ -165,6 +198,36 @@ 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,
@@ -174,16 +237,32 @@ export function useChat({
   experimental_onFunctionCall,
   experimental_onToolCall,
   streamMode,
+  streamProtocol,
   onResponse,
   onFinish,
   onError,
+  onToolCall,
   credentials,
   headers,
   body,
   generateId = generateIdFunc,
   fetch,
   keepLastMessageOnError = false,
-}: UseChatOptions = {}): UseChatHelpers {
+  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++}`;
 
@@ -226,6 +305,9 @@ export function useChat({
   // 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);
@@ -245,9 +327,10 @@ export function useChat({
             get(messages),
             abortController,
             generateId,
-            streamMode,
+            streamProtocol,
             onFinish,
             onResponse,
+            onToolCall,
             sendExtraMessageFields,
             fetch,
             keepLastMessageOnError,
@@ -261,8 +344,6 @@ export function useChat({
       });
 
       abortController = null;
-
-      return null;
     } catch (err) {
       // Ignore abort errors as they are expected.
       if ((err as any).name === 'AbortError') {
@@ -278,6 +359,25 @@ export function useChat({
     } 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 (
@@ -358,10 +458,6 @@ export function useChat({
       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);
@@ -428,6 +524,40 @@ export function useChat({
     },
   );
 
+  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,
@@ -439,5 +569,6 @@ export function useChat({
     handleSubmit,
     isLoading,
     data: streamData,
+    addToolResult,
   };
 }

package/src/use-completion.ts

@@ -61,11 +61,17 @@ export function useCompletion({
   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++}`;
 
@@ -115,7 +121,7 @@ export function useCompletion({
         ...body,
         ...options?.body,
       },
-      streamMode,
+      streamProtocol,
       setCompletion: mutate,
       setLoading: loadingState => loading.set(loadingState),
       setError: err => error.set(err),