ai 7.0.112 → 7.0.114

package/dist/internal/index.d.ts

@@ -2911,7 +2911,7 @@ declare function verifyToolApprovalSignature({ secret, signature, approvalId, to
  * message history before they are executed. Checks HMAC signature (when
  * configured), input schema, and approval policy.
  */
-declare function validateApprovedToolApprovals<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context | unknown | never>({ approvedToolApprovals, tools, toolApproval, messages, toolsContext, runtimeContext, toolApprovalSecret, }: {
+declare function validateApprovedToolApprovals<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context | unknown | never>({ approvedToolApprovals, tools, toolApproval, messages, toolsContext, runtimeContext, toolApprovalSecret, refineToolInput, }: {
     approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
     tools: TOOLS | undefined;
     toolApproval: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT> | undefined;
@@ -2919,6 +2919,7 @@ declare function validateApprovedToolApprovals<TOOLS extends ToolSet, RUNTIME_CO
     toolsContext: InferToolSetContext<TOOLS>;
     runtimeContext: RUNTIME_CONTEXT;
     toolApprovalSecret?: string | Uint8Array;
+    refineToolInput?: ToolInputRefinement<TOOLS>;
 }): Promise<{
     approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
     deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;

package/dist/internal/index.js

@@ -91,7 +91,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.112" : "0.0.0-test";
+var VERSION = true ? "7.0.114" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -1462,7 +1462,10 @@ var toolApprovalRequestSchema = z.object(
     type: z.literal("tool-approval-request"),
     approvalId: z.string(),
     toolCallId: z.string(),
-    reason: z.string().optional()
+    reason: z.string().optional(),
+    isAutomatic: z.boolean().optional(),
+    signature: z.string().optional(),
+    inputSchemaInput: z.unknown().optional()
   }
 );
 var toolApprovalResponseSchema = z.object({
@@ -2513,6 +2516,50 @@ function mergeCallbacks(...callbacks) {
 // src/telemetry/create-telemetry-dispatcher.ts
 import { asArray as asArray3 } from "@ai-sdk/provider-utils";
 
+// src/telemetry/filter-included-context.ts
+function filterIncludedContext({
+  context,
+  includeContext
+}) {
+  if (context == null) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(context).filter(
+      ([key]) => (includeContext == null ? void 0 : includeContext[key]) === true
+    )
+  );
+}
+function filterToolsContext({
+  toolsContext,
+  includeToolsContext
+}) {
+  if (includeToolsContext == null) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(toolsContext).map(([toolName, toolContext]) => [
+      toolName,
+      filterToolContext({
+        toolName,
+        toolContext,
+        includeToolsContext
+      })
+    ])
+  );
+}
+function filterToolContext({
+  toolName,
+  toolContext,
+  includeToolsContext
+}) {
+  const includeToolContext = includeToolsContext == null ? void 0 : includeToolsContext[toolName];
+  return filterIncludedContext({
+    context: toolContext,
+    includeContext: includeToolContext
+  });
+}
+
 // src/telemetry/tracing-channel.ts
 var AI_SDK_TELEMETRY_TRACING_CHANNEL = "ai:telemetry";
 
@@ -2663,12 +2710,37 @@ function getGlobalTelemetryIntegrations() {
 }
 
 // src/telemetry/create-telemetry-dispatcher.ts
-function augmentEvent(event, telemetry) {
-  return Object.assign(
+function augmentEvent(event, telemetry, filterContext = false) {
+  const augmentedEvent = Object.assign(
     Object.create(Object.getPrototypeOf(event)),
     event,
-    telemetry
+    {
+      recordInputs: telemetry.recordInputs,
+      recordOutputs: telemetry.recordOutputs,
+      functionId: telemetry.functionId
+    }
   );
+  if (filterContext && event != null && typeof event === "object" && "runtimeContext" in event) {
+    augmentedEvent.runtimeContext = filterIncludedContext({
+      context: event.runtimeContext,
+      includeContext: telemetry.includeRuntimeContext
+    });
+  }
+  if (filterContext && event != null && typeof event === "object") {
+    if ("toolsContext" in event) {
+      augmentedEvent.toolsContext = filterToolsContext({
+        toolsContext: event.toolsContext,
+        includeToolsContext: telemetry.includeToolsContext
+      });
+    } else if ("toolContext" in event && event.toolContext != null && "toolCall" in event && event.toolCall != null && typeof event.toolCall === "object" && "toolName" in event.toolCall) {
+      augmentedEvent.toolContext = filterToolContext({
+        toolName: event.toolCall.toolName,
+        toolContext: event.toolContext,
+        includeToolsContext: telemetry.includeToolsContext
+      });
+    }
+  }
+  return augmentedEvent;
 }
 function createTelemetryDispatcher({
   telemetry
@@ -2681,7 +2753,9 @@ function createTelemetryDispatcher({
   const telemetryMetadata = {
     recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
     recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
-    functionId: telemetry == null ? void 0 : telemetry.functionId
+    functionId: telemetry == null ? void 0 : telemetry.functionId,
+    includeRuntimeContext: telemetry == null ? void 0 : telemetry.includeRuntimeContext,
+    includeToolsContext: telemetry == null ? void 0 : telemetry.includeToolsContext
   };
   const mergeTelemetryCallback = (key) => {
     const integrationCallbacks = integrations.map((integration) => {
@@ -2707,14 +2781,14 @@ function createTelemetryDispatcher({
     runInTracingChannelSpan: async ({ type, event, execute }) => await runWithTracingChannelSpan(
       {
         type,
-        event: augmentEvent(event, telemetryMetadata)
+        event: augmentEvent(event, telemetryMetadata, true)
       },
       execute
     ),
     startTracingChannelContext: ({ type, event, completion }) => openTelemetryChannelSpanContext({
       message: {
         type,
-        event: augmentEvent(event, telemetryMetadata)
+        event: augmentEvent(event, telemetryMetadata, true)
       },
       completion
     }),
@@ -2789,21 +2863,6 @@ function createTelemetryDispatcher({
   };
 }
 
-// src/telemetry/filter-included-context.ts
-function filterIncludedContext({
-  context,
-  includeContext
-}) {
-  if (context == null) {
-    return {};
-  }
-  return Object.fromEntries(
-    Object.entries(context).filter(
-      ([key]) => (includeContext == null ? void 0 : includeContext[key]) === true
-    )
-  );
-}
-
 // src/generate-text/reasoning.ts
 function asReasoningText(reasoningParts) {
   const reasoningText = reasoningParts.map((part) => "text" in part ? part.text : "").join("");
@@ -2940,35 +2999,6 @@ function restrictStepResult({
     providerMetadata: step.providerMetadata
   });
 }
-function filterToolsContext({
-  toolsContext,
-  includeToolsContext
-}) {
-  if (includeToolsContext == null) {
-    return {};
-  }
-  return Object.fromEntries(
-    Object.entries(toolsContext).map(([toolName, toolContext]) => [
-      toolName,
-      filterToolContext({
-        toolName,
-        toolContext,
-        includeToolsContext
-      })
-    ])
-  );
-}
-function filterToolContext({
-  toolName,
-  toolContext,
-  includeToolsContext
-}) {
-  const includeToolContext = includeToolsContext == null ? void 0 : includeToolsContext[toolName];
-  return filterIncludedContext({
-    context: toolContext,
-    includeContext: includeToolContext
-  });
-}
 function createRestrictedTelemetryDispatcher({
   telemetry,
   includeRuntimeContext,
@@ -3113,6 +3143,20 @@ function getOwn(obj, key) {
   return obj != null && Object.hasOwn(obj, key) ? obj[key] : void 0;
 }
 
+// src/generate-text/tool-call.ts
+var inputSchemaInputSymbol = /* @__PURE__ */ Symbol("ai-sdk-tool-call-input-schema-input");
+function setToolCallInputSchemaInput(toolCall, inputSchemaInput) {
+  Object.defineProperty(toolCall, inputSchemaInputSymbol, {
+    value: inputSchemaInput
+  });
+  return toolCall;
+}
+function getToolCallInputSchemaInput(toolCall) {
+  return inputSchemaInputSymbol in toolCall ? {
+    value: toolCall[inputSchemaInputSymbol]
+  } : void 0;
+}
+
 // src/generate-text/parse-tool-call.ts
 async function parseToolCall({
   toolCall,
@@ -3235,10 +3279,12 @@ async function refineParsedToolCallInput({
   if (refine == null) {
     return toolCall;
   }
-  return {
+  const refinedToolCall = {
     ...toolCall,
     input: await refine(toolCall.input)
   };
+  const inputSchemaInput = getToolCallInputSchemaInput(toolCall);
+  return inputSchemaInput == null ? refinedToolCall : setToolCallInputSchemaInput(refinedToolCall, inputSchemaInput.value);
 }
 async function parseProviderExecutedDynamicToolCall(toolCall) {
   const parseResult = toolCall.input.trim() === "" ? { success: true, value: {} } : await safeParseJSON({ text: toolCall.input });
@@ -3283,26 +3329,29 @@ async function doParseToolCall({
       cause: parseResult.error
     });
   }
-  return tool2.type === "dynamic" ? {
-    type: "tool-call",
-    toolCallId: toolCall.toolCallId,
-    toolName: toolCall.toolName,
-    input: parseResult.value,
-    providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
-    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
-    dynamic: true,
-    title: tool2.title
-  } : {
-    type: "tool-call",
-    toolCallId: toolCall.toolCallId,
-    toolName,
-    input: parseResult.value,
-    providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
-    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
-    title: tool2.title
-  };
+  return setToolCallInputSchemaInput(
+    tool2.type === "dynamic" ? {
+      type: "tool-call",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      input: parseResult.value,
+      providerExecuted: toolCall.providerExecuted,
+      providerMetadata: toolCall.providerMetadata,
+      ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
+      dynamic: true,
+      title: tool2.title
+    } : {
+      type: "tool-call",
+      toolCallId: toolCall.toolCallId,
+      toolName,
+      input: parseResult.value,
+      providerExecuted: toolCall.providerExecuted,
+      providerMetadata: toolCall.providerMetadata,
+      ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
+      title: tool2.title
+    },
+    parseResult.rawValue
+  );
 }
 
 // src/generate-text/validate-tool-context.ts
@@ -3624,6 +3673,33 @@ import {
   safeValidateTypes as safeValidateTypes3
 } from "@ai-sdk/provider-utils";
 
+// src/util/is-deep-equal-data.ts
+function isDeepEqualData(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (obj1 == null || obj2 == null) return false;
+  if (typeof obj1 !== "object" && typeof obj2 !== "object")
+    return obj1 === obj2;
+  if (obj1.constructor !== obj2.constructor) return false;
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
+  }
+  if (Array.isArray(obj1)) {
+    if (obj1.length !== obj2.length) return false;
+    for (let i = 0; i < obj1.length; i++) {
+      if (!isDeepEqualData(obj1[i], obj2[i])) return false;
+    }
+    return true;
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!keys2.includes(key)) return false;
+    if (!isDeepEqualData(obj1[key], obj2[key])) return false;
+  }
+  return true;
+}
+
 // src/generate-text/resolve-tool-approval.ts
 async function resolveToolApproval({
   tools,
@@ -3687,14 +3763,15 @@ async function validateApprovedToolApprovals({
   messages,
   toolsContext,
   runtimeContext,
-  toolApprovalSecret
+  toolApprovalSecret,
+  refineToolInput
 }) {
   var _a12;
   const approved = [];
   const denied = [];
   const invalid = [];
   for (const approval of approvedToolApprovals) {
-    const { toolCall, approvalRequest } = approval;
+    const { approvalRequest, toolCall } = approval;
     const tool2 = getOwn(tools, toolCall.toolName);
     if (toolApprovalSecret != null) {
       if (approvalRequest.signature == null) {
@@ -3721,17 +3798,42 @@ async function validateApprovedToolApprovals({
       }
     }
     if (isExecutableTool(tool2) && tool2.inputSchema != null) {
+      const hasInputSchemaInput = Object.prototype.hasOwnProperty.call(
+        approvalRequest,
+        "inputSchemaInput"
+      );
       const validation = await safeValidateTypes3({
-        value: toolCall.input,
+        value: hasInputSchemaInput ? approvalRequest.inputSchemaInput : toolCall.input,
         schema: asSchema3(tool2.inputSchema)
       });
+      let validationError;
       if (!validation.success) {
+        validationError = validation.error;
+      } else {
+        try {
+          const revalidatedToolCall = await refineParsedToolCallInput({
+            toolCall: {
+              ...toolCall,
+              input: validation.value
+            },
+            refineToolInput
+          });
+          if (!isDeepEqualData(revalidatedToolCall.input, toolCall.input)) {
+            validationError = new Error(
+              "Approved tool input does not match the validated schema output."
+            );
+          }
+        } catch (error) {
+          validationError = error;
+        }
+      }
+      if (validationError != null) {
         invalid.push({
           ...approval,
           error: new InvalidToolInputError({
             toolName: toolCall.toolName,
             toolInput: JSON.stringify(toolCall.input),
-            cause: validation.error
+            cause: validationError
           })
         });
         continue;
@@ -3869,13 +3971,15 @@ async function toResponseMessages({
         break;
       }
       case "tool-approval-request":
+        const inputSchemaInput = getToolCallInputSchemaInput(part.toolCall);
         content.push({
           type: "tool-approval-request",
           approvalId: part.approvalId,
           toolCallId: part.toolCall.toolCallId,
           ...part.reason != null ? { reason: part.reason } : {},
           isAutomatic: part.isAutomatic,
-          ...part.signature != null ? { signature: part.signature } : {}
+          ...part.signature != null ? { signature: part.signature } : {},
+          ...inputSchemaInput != null && !isDeepEqualData(inputSchemaInput.value, part.toolCall.input) ? { inputSchemaInput: inputSchemaInput.value } : {}
         });
         break;
     }