ai 7.0.107 → 7.0.109

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # ai
 
+## 7.0.109
+
+### Patch Changes
+
+- 0343bb1: fix(ai): keep replacement completion requests loading and cancellable when an earlier request settles
+- 2b105fa: fix(ai): preserve overlapping text blocks in reasoning extraction streams
+- 125f493: fix(harness): forward validated `toolsContext` to host-executed tools in alignment with `ToolLoopAgent`
+
+## 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>;
@@ -3329,18 +3331,22 @@ type ToolInputRefinement<TOOLS extends ToolSet> = {
  */
 type IsEmptyObject<OBJECT> = keyof OBJECT extends never ? true : false;
 /**
- * Helper type to make the toolsContext parameter optional, required, or
- * unavailable based on the tool set.
+ * Makes the toolsContext setting optional, required, or unavailable based on
+ * the tool set.
  */
-type ToolsContextParameter<TOOLS extends ToolSet> = {
-    tools?: TOOLS;
-} & (IsEmptyObject<InferToolSetContext<TOOLS>> extends true ? {
+type ToolsContextSettings<TOOLS extends ToolSet> = IsEmptyObject<InferToolSetContext<TOOLS>> extends true ? {
     toolsContext?: never;
 } : HasRequiredKey<InferToolSetContext<TOOLS>> extends true ? {
     toolsContext: InferToolSetContext<TOOLS>;
 } : {
     toolsContext?: InferToolSetContext<TOOLS>;
-});
+};
+/**
+ * Helper type for request options that include both tools and their context.
+ */
+type ToolsContextParameter<TOOLS extends ToolSet> = {
+    tools?: TOOLS;
+} & ToolsContextSettings<TOOLS>;
 
 type StreamTextInclude = {
     /**
@@ -5397,7 +5403,7 @@ type UIMessageStreamOnStepEndCallback<UI_MESSAGE extends UIMessage> = (event: {
 type UIMessageStreamOnStepFinishCallback<UI_MESSAGE extends UIMessage> = UIMessageStreamOnStepEndCallback<UI_MESSAGE>;
 
 declare const getOriginalFetch: () => typeof fetch;
-declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, onFinish, onError, fetch, }: {
+declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, getAbortController, onFinish, onError, fetch, }: {
     api: string;
     prompt: string;
     credentials: RequestCredentials | undefined;
@@ -5408,6 +5414,7 @@ declare function callCompletionApi({ api, prompt, credentials, headers, body, st
     setLoading: (loading: boolean) => void;
     setError: (error: Error | undefined) => void;
     setAbortController: (abortController: AbortController | null) => void;
+    getAbortController?: () => AbortController | null | undefined;
     onFinish: ((prompt: string, completion: string) => void) | undefined;
     onError: ((error: Error) => void) | undefined;
     fetch: ReturnType<typeof getOriginalFetch> | undefined;

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.109" : "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) {
@@ -17264,18 +17430,19 @@ function extractReasoningMiddleware({
     wrapStream: async ({ doStream }) => {
       const { stream, ...rest } = await doStream();
       const reasoningExtractions = createIdMap();
-      let delayedTextStart;
+      let reasoningIdCounter = 0;
+      const delayedTextStarts = createIdMap();
       return {
         stream: stream.pipeThrough(
           new TransformStream({
             transform: (chunk, controller) => {
               if (chunk.type === "text-start") {
-                delayedTextStart = chunk;
+                delayedTextStarts[chunk.id] = chunk;
                 return;
               }
-              if (chunk.type === "text-end" && delayedTextStart) {
-                controller.enqueue(delayedTextStart);
-                delayedTextStart = void 0;
+              if (chunk.type === "text-end" && delayedTextStarts[chunk.id] != null) {
+                controller.enqueue(delayedTextStarts[chunk.id]);
+                delete delayedTextStarts[chunk.id];
               }
               if (chunk.type !== "text-delta") {
                 controller.enqueue(chunk);
@@ -17288,31 +17455,37 @@ function extractReasoningMiddleware({
                   afterSwitch: false,
                   isReasoning: startWithReasoning,
                   buffer: "",
-                  idCounter: 0,
+                  reasoningId: void 0,
                   textId: chunk.id
                 };
               }
               const activeExtraction = reasoningExtractions[chunk.id];
               activeExtraction.buffer += chunk.delta;
+              function getReasoningId() {
+                var _a25;
+                return (_a25 = activeExtraction.reasoningId) != null ? _a25 : activeExtraction.reasoningId = `reasoning-${reasoningIdCounter++}`;
+              }
               function publish(text2) {
                 if (text2.length > 0) {
                   const prefix = activeExtraction.afterSwitch && (activeExtraction.isReasoning ? !activeExtraction.isFirstReasoning : !activeExtraction.isFirstText) ? separator : "";
                   if (activeExtraction.isReasoning && (activeExtraction.afterSwitch || activeExtraction.isFirstReasoning)) {
                     controller.enqueue({
                       type: "reasoning-start",
-                      id: `reasoning-${activeExtraction.idCounter}`
+                      id: getReasoningId()
                     });
                   }
                   if (activeExtraction.isReasoning) {
                     controller.enqueue({
                       type: "reasoning-delta",
                       delta: prefix + text2,
-                      id: `reasoning-${activeExtraction.idCounter}`
+                      id: getReasoningId()
                     });
                   } else {
-                    if (delayedTextStart) {
-                      controller.enqueue(delayedTextStart);
-                      delayedTextStart = void 0;
+                    if (delayedTextStarts[activeExtraction.textId] != null) {
+                      controller.enqueue(
+                        delayedTextStarts[activeExtraction.textId]
+                      );
+                      delete delayedTextStarts[activeExtraction.textId];
                     }
                     controller.enqueue({
                       type: "text-delta",
@@ -17349,13 +17522,14 @@ function extractReasoningMiddleware({
                     if (activeExtraction.isFirstReasoning) {
                       controller.enqueue({
                         type: "reasoning-start",
-                        id: `reasoning-${activeExtraction.idCounter}`
+                        id: getReasoningId()
                       });
                     }
                     controller.enqueue({
                       type: "reasoning-end",
-                      id: `reasoning-${activeExtraction.idCounter++}`
+                      id: getReasoningId()
                     });
+                    activeExtraction.reasoningId = void 0;
                   }
                   activeExtraction.isReasoning = !activeExtraction.isReasoning;
                   activeExtraction.afterSwitch = true;
@@ -21495,14 +21669,16 @@ async function callCompletionApi({
   setLoading,
   setError,
   setAbortController,
+  getAbortController,
   onFinish,
   onError,
   fetch: fetch2 = getOriginalFetch()
 }) {
+  const abortController = new AbortController();
+  const isCurrentRequest = () => getAbortController == null || getAbortController() === abortController;
   try {
     setLoading(true);
     setError(void 0);
-    const abortController = new AbortController();
     setAbortController(abortController);
     setCompletion("");
     const response = await fetch2(api, {
@@ -21543,7 +21719,9 @@ async function callCompletionApi({
           stream: response.body,
           onTextPart: (chunk) => {
             result += chunk;
-            setCompletion(result);
+            if (isCurrentRequest()) {
+              setCompletion(result);
+            }
           }
         });
         break;
@@ -21562,7 +21740,9 @@ async function callCompletionApi({
                 const streamPart = part.value;
                 if (streamPart.type === "text-delta") {
                   result += streamPart.delta;
-                  setCompletion(result);
+                  if (isCurrentRequest()) {
+                    setCompletion(result);
+                  }
                 } else if (streamPart.type === "error") {
                   throw new UIMessageStreamError({
                     chunkType: "error",
@@ -21591,11 +21771,9 @@ async function callCompletionApi({
     if (onFinish) {
       onFinish(prompt, result);
     }
-    setAbortController(null);
     return result;
   } catch (err) {
     if (err.name === "AbortError") {
-      setAbortController(null);
       return null;
     }
     if (err instanceof Error) {
@@ -21603,9 +21781,14 @@ async function callCompletionApi({
         onError(err);
       }
     }
-    setError(err);
+    if (isCurrentRequest()) {
+      setError(err);
+    }
   } finally {
-    setLoading(false);
+    if (isCurrentRequest()) {
+      setAbortController(null);
+      setLoading(false);
+    }
   }
 }