ai 7.0.107 → 7.0.109

package/dist/internal/index.d.ts

@@ -1,7 +1,7 @@
 import * as _ai_sdk_provider from '@ai-sdk/provider';
 import { EmbeddingModelV4Embedding, LanguageModelV4Source, SharedV4Warning, LanguageModelV4, LanguageModelV3, LanguageModelV2, SharedV4ProviderMetadata, JSONObject, LanguageModelV4Usage, LanguageModelV4CallOptions, LanguageModelV4Prompt, AISDKError, LanguageModelV4ToolCall, JSONSchema7, ProviderV4, ProviderV3, ProviderV2, LanguageModelV4ToolResultOutput, LanguageModelV4ToolChoice, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool } from '@ai-sdk/provider';
 import { GatewayModelId } from '@ai-sdk/gateway';
-import { ModelMessage, AssistantModelMessage, ToolModelMessage, Context, ProviderOptions, ToolSet, SystemModelMessage, InferToolSetContext, Arrayable, InferToolInput, InferToolOutput, ReasoningPart, ReasoningFilePart, MaybePromiseLike, ToolExecutionOptions, InferToolContext, ToolResultOutput, Tool, Experimental_SandboxSession, ShouldRetryFunction, RetryFunction, ToolApprovalRequest, ToolApprovalResponse, ToolResultPart } from '@ai-sdk/provider-utils';
+import { ModelMessage, AssistantModelMessage, ToolModelMessage, Context, ProviderOptions, ToolSet, SystemModelMessage, InferToolSetContext, Arrayable, InferToolInput, InferToolOutput, ReasoningPart, ReasoningFilePart, MaybePromiseLike, ToolExecutionOptions, InferToolContext, HasRequiredKey, ToolResultOutput, Tool, Experimental_SandboxSession, ShouldRetryFunction, RetryFunction, FlexibleSchema, ToolApprovalRequest, ToolApprovalResponse, ToolResultPart } from '@ai-sdk/provider-utils';
 export { convertAsyncIteratorToReadableStream } from '@ai-sdk/provider-utils';
 
 /**
@@ -1763,6 +1763,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;
@@ -1777,6 +1778,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>;
@@ -1924,6 +1926,22 @@ type ToolInputRefinement<TOOLS extends ToolSet> = {
     [NAME in keyof TOOLS]?: (input: InferToolInput<TOOLS[NAME]>) => MaybePromiseLike<InferToolInput<TOOLS[NAME]>>;
 };
 
+/**
+ * Checks whether a tool context map contains any contextual tool entries.
+ */
+type IsEmptyObject<OBJECT> = keyof OBJECT extends never ? true : false;
+/**
+ * Makes the toolsContext setting optional, required, or unavailable based on
+ * the tool set.
+ */
+type ToolsContextSettings<TOOLS extends ToolSet> = IsEmptyObject<InferToolSetContext<TOOLS>> extends true ? {
+    toolsContext?: never;
+} : HasRequiredKey<InferToolSetContext<TOOLS>> extends true ? {
+    toolsContext: InferToolSetContext<TOOLS>;
+} : {
+    toolsContext?: InferToolSetContext<TOOLS>;
+};
+
 type EnrichedStreamPart<TOOLS extends ToolSet, PARTIAL_OUTPUT> = {
     part: TextStreamPart<TOOLS>;
     partialOutput: PARTIAL_OUTPUT | undefined;
@@ -2681,15 +2699,32 @@ declare function createRestrictedTelemetryDispatcher<TOOLS extends ToolSet, RUNT
     includeToolsContext?: IncludedToolsContext<TOOLS>;
 }): RestrictedTelemetryDispatcher<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
 
-declare function parseToolCall<TOOLS extends ToolSet>({ toolCall, tools, repairToolCall, refineToolInput, messages, instructions, }: {
+declare function parseToolCall<TOOLS extends ToolSet>({ toolCall, tools, repairToolCall, refineToolInput, messages, instructions, abortSignal, }: {
     toolCall: LanguageModelV4ToolCall;
     tools: TOOLS | undefined;
     repairToolCall: ToolCallRepairFunction<TOOLS> | undefined;
     refineToolInput?: ToolInputRefinement<TOOLS> | undefined;
     instructions: Instructions | undefined;
     messages: ModelMessage[];
+    abortSignal?: AbortSignal;
 }): Promise<TypedToolCall<TOOLS>>;
 
+/**
+ * Validates a tool context value against the tool's optional context schema.
+ *
+ * When no context schema is defined, the original context value is returned as-is.
+ * Otherwise, the context is validated and normalized through the schema before
+ * being passed into tool execution and approval hooks.
+ *
+ * @throws {TypeValidationError} When the provided tool context does not match
+ * the tool's declared `contextSchema`.
+ */
+declare function validateToolContext<CONTEXT>({ toolName, context, contextSchema, }: {
+    toolName: string;
+    context: unknown;
+    contextSchema: FlexibleSchema<CONTEXT> | undefined;
+}): Promise<CONTEXT>;
+
 /** Create discovery state for one generation, never for a shared tool instance. */
 declare function createToolSearchState({ tools, toolCallers, }: {
     tools: ToolSet | undefined;
@@ -2761,4 +2796,4 @@ declare function toResponseMessages<TOOLS extends ToolSet>({ content: inputConte
     tools: TOOLS | undefined;
 }): Promise<Array<AssistantModelMessage | ToolModelMessage>>;
 
-export { type CollectedToolApprovals, DefaultStepResult, type DownloadFunction, addLanguageModelUsage, asLanguageModelUsage, collectToolApprovals, convertToLanguageModelPrompt, createAsyncIterableStream, createDefaultDownloadFunction, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createTelemetryDispatcher, createToolModelOutput, createToolSearchState, downloadAssets, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions as prepareCallSettings, prepareLanguageModelCallOptions, prepareRetries, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, toResponseMessages, validateApprovedToolApprovals, verifyToolApprovalSignature };
+export { type CollectedToolApprovals, DefaultStepResult, type DownloadFunction, type ToolsContextSettings, addLanguageModelUsage, asLanguageModelUsage, collectToolApprovals, convertToLanguageModelPrompt, createAsyncIterableStream, createDefaultDownloadFunction, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createTelemetryDispatcher, createToolModelOutput, createToolSearchState, downloadAssets, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions as prepareCallSettings, prepareLanguageModelCallOptions, prepareRetries, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, toResponseMessages, validateApprovedToolApprovals, validateToolContext, verifyToolApprovalSignature };

package/dist/internal/index.js

@@ -91,7 +91,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 ({
@@ -2126,6 +2126,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") {
@@ -2213,11 +2216,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) {
@@ -2968,7 +3091,8 @@ async function parseToolCall({
   repairToolCall,
   refineToolInput,
   messages,
-  instructions
+  instructions,
+  abortSignal
 }) {
   try {
     if (tools == null) {
@@ -2991,20 +3115,26 @@ async function parseToolCall({
       }
       let repairedToolCall = null;
       try {
-        repairedToolCall = await repairToolCall({
-          toolCall,
-          tools,
-          inputSchema: async ({ toolName }) => {
-            var _a12;
-            const inputSchema = (_a12 = getOwn(tools, toolName)) == null ? void 0 : _a12.inputSchema;
-            return await asSchema2(inputSchema).jsonSchema;
-          },
-          instructions,
-          system: instructions,
-          messages,
-          error
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+        repairedToolCall = await waitForPromiseWithAbortSignal({
+          promise: repairToolCall({
+            toolCall,
+            tools,
+            inputSchema: async ({ toolName }) => {
+              var _a12;
+              const inputSchema = (_a12 = getOwn(tools, toolName)) == null ? void 0 : _a12.inputSchema;
+              return await asSchema2(inputSchema).jsonSchema;
+            },
+            instructions,
+            system: instructions,
+            messages,
+            error,
+            abortSignal
+          }),
+          abortSignal
         });
       } catch (repairError) {
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
         throw new ToolCallRepairError({
           cause: repairError,
           originalError: error
@@ -3013,12 +3143,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 safeParseJSON({ text: toolCall.input });
     const input = parsedInput.success ? parsedInput.value : toolCall.input;
     const tool2 = getOwn(tools, toolCall.toolName);
@@ -3037,6 +3170,34 @@ async function parseToolCall({
     };
   }
 }
+async function waitForPromiseWithAbortSignal({
+  promise,
+  abortSignal
+}) {
+  if (abortSignal == null) {
+    return await promise;
+  }
+  return await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      abortSignal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortSignal.reason);
+    };
+    Promise.resolve(promise).then((value) => {
+      cleanup();
+      resolve(value);
+    }).catch((error) => {
+      cleanup();
+      reject(error);
+    });
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+    if (abortSignal.aborted) {
+      onAbort();
+    }
+  });
+}
 async function refineParsedToolCallInput({
   toolCall,
   refineToolInput
@@ -3115,6 +3276,26 @@ async function doParseToolCall({
   };
 }
 
+// src/generate-text/validate-tool-context.ts
+import { validateTypes } from "@ai-sdk/provider-utils";
+async function validateToolContext({
+  toolName,
+  context,
+  contextSchema
+}) {
+  if (contextSchema == null) {
+    return context;
+  }
+  return await validateTypes({
+    value: context,
+    schema: contextSchema,
+    context: {
+      field: "tool context",
+      entityName: toolName
+    }
+  });
+}
+
 // src/tool-search/prepare-tool-search.ts
 import {
   experimental_getToolCaller as experimental_getToolCaller2
@@ -3304,7 +3485,7 @@ function collectToolApprovals({
 import { convertBase64ToUint8Array } from "@ai-sdk/provider-utils";
 
 // src/util/canonical-hash.ts
-import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+import { convertUint8ArrayToBase64 as convertUint8ArrayToBase642 } from "@ai-sdk/provider-utils";
 var encoder = new TextEncoder();
 function canonicalJSON(value) {
   if (value === null || value === void 0) {
@@ -3323,7 +3504,7 @@ function canonicalJSON(value) {
   return `{${entries.join(",")}}`;
 }
 function toBase64url(bytes) {
-  return convertUint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  return convertUint8ArrayToBase642(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 async function hashCanonical(value) {
   const digest = await crypto.subtle.digest(
@@ -3414,26 +3595,6 @@ import {
   safeValidateTypes as safeValidateTypes3
 } from "@ai-sdk/provider-utils";
 
-// src/generate-text/validate-tool-context.ts
-import { validateTypes } from "@ai-sdk/provider-utils";
-async function validateToolContext({
-  toolName,
-  context,
-  contextSchema
-}) {
-  if (contextSchema == null) {
-    return context;
-  }
-  return await validateTypes({
-    value: context,
-    schema: contextSchema,
-    context: {
-      field: "tool context",
-      entityName: toolName
-    }
-  });
-}
-
 // src/generate-text/resolve-tool-approval.ts
 async function resolveToolApproval({
   tools,
@@ -3803,6 +3964,7 @@ export {
   standardizePrompt,
   toResponseMessages,
   validateApprovedToolApprovals,
+  validateToolContext,
   verifyToolApprovalSignature
 };
 //# sourceMappingURL=index.js.map