ai 7.0.107 → 7.0.108

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # ai
 
+## 7.0.108
+
+### Patch Changes
+
+- 3f6852a: fix(ai): prevent direct execution of tools governed by tool callers
+- 6317504: fix(ai): stop pending tool-call repairs when generation is cancelled
+- 3cb2dcd: fix(ai): preserve file data when adapting v3 language models
+- ccf98e7: fix(ai): prevent `streamText` from executing tool calls that violate tool choice
+- Updated dependencies [20dd00a]
+- Updated dependencies [7cf7cee]
+- Updated dependencies [c42576a]
+- Updated dependencies [d85dcf5]
+- Updated dependencies [fd9b3f3]
+  - @ai-sdk/gateway@4.0.88
+
 ## 7.0.107
 
 ### Patch Changes

package/dist/index.d.ts

@@ -3159,6 +3159,7 @@ declare class NoSuchToolError extends AISDKError {
  * @param options.tools - The tools that are available.
  * @param options.inputSchema - A function that returns the JSON Schema for a tool.
  * @param options.error - The error that occurred while parsing the tool call.
+ * @param options.abortSignal - An optional signal for cancelling the repair.
  */
 type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
     instructions: Instructions | undefined;
@@ -3173,6 +3174,7 @@ type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
         toolName: string;
     }) => PromiseLike<JSONSchema7>;
     error: NoSuchToolError | InvalidToolInputError;
+    abortSignal?: AbortSignal;
 }) => Promise<LanguageModelV4ToolCall | null>;
 
 type ToolOutput<TOOLS extends ToolSet> = TypedToolResult<TOOLS> | TypedToolError<TOOLS>;

package/dist/index.js

@@ -774,6 +774,9 @@ function asImageModelV4(model) {
   });
 }
 
+// src/model/as-language-model-v4.ts
+import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+
 // src/model/as-language-model-v3.ts
 function asLanguageModelV3(model) {
   if (model.specificationVersion === "v3") {
@@ -861,11 +864,131 @@ function asLanguageModelV4(model) {
   const v3Model = model.specificationVersion === "v2" ? asLanguageModelV3(model) : model;
   return new Proxy(v3Model, {
     get(target, prop) {
-      if (prop === "specificationVersion") return "v4";
-      return target[prop];
+      switch (prop) {
+        case "specificationVersion":
+          return "v4";
+        case "doGenerate":
+          return async (options) => {
+            const result = await target.doGenerate({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt)
+            });
+            return {
+              ...result,
+              content: result.content.map(convertV3ContentToV4)
+            };
+          };
+        case "doStream":
+          return async (options) => {
+            const result = await target.doStream({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt)
+            });
+            return {
+              ...result,
+              stream: convertV3StreamToV4(result.stream)
+            };
+          };
+        default:
+          return target[prop];
+      }
     }
   });
 }
+function convertV4PromptToV3(prompt) {
+  return prompt.map((message) => {
+    if (message.role === "system") {
+      return message;
+    }
+    return {
+      ...message,
+      content: message.content.map((part) => {
+        switch (part.type) {
+          case "file":
+            return {
+              ...part,
+              data: convertV4FileDataToV3(part.data)
+            };
+          case "tool-result":
+            return {
+              ...part,
+              output: convertV4ToolResultOutputToV3(part.output)
+            };
+          default:
+            return part;
+        }
+      })
+    };
+  });
+}
+function convertV4FileDataToV3(data) {
+  switch (data.type) {
+    case "data":
+      return data.data;
+    case "url":
+      return data.url;
+    case "reference":
+    case "text":
+      return data;
+  }
+}
+function convertV4ToolResultOutputToV3(output) {
+  if (output.type !== "content") {
+    return output;
+  }
+  return {
+    ...output,
+    value: output.value.map((part) => {
+      if (part.type !== "file") {
+        return part;
+      }
+      switch (part.data.type) {
+        case "data":
+          return {
+            type: "file-data",
+            data: typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data),
+            mediaType: part.mediaType,
+            filename: part.filename,
+            providerOptions: part.providerOptions
+          };
+        case "url":
+          return {
+            type: "file-url",
+            url: part.data.url.toString(),
+            providerOptions: part.providerOptions
+          };
+        case "reference":
+          return {
+            type: "file-id",
+            fileId: part.data.reference,
+            providerOptions: part.providerOptions
+          };
+        case "text":
+          return part;
+      }
+    })
+  };
+}
+function convertV3ContentToV4(content) {
+  return content.type === "file" ? {
+    ...content,
+    data: { type: "data", data: content.data }
+  } : content;
+}
+function convertV3StreamToV4(stream) {
+  return stream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        controller.enqueue(
+          chunk.type === "file" ? {
+            ...chunk,
+            data: { type: "data", data: chunk.data }
+          } : chunk
+        );
+      }
+    })
+  );
+}
 
 // src/model/as-reranking-model-v4.ts
 function asRerankingModelV4(model) {
@@ -1211,7 +1334,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.107" : "0.0.0-test";
+var VERSION = true ? "7.0.108" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -3010,7 +3133,7 @@ function collectToolApprovals({
 // src/generate-text/generated-file.ts
 import {
   convertBase64ToUint8Array,
-  convertUint8ArrayToBase64
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642
 } from "@ai-sdk/provider-utils";
 var DefaultGeneratedFile = class {
   constructor({
@@ -3027,7 +3150,7 @@ var DefaultGeneratedFile = class {
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
     if (this.base64Data == null) {
-      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
+      this.base64Data = convertUint8ArrayToBase642(this.uint8ArrayData);
     }
     return this.base64Data;
   }
@@ -4439,7 +4562,8 @@ async function parseToolCall({
   repairToolCall,
   refineToolInput,
   messages,
-  instructions
+  instructions,
+  abortSignal
 }) {
   try {
     if (tools == null) {
@@ -4462,20 +4586,26 @@ async function parseToolCall({
       }
       let repairedToolCall = null;
       try {
-        repairedToolCall = await repairToolCall({
-          toolCall,
-          tools,
-          inputSchema: async ({ toolName }) => {
-            var _a25;
-            const inputSchema = (_a25 = getOwn(tools, toolName)) == null ? void 0 : _a25.inputSchema;
-            return await asSchema3(inputSchema).jsonSchema;
-          },
-          instructions,
-          system: instructions,
-          messages,
-          error
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+        repairedToolCall = await waitForPromiseWithAbortSignal({
+          promise: repairToolCall({
+            toolCall,
+            tools,
+            inputSchema: async ({ toolName }) => {
+              var _a25;
+              const inputSchema = (_a25 = getOwn(tools, toolName)) == null ? void 0 : _a25.inputSchema;
+              return await asSchema3(inputSchema).jsonSchema;
+            },
+            instructions,
+            system: instructions,
+            messages,
+            error,
+            abortSignal
+          }),
+          abortSignal
         });
       } catch (repairError) {
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
         throw new ToolCallRepairError({
           cause: repairError,
           originalError: error
@@ -4484,12 +4614,15 @@ async function parseToolCall({
       if (repairedToolCall == null) {
         throw error;
       }
-      return await refineParsedToolCallInput({
+      const parsedRepairedToolCall = await refineParsedToolCallInput({
         toolCall: await doParseToolCall({ toolCall: repairedToolCall, tools }),
         refineToolInput
       });
+      abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+      return parsedRepairedToolCall;
     }
   } catch (error) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
     const parsedInput = await safeParseJSON3({ text: toolCall.input });
     const input = parsedInput.success ? parsedInput.value : toolCall.input;
     const tool3 = getOwn(tools, toolCall.toolName);
@@ -4508,6 +4641,34 @@ async function parseToolCall({
     };
   }
 }
+async function waitForPromiseWithAbortSignal({
+  promise,
+  abortSignal
+}) {
+  if (abortSignal == null) {
+    return await promise;
+  }
+  return await new Promise((resolve3, reject) => {
+    const cleanup = () => {
+      abortSignal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortSignal.reason);
+    };
+    Promise.resolve(promise).then((value) => {
+      cleanup();
+      resolve3(value);
+    }).catch((error) => {
+      cleanup();
+      reject(error);
+    });
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+    if (abortSignal.aborted) {
+      onAbort();
+    }
+  });
+}
 async function refineParsedToolCallInput({
   toolCall,
   refineToolInput
@@ -5514,7 +5675,7 @@ function sortToolResultContentByToolCallOrder({
 import { convertBase64ToUint8Array as convertBase64ToUint8Array2 } from "@ai-sdk/provider-utils";
 
 // src/util/canonical-hash.ts
-import { convertUint8ArrayToBase64 as convertUint8ArrayToBase642 } from "@ai-sdk/provider-utils";
+import { convertUint8ArrayToBase64 as convertUint8ArrayToBase643 } from "@ai-sdk/provider-utils";
 var encoder = new TextEncoder();
 function canonicalJSON(value) {
   if (value === null || value === void 0) {
@@ -5533,7 +5694,7 @@ function canonicalJSON(value) {
   return `{${entries.join(",")}}`;
 }
 function toBase64url(bytes) {
-  return convertUint8ArrayToBase642(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  return convertUint8ArrayToBase643(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 async function hashCanonical(value) {
   const digest = await crypto.subtle.digest(
@@ -6191,11 +6352,12 @@ async function generateText({
                 ).map(
                   (toolCall) => parseToolCall({
                     toolCall,
-                    tools: stepExecutionTools,
+                    tools: stepModelTools,
                     repairToolCall,
                     refineToolInput,
                     instructions: stepInstructions,
-                    messages: stepMessages
+                    messages: stepMessages,
+                    abortSignal: mergedAbortSignal
                   })
                 )
               );
@@ -9089,6 +9251,7 @@ async function streamLanguageModelCall({
       messages: standardizedPrompt.messages,
       repairToolCall,
       refineToolInput,
+      abortSignal,
       callId: effectiveCallId,
       provider: resolvedModel.provider,
       modelId: resolvedModel.modelId,
@@ -9111,6 +9274,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
   messages,
   repairToolCall,
   refineToolInput,
+  abortSignal,
   callId,
   provider,
   modelId,
@@ -9298,27 +9462,28 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             },
             callbacks: onLanguageModelCallEnd
           });
+          const enforcedToolChoice = toolChoice.type === "required" || toolChoice.type === "tool" ? toolChoice : void 0;
+          const toolChoiceViolationError = enforcedToolChoice != null && ![...toolCallsByToolCallId.values()].some(
+            (toolCall) => enforcedToolChoice.type === "required" || toolCall.toolName === enforcedToolChoice.toolName
+          ) ? new ToolChoiceViolationError({
+            toolChoice: enforcedToolChoice,
+            finishReason: chunk.finishReason.unified,
+            provider,
+            modelId,
+            content: rawModelCallContent
+          }) : void 0;
           controller.enqueue({
             type: "model-call-end",
-            finishReason: chunk.finishReason.unified,
+            finishReason: toolChoiceViolationError == null ? chunk.finishReason.unified : "error",
             rawFinishReason: chunk.finishReason.raw,
             usage,
             providerMetadata: chunk.providerMetadata,
             performance
           });
-          const enforcedToolChoice = toolChoice.type === "required" || toolChoice.type === "tool" ? toolChoice : void 0;
-          if (enforcedToolChoice != null && ![...toolCallsByToolCallId.values()].some(
-            (toolCall) => enforcedToolChoice.type === "required" || toolCall.toolName === enforcedToolChoice.toolName
-          )) {
+          if (toolChoiceViolationError != null) {
             controller.enqueue({
               type: "error",
-              error: new ToolChoiceViolationError({
-                toolChoice: enforcedToolChoice,
-                finishReason: chunk.finishReason.unified,
-                provider,
-                modelId,
-                content: rawModelCallContent
-              })
+              error: toolChoiceViolationError
             });
             break;
           }
@@ -9333,7 +9498,8 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
               repairToolCall,
               refineToolInput,
               instructions,
-              messages
+              messages,
+              abortSignal
             });
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
             controller.enqueue(toolCall);
@@ -12935,16 +13101,16 @@ import {
 // src/prompt/data-content.ts
 import {
   convertBase64ToUint8Array as convertBase64ToUint8Array3,
-  convertUint8ArrayToBase64 as convertUint8ArrayToBase643
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase644
 } from "@ai-sdk/provider-utils";
 function convertDataContentToBase64String(content) {
   if (typeof content === "string") {
     return content;
   }
   if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase643(new Uint8Array(content));
+    return convertUint8ArrayToBase644(new Uint8Array(content));
   }
-  return convertUint8ArrayToBase643(content);
+  return convertUint8ArrayToBase644(content);
 }
 function convertDataContentToUint8Array(content) {
   if (content instanceof Uint8Array) {