ai 5.0.6 → 5.0.8

package/dist/index.mjs

@@ -17,7 +17,8 @@ import {
 
 // src/generate-text/generate-text.ts
 import {
-  createIdGenerator
+  createIdGenerator,
+  getErrorMessage as getErrorMessage5
 } from "@ai-sdk/provider-utils";
 
 // src/error/no-output-specified-error.ts
@@ -1691,38 +1692,50 @@ async function parseToolCall({
   system,
   messages
 }) {
-  if (tools == null) {
-    throw new NoSuchToolError({ toolName: toolCall.toolName });
-  }
   try {
-    return await doParseToolCall({ toolCall, tools });
-  } catch (error) {
-    if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolInputError.isInstance(error))) {
-      throw error;
+    if (tools == null) {
+      throw new NoSuchToolError({ toolName: toolCall.toolName });
     }
-    let repairedToolCall = null;
     try {
-      repairedToolCall = await repairToolCall({
-        toolCall,
-        tools,
-        inputSchema: ({ toolName }) => {
-          const { inputSchema } = tools[toolName];
-          return asSchema2(inputSchema).jsonSchema;
-        },
-        system,
-        messages,
-        error
-      });
-    } catch (repairError) {
-      throw new ToolCallRepairError({
-        cause: repairError,
-        originalError: error
-      });
-    }
-    if (repairedToolCall == null) {
-      throw error;
+      return await doParseToolCall({ toolCall, tools });
+    } catch (error) {
+      if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolInputError.isInstance(error))) {
+        throw error;
+      }
+      let repairedToolCall = null;
+      try {
+        repairedToolCall = await repairToolCall({
+          toolCall,
+          tools,
+          inputSchema: ({ toolName }) => {
+            const { inputSchema } = tools[toolName];
+            return asSchema2(inputSchema).jsonSchema;
+          },
+          system,
+          messages,
+          error
+        });
+      } catch (repairError) {
+        throw new ToolCallRepairError({
+          cause: repairError,
+          originalError: error
+        });
+      }
+      if (repairedToolCall == null) {
+        throw error;
+      }
+      return await doParseToolCall({ toolCall: repairedToolCall, tools });
     }
-    return await doParseToolCall({ toolCall: repairedToolCall, tools });
+  } catch (error) {
+    return {
+      type: "tool-call",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      input: toolCall.input,
+      dynamic: true,
+      invalid: true,
+      error
+    };
   }
 }
 async function doParseToolCall({
@@ -2174,6 +2187,9 @@ async function generateText({
             )
           );
           for (const toolCall of stepToolCalls) {
+            if (toolCall.invalid) {
+              continue;
+            }
             const tool3 = tools[toolCall.toolName];
             if ((tool3 == null ? void 0 : tool3.onInputAvailable) != null) {
               await tool3.onInputAvailable({
@@ -2185,18 +2201,38 @@ async function generateText({
               });
             }
           }
+          const invalidToolCalls = stepToolCalls.filter(
+            (toolCall) => toolCall.invalid && toolCall.dynamic
+          );
+          clientToolOutputs = [];
+          for (const toolCall of invalidToolCalls) {
+            clientToolOutputs.push({
+              type: "tool-error",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input,
+              error: getErrorMessage5(toolCall.error),
+              dynamic: true
+            });
+          }
           clientToolCalls = stepToolCalls.filter(
-            (toolCall) => toolCall.providerExecuted !== true
+            (toolCall) => !toolCall.providerExecuted
           );
-          clientToolOutputs = tools == null ? [] : await executeTools({
-            toolCalls: clientToolCalls,
-            tools,
-            tracer,
-            telemetry,
-            messages: stepInputMessages,
-            abortSignal,
-            experimental_context
-          });
+          if (tools != null) {
+            clientToolOutputs.push(
+              ...await executeTools({
+                toolCalls: clientToolCalls.filter(
+                  (toolCall) => !toolCall.invalid
+                ),
+                tools,
+                tracer,
+                telemetry,
+                messages: stepInputMessages,
+                abortSignal,
+                experimental_context
+              })
+            );
+          }
           const stepContent = asContent({
             content: currentModelResponse.content,
             toolCalls: stepToolCalls,
@@ -2505,7 +2541,7 @@ function asContent({
 
 // src/generate-text/stream-text.ts
 import {
-  getErrorMessage as getErrorMessage5
+  getErrorMessage as getErrorMessage7
 } from "@ai-sdk/provider";
 import {
   createIdGenerator as createIdGenerator2,
@@ -2695,6 +2731,16 @@ var uiMessageChunkSchema = z7.union([
     providerMetadata: providerMetadataSchema.optional(),
     dynamic: z7.boolean().optional()
   }),
+  z7.strictObject({
+    type: z7.literal("tool-input-error"),
+    toolCallId: z7.string(),
+    toolName: z7.string(),
+    input: z7.unknown(),
+    providerExecuted: z7.boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    dynamic: z7.boolean().optional(),
+    errorText: z7.string()
+  }),
   z7.strictObject({
     type: z7.literal("tool-output-available"),
     toolCallId: z7.string(),
@@ -3234,6 +3280,7 @@ function processUIMessageStream({
               anyPart.input = anyOptions.input;
               anyPart.output = anyOptions.output;
               anyPart.errorText = anyOptions.errorText;
+              anyPart.rawInput = anyOptions.rawInput;
               anyPart.providerExecuted = (_a17 = anyOptions.providerExecuted) != null ? _a17 : part.providerExecuted;
               if (anyOptions.providerMetadata != null && part.state === "input-available") {
                 part.callProviderMetadata = anyOptions.providerMetadata;
@@ -3245,6 +3292,7 @@ function processUIMessageStream({
                 state: options.state,
                 input: anyOptions.input,
                 output: anyOptions.output,
+                rawInput: anyOptions.rawInput,
                 errorText: anyOptions.errorText,
                 providerExecuted: anyOptions.providerExecuted,
                 ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
@@ -3252,6 +3300,7 @@ function processUIMessageStream({
             }
           }
           function updateDynamicToolPart(options) {
+            var _a17;
             const part = state.message.parts.find(
               (part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId
             );
@@ -3263,6 +3312,7 @@ function processUIMessageStream({
               anyPart.input = anyOptions.input;
               anyPart.output = anyOptions.output;
               anyPart.errorText = anyOptions.errorText;
+              anyPart.rawInput = (_a17 = anyOptions.rawInput) != null ? _a17 : anyPart.rawInput;
               if (anyOptions.providerMetadata != null && part.state === "input-available") {
                 part.callProviderMetadata = anyOptions.providerMetadata;
               }
@@ -3456,6 +3506,31 @@ function processUIMessageStream({
               }
               break;
             }
+            case "tool-input-error": {
+              if (chunk.dynamic) {
+                updateDynamicToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "output-error",
+                  input: chunk.input,
+                  errorText: chunk.errorText,
+                  providerMetadata: chunk.providerMetadata
+                });
+              } else {
+                updateToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "output-error",
+                  input: void 0,
+                  rawInput: chunk.input,
+                  errorText: chunk.errorText,
+                  providerExecuted: chunk.providerExecuted,
+                  providerMetadata: chunk.providerMetadata
+                });
+              }
+              write();
+              break;
+            }
             case "tool-output-available": {
               if (chunk.dynamic) {
                 const toolInvocation = getDynamicToolInvocation(
@@ -3501,6 +3576,7 @@ function processUIMessageStream({
                   toolName: getToolName(toolInvocation),
                   state: "output-error",
                   input: toolInvocation.input,
+                  rawInput: toolInvocation.rawInput,
                   errorText: chunk.errorText
                 });
               }
@@ -3870,7 +3946,10 @@ function now() {
 }
 
 // src/generate-text/run-tools-transformation.ts
-import { generateId } from "@ai-sdk/provider-utils";
+import {
+  generateId,
+  getErrorMessage as getErrorMessage6
+} from "@ai-sdk/provider-utils";
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -3950,6 +4029,17 @@ function runToolsTransformation({
               messages
             });
             controller.enqueue(toolCall);
+            if (toolCall.invalid) {
+              toolResultsStreamController.enqueue({
+                type: "tool-error",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input,
+                error: getErrorMessage6(toolCall.error),
+                dynamic: true
+              });
+              break;
+            }
             const tool3 = tools[toolCall.toolName];
             toolInputs.set(toolCall.toolCallId, toolCall.input);
             if (tool3.onInputAvailable != null) {
@@ -4262,6 +4352,7 @@ var DefaultStreamTextResult = class {
     this._steps = new DelayedPromise();
     this.output = output;
     this.includeRawChunks = includeRawChunks;
+    this.tools = tools;
     let stepFinish;
     let recordedContent = [];
     const recordedResponseMessages = [];
@@ -5064,12 +5155,19 @@ var DefaultStreamTextResult = class {
     sendSources = false,
     sendStart = true,
     sendFinish = true,
-    onError = getErrorMessage5
+    onError = getErrorMessage7
   } = {}) {
     const responseMessageId = generateMessageId != null ? getResponseUIMessageId({
       originalMessages,
       responseMessageId: generateMessageId
     }) : void 0;
+    const toolNamesByCallId = {};
+    const isDynamic = (toolCallId) => {
+      var _a16, _b;
+      const toolName = toolNamesByCallId[toolCallId];
+      const dynamic = ((_b = (_a16 = this.tools) == null ? void 0 : _a16[toolName]) == null ? void 0 : _b.type) === "dynamic";
+      return dynamic ? true : void 0;
+    };
     const baseStream = this.fullStream.pipeThrough(
       new TransformStream({
         transform: async (part, controller) => {
@@ -5159,12 +5257,14 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "tool-input-start": {
+              toolNamesByCallId[part.id] = part.toolName;
+              const dynamic = isDynamic(part.id);
               controller.enqueue({
                 type: "tool-input-start",
                 toolCallId: part.id,
                 toolName: part.toolName,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+                ...dynamic != null ? { dynamic } : {}
               });
               break;
             }
@@ -5177,34 +5277,51 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "tool-call": {
-              controller.enqueue({
-                type: "tool-input-available",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                input: part.input,
-                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
-              });
+              toolNamesByCallId[part.toolCallId] = part.toolName;
+              const dynamic = isDynamic(part.toolCallId);
+              if (part.invalid) {
+                controller.enqueue({
+                  type: "tool-input-error",
+                  toolCallId: part.toolCallId,
+                  toolName: part.toolName,
+                  input: part.input,
+                  ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                  ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+                  ...dynamic != null ? { dynamic } : {},
+                  errorText: onError(part.error)
+                });
+              } else {
+                controller.enqueue({
+                  type: "tool-input-available",
+                  toolCallId: part.toolCallId,
+                  toolName: part.toolName,
+                  input: part.input,
+                  ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                  ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+                  ...dynamic != null ? { dynamic } : {}
+                });
+              }
               break;
             }
             case "tool-result": {
+              const dynamic = isDynamic(part.toolCallId);
               controller.enqueue({
                 type: "tool-output-available",
                 toolCallId: part.toolCallId,
                 output: part.output,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+                ...dynamic != null ? { dynamic } : {}
               });
               break;
             }
             case "tool-error": {
+              const dynamic = isDynamic(part.toolCallId);
               controller.enqueue({
                 type: "tool-output-error",
                 toolCallId: part.toolCallId,
                 errorText: onError(part.error),
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+                ...dynamic != null ? { dynamic } : {}
               });
               break;
             }
@@ -9253,7 +9370,7 @@ function convertToModelMessages(messages, options) {
       case "assistant": {
         if (message.parts != null) {
           let processBlock2 = function() {
-            var _a16;
+            var _a16, _b;
             if (block.length === 0) {
               return;
             }
@@ -9305,7 +9422,7 @@ function convertToModelMessages(messages, options) {
                     type: "tool-call",
                     toolCallId: part.toolCallId,
                     toolName,
-                    input: part.input,
+                    input: part.state === "output-error" ? (_a16 = part.input) != null ? _a16 : part.rawInput : part.input,
                     providerExecuted: part.providerExecuted,
                     ...part.callProviderMetadata != null ? { providerOptions: part.callProviderMetadata } : {}
                   });
@@ -9316,7 +9433,7 @@ function convertToModelMessages(messages, options) {
                       toolName,
                       output: createToolModelOutput({
                         output: part.state === "output-error" ? part.errorText : part.output,
-                        tool: (_a16 = options == null ? void 0 : options.tools) == null ? void 0 : _a16[toolName],
+                        tool: (_b = options == null ? void 0 : options.tools) == null ? void 0 : _b[toolName],
                         errorMode: part.state === "output-error" ? "json" : "none"
                       })
                     });
@@ -9449,11 +9566,11 @@ var TextStreamChatTransport = class extends HttpChatTransport {
 // src/ui-message-stream/create-ui-message-stream.ts
 import {
   generateId as generateIdFunc2,
-  getErrorMessage as getErrorMessage6
+  getErrorMessage as getErrorMessage8
 } from "@ai-sdk/provider-utils";
 function createUIMessageStream({
   execute,
-  onError = getErrorMessage6,
+  onError = getErrorMessage8,
   originalMessages,
   onFinish,
   generateId: generateId3 = generateIdFunc2