ai 7.0.112 → 7.0.114

package/src/generate-text/generated-file.ts

@@ -78,12 +78,4 @@ export class DefaultGeneratedFile implements GeneratedFile {
 
 export class DefaultGeneratedFileWithType extends DefaultGeneratedFile {
   readonly type = 'file';
-
-  constructor(options: {
-    data: string | Uint8Array;
-    mediaType: string;
-    providerMetadata?: Record<string, JSONObject>;
-  }) {
-    super(options);
-  }
 }

package/src/generate-text/invoke-tool-callbacks-from-stream.ts

@@ -35,7 +35,7 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
     string,
     {
       toolName: string;
-      validatedContext: Promise<unknown> | undefined;
+      validatedContexts: Record<string, Promise<unknown> | undefined>;
     }
   > = createIdMap();
 
@@ -48,22 +48,23 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
   }): Promise<unknown> => {
     const ongoingToolCall = ongoingToolCalls[toolCallId];
 
-    if (ongoingToolCall?.validatedContext != null) {
-      return ongoingToolCall.validatedContext;
+    const validatedContext = ongoingToolCall?.validatedContexts[toolName];
+    if (validatedContext != null) {
+      return validatedContext;
     }
 
     const tool = getOwn(tools, toolName);
-    const validatedContext = validateToolContext({
+    const newValidatedContext = validateToolContext({
       toolName,
       context: getOwn(toolsContext, toolName),
       contextSchema: tool?.contextSchema,
     });
 
     if (ongoingToolCall != null) {
-      ongoingToolCall.validatedContext = validatedContext;
+      ongoingToolCall.validatedContexts[toolName] = newValidatedContext;
     }
 
-    return validatedContext;
+    return newValidatedContext;
   };
 
   return stream.pipeThrough(
@@ -80,7 +81,7 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
           case 'tool-input-start': {
             ongoingToolCalls[chunk.id] = {
               toolName: chunk.toolName,
-              validatedContext: undefined,
+              validatedContexts: createIdMap(),
             };
 
             const tool = getOwn(tools, chunk.toolName);
@@ -120,7 +121,7 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
           }
 
           case 'tool-call': {
-            const toolName = ongoingToolCalls[chunk.toolCallId]?.toolName;
+            const toolName = chunk.toolName;
             const tool = getOwn(tools, toolName);
 
             if (!chunk.invalid && tool?.onInputAvailable != null) {

package/src/generate-text/output.ts

@@ -487,8 +487,6 @@ function getArrayLengthValidationError({
       cause: `elements array must contain at most ${maxItems} items`,
     });
   }
-
-  return undefined;
 }
 
 /**

package/src/generate-text/parse-tool-call.ts

@@ -12,7 +12,12 @@ import { NoSuchToolError } from '../error/no-such-tool-error';
 import { ToolCallRepairError } from '../error/tool-call-repair-error';
 import type { Instructions } from '../prompt';
 import { getOwn } from '../util/get-own';
-import type { DynamicToolCall, TypedToolCall } from './tool-call';
+import {
+  getToolCallInputSchemaInput,
+  setToolCallInputSchemaInput,
+  type DynamicToolCall,
+  type TypedToolCall,
+} from './tool-call';
 import type { ToolCallRepairFunction } from './tool-call-repair-function';
 import type { ToolInputRefinement } from './tool-input-refinement';
 
@@ -167,7 +172,7 @@ async function waitForPromiseWithAbortSignal<T>({
   });
 }
 
-async function refineParsedToolCallInput<TOOLS extends ToolSet>({
+export async function refineParsedToolCallInput<TOOLS extends ToolSet>({
   toolCall,
   refineToolInput,
 }: {
@@ -180,10 +185,15 @@ async function refineParsedToolCallInput<TOOLS extends ToolSet>({
     return toolCall;
   }
 
-  return {
+  const refinedToolCall = {
     ...toolCall,
     input: await refine(toolCall.input as InferToolInput<TOOLS[keyof TOOLS]>),
   } as TypedToolCall<TOOLS>;
+
+  const inputSchemaInput = getToolCallInputSchemaInput(toolCall);
+  return inputSchemaInput == null
+    ? refinedToolCall
+    : setToolCallInputSchemaInput(refinedToolCall, inputSchemaInput.value);
 }
 
 async function parseProviderExecutedDynamicToolCall(
@@ -253,26 +263,29 @@ async function doParseToolCall<TOOLS extends ToolSet>({
     });
   }
 
-  return tool.type === 'dynamic'
-    ? {
-        type: 'tool-call',
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        input: parseResult.value,
-        providerExecuted: toolCall.providerExecuted,
-        providerMetadata: toolCall.providerMetadata,
-        ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
-        dynamic: true,
-        title: tool.title,
-      }
-    : {
-        type: 'tool-call',
-        toolCallId: toolCall.toolCallId,
-        toolName,
-        input: parseResult.value,
-        providerExecuted: toolCall.providerExecuted,
-        providerMetadata: toolCall.providerMetadata,
-        ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
-        title: tool.title,
-      };
+  return setToolCallInputSchemaInput(
+    tool.type === 'dynamic'
+      ? {
+          type: 'tool-call',
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          input: parseResult.value,
+          providerExecuted: toolCall.providerExecuted,
+          providerMetadata: toolCall.providerMetadata,
+          ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
+          dynamic: true,
+          title: tool.title,
+        }
+      : {
+          type: 'tool-call',
+          toolCallId: toolCall.toolCallId,
+          toolName,
+          input: parseResult.value,
+          providerExecuted: toolCall.providerExecuted,
+          providerMetadata: toolCall.providerMetadata,
+          ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
+          title: tool.title,
+        },
+    parseResult.rawValue,
+  );
 }

package/src/generate-text/restricted-telemetry-dispatcher.ts

@@ -1,10 +1,9 @@
-import type {
-  Context,
-  InferToolContext,
-  InferToolSetContext,
-  ToolSet,
-} from '@ai-sdk/provider-utils';
-import { filterIncludedContext } from '../telemetry/filter-included-context';
+import type { Context, ToolSet } from '@ai-sdk/provider-utils';
+import {
+  filterIncludedContext,
+  filterToolContext,
+  filterToolsContext,
+} from '../telemetry/filter-included-context';
 import { createTelemetryDispatcher } from '../telemetry/create-telemetry-dispatcher';
 import type { TelemetryDispatcher } from '../telemetry/telemetry';
 import type {
@@ -98,57 +97,6 @@ function restrictStepResult<
   });
 }
 
-/**
- * Returns a shallow copy of the tools context with only top-level properties
- * marked for telemetry inclusion for each tool.
- */
-function filterToolsContext<TOOLS extends ToolSet>({
-  toolsContext,
-  includeToolsContext,
-}: {
-  toolsContext: InferToolSetContext<TOOLS>;
-  includeToolsContext: IncludedToolsContext<TOOLS>;
-}): InferToolSetContext<TOOLS> {
-  if (includeToolsContext == null) {
-    return {} as InferToolSetContext<TOOLS>;
-  }
-
-  return Object.fromEntries(
-    Object.entries(toolsContext).map(([toolName, toolContext]) => [
-      toolName,
-      filterToolContext({
-        toolName,
-        toolContext,
-        includeToolsContext,
-      }),
-    ]),
-  ) as InferToolSetContext<TOOLS>;
-}
-
-function filterToolContext<TOOLS extends ToolSet>({
-  toolName,
-  toolContext,
-  includeToolsContext,
-}: {
-  toolName: string;
-  toolContext: unknown;
-  includeToolsContext: IncludedToolsContext<TOOLS>;
-}) {
-  const includeToolContext = (
-    includeToolsContext as
-      | Record<
-          string,
-          IncludedContext<InferToolContext<TOOLS[typeof toolName]>>
-        >
-      | undefined
-  )?.[toolName];
-
-  return filterIncludedContext({
-    context: toolContext as InferToolContext<TOOLS[typeof toolName]>,
-    includeContext: includeToolContext,
-  });
-}
-
 /**
  * Creates a telemetry dispatcher that only includes configured runtime context
  * properties in text-generation lifecycle events before dispatching them.

package/src/generate-text/stream-text.ts

@@ -2046,6 +2046,7 @@ class DefaultStreamTextResult<
           toolsContext,
           runtimeContext,
           toolApprovalSecret: experimental_toolApprovalSecret,
+          refineToolInput,
         });
 
         const localDeniedToolApprovals = [

package/src/generate-text/to-response-messages.ts

@@ -6,8 +6,10 @@ import type {
 } from '../prompt';
 import { createToolModelOutput } from '../prompt/create-tool-model-output';
 import { getOwn } from '../util/get-own';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import type { ContentPart } from './content-part';
 import type { ToolSet } from '@ai-sdk/provider-utils';
+import { getToolCallInputSchemaInput } from './tool-call';
 
 /**
  * Converts the result of a `generateText` or `streamText` call to a list of response messages.
@@ -129,6 +131,7 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
         break;
       }
       case 'tool-approval-request':
+        const inputSchemaInput = getToolCallInputSchemaInput(part.toolCall);
         content.push({
           type: 'tool-approval-request',
           approvalId: part.approvalId,
@@ -136,6 +139,10 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
           ...(part.reason != null ? { reason: part.reason } : {}),
           isAutomatic: part.isAutomatic,
           ...(part.signature != null ? { signature: part.signature } : {}),
+          ...(inputSchemaInput != null &&
+          !isDeepEqualData(inputSchemaInput.value, part.toolCall.input)
+            ? { inputSchemaInput: inputSchemaInput.value }
+            : {}),
         });
         break;
     }

package/src/generate-text/tool-call.ts

@@ -3,6 +3,8 @@ import type { InferToolInput, ToolSet } from '@ai-sdk/provider-utils';
 import type { ProviderMetadata } from '../types';
 import type { ValueOf } from '../util/value-of';
 
+const inputSchemaInputSymbol = Symbol('ai-sdk-tool-call-input-schema-input');
+
 type BaseToolCall = {
   type: 'tool-call';
   toolCallId: string;
@@ -58,3 +60,27 @@ export type DynamicToolCall = BaseToolCall & {
 export type TypedToolCall<TOOLS extends ToolSet> =
   | StaticToolCall<TOOLS>
   | DynamicToolCall;
+
+export function setToolCallInputSchemaInput<TOOLS extends ToolSet>(
+  toolCall: TypedToolCall<TOOLS>,
+  inputSchemaInput: unknown,
+): TypedToolCall<TOOLS> {
+  Object.defineProperty(toolCall, inputSchemaInputSymbol, {
+    value: inputSchemaInput,
+  });
+  return toolCall;
+}
+
+export function getToolCallInputSchemaInput<TOOLS extends ToolSet>(
+  toolCall: TypedToolCall<TOOLS>,
+): { value: unknown } | undefined {
+  return inputSchemaInputSymbol in toolCall
+    ? {
+        value: (
+          toolCall as TypedToolCall<TOOLS> & {
+            [inputSchemaInputSymbol]: unknown;
+          }
+        )[inputSchemaInputSymbol],
+      }
+    : undefined;
+}

package/src/generate-text/validate-tool-approvals.ts

@@ -10,10 +10,13 @@ import {
 import { InvalidToolApprovalSignatureError } from '../error/invalid-tool-approval-signature-error';
 import { InvalidToolInputError } from '../error/invalid-tool-input-error';
 import { getOwn } from '../util/get-own';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import type { CollectedToolApprovals } from './collect-tool-approvals';
+import { refineParsedToolCallInput } from './parse-tool-call';
 import { resolveToolApproval } from './resolve-tool-approval';
 import { verifyToolApprovalSignature } from './tool-approval-signature';
 import type { ToolApprovalConfiguration } from './tool-approval-configuration';
+import type { ToolInputRefinement } from './tool-input-refinement';
 
 /**
  * Re-validates approved tool approvals reconstructed from client-supplied
@@ -31,6 +34,7 @@ export async function validateApprovedToolApprovals<
   toolsContext,
   runtimeContext,
   toolApprovalSecret,
+  refineToolInput,
 }: {
   approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
   tools: TOOLS | undefined;
@@ -39,6 +43,7 @@ export async function validateApprovedToolApprovals<
   toolsContext: InferToolSetContext<TOOLS>;
   runtimeContext: RUNTIME_CONTEXT;
   toolApprovalSecret?: string | Uint8Array;
+  refineToolInput?: ToolInputRefinement<TOOLS>;
 }): Promise<{
   approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
   deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
@@ -53,7 +58,7 @@ export async function validateApprovedToolApprovals<
   > = [];
 
   for (const approval of approvedToolApprovals) {
-    const { toolCall, approvalRequest } = approval;
+    const { approvalRequest, toolCall } = approval;
     // Look up the tool by own property only: `toolName` comes from
     // client-supplied history, so a name matching an inherited object property
     // (e.g. `constructor`, `toString`) must resolve to "no such tool" rather
@@ -88,18 +93,49 @@ export async function validateApprovedToolApprovals<
     }
 
     if (isExecutableTool(tool) && tool.inputSchema != null) {
+      const hasInputSchemaInput = Object.prototype.hasOwnProperty.call(
+        approvalRequest,
+        'inputSchemaInput',
+      );
       const validation = await safeValidateTypes({
-        value: toolCall.input,
+        value: hasInputSchemaInput
+          ? approvalRequest.inputSchemaInput
+          : toolCall.input,
         schema: asSchema(tool.inputSchema),
       });
 
+      let validationError: unknown;
       if (!validation.success) {
+        validationError = validation.error;
+      } else {
+        try {
+          const revalidatedToolCall = await refineParsedToolCallInput({
+            toolCall: {
+              ...toolCall,
+              input: validation.value,
+            },
+            refineToolInput,
+          });
+
+          // Revalidation must never change the operation that was approved,
+          // including when older or projected history omits the schema input.
+          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;

package/src/generate-video/generate-video.ts

@@ -890,8 +890,6 @@ function normalizeImageData(
       data: bytes,
     };
   }
-
-  return undefined;
 }
 
 /**

package/src/middleware/extract-reasoning-middleware.ts

@@ -24,7 +24,7 @@ export function extractReasoningMiddleware({
   startWithReasoning?: boolean;
 }): LanguageModelMiddleware {
   const openingTag = `<${tagName}>`;
-  const closingTag = `<\/${tagName}>`;
+  const closingTag = `</${tagName}>`;
 
   return {
     specificationVersion: 'v4',

package/src/middleware/wrap-embedding-model.ts

@@ -7,12 +7,17 @@ import type {
 import {
   asArray,
   EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL,
+  EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
 } from '@ai-sdk/provider-utils';
 import { asEmbeddingModelV4 } from '../model/as-embedding-model-v4';
 import {
   getEmbeddingModelMaxInputBytesPerCall,
   type EmbeddingModelWithMaxInputBytesPerCall,
 } from '../model/get-embedding-model-max-input-bytes-per-call';
+import {
+  getEmbeddingModelProviderOptionsTransformer,
+  type EmbeddingModelWithProviderOptionsTransformer,
+} from '../model/get-embedding-model-provider-options-transformer';
 import type { EmbeddingModelMiddleware } from '../types';
 
 /**
@@ -63,7 +68,8 @@ const doWrap = ({
   middleware: EmbeddingModelMiddleware;
   modelId?: string;
   providerId?: string;
-}): EmbeddingModelWithMaxInputBytesPerCall => {
+}): EmbeddingModelWithMaxInputBytesPerCall &
+  EmbeddingModelWithProviderOptionsTransformer => {
   async function doTransform({
     params,
   }: {
@@ -80,6 +86,8 @@ const doWrap = ({
       overrideMaxEmbeddingsPerCall?.({ model }) ?? model.maxEmbeddingsPerCall,
     [EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL]:
       getEmbeddingModelMaxInputBytesPerCall(model),
+    [EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER]:
+      getEmbeddingModelProviderOptionsTransformer(model),
     supportsParallelCalls:
       overrideSupportsParallelCalls?.({ model }) ?? model.supportsParallelCalls,
     async doEmbed(

package/src/model/get-embedding-model-provider-options-transformer.ts

@@ -0,0 +1,17 @@
+import type { EmbeddingModelV4 } from '@ai-sdk/provider';
+import {
+  EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
+  type EmbeddingModelProviderOptionsTransformer,
+} from '@ai-sdk/provider-utils';
+
+export type EmbeddingModelWithProviderOptionsTransformer = EmbeddingModelV4 & {
+  readonly [EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER]?: EmbeddingModelProviderOptionsTransformer;
+};
+
+export function getEmbeddingModelProviderOptionsTransformer(
+  model: EmbeddingModelV4,
+) {
+  return (model as EmbeddingModelWithProviderOptionsTransformer)[
+    EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER
+  ];
+}

package/src/prompt/content-part.ts

@@ -284,6 +284,9 @@ export const toolApprovalRequestSchema: ZodType<ToolApprovalRequest> = z.object(
     approvalId: z.string(),
     toolCallId: z.string(),
     reason: z.string().optional(),
+    isAutomatic: z.boolean().optional(),
+    signature: z.string().optional(),
+    inputSchemaInput: z.unknown().optional(),
   },
 );
 

package/src/prompt/standardize-prompt.ts

@@ -82,6 +82,8 @@ export async function standardizePrompt({
     });
   }
 
+  // Require explicit trust in supplied system messages to reduce prompt-injection
+  // risk. The opt-in permits all system messages, including instruction text.
   if (
     !allowSystemInMessages &&
     messages.some(message => message.role === 'system')

package/src/registry/custom-provider.ts

@@ -1,6 +1,7 @@
 import {
   type Experimental_EvaluationModelV4 as EvaluationModelV4,
   type EmbeddingModelV4,
+  type Experimental_VideoModelV3,
   type Experimental_VideoModelV4,
   type FilesV4,
   type ImageModelV4,
@@ -35,6 +36,12 @@ import type { SpeechModel } from '../types/speech-model';
 import type { TranscriptionModel } from '../types/transcription-model';
 import type { VideoModel } from '../types/video-model';
 
+type ProviderWithOptionalVideoModel = {
+  videoModel?: (
+    modelId: string,
+  ) => Experimental_VideoModelV3 | Experimental_VideoModelV4;
+};
+
 /**
  * Creates a custom provider with specified language models, text embedding models, image models, transcription models, speech models, file APIs, skill APIs, and an optional fallback provider.
  *
@@ -247,11 +254,11 @@ export function customProvider<
         return resolveVideoModel(videoModels[modelId]);
       }
 
-      // TODO AI SDK v7
-      // @ts-expect-error - videoModel support is experimental
-      const videoModel = fallbackProvider?.videoModel;
-      if (videoModel) {
-        return videoModel(modelId);
+      const provider = fallbackProviderArg as
+        | ProviderWithOptionalVideoModel
+        | undefined;
+      if (provider?.videoModel) {
+        return resolveVideoModel(provider.videoModel(modelId));
       }
 
       throw new NoSuchModelError({ modelId, modelType: 'videoModel' });

package/src/telemetry/create-telemetry-dispatcher.ts

@@ -1,5 +1,10 @@
-import { asArray } from '@ai-sdk/provider-utils';
+import { asArray, type Context } from '@ai-sdk/provider-utils';
 import type { Callback } from '../util/callback';
+import {
+  filterIncludedContext,
+  filterToolContext,
+  filterToolsContext,
+} from './filter-included-context';
 import { mergeCallbacks } from '../util/merge-callbacks';
 import type {
   InferTelemetryEvent,
@@ -41,14 +46,59 @@ function augmentEvent<EVENT>(
   event: EVENT,
   telemetry: Pick<
     TelemetryOptions,
-    'recordInputs' | 'recordOutputs' | 'functionId'
+    | 'recordInputs'
+    | 'recordOutputs'
+    | 'functionId'
+    | 'includeRuntimeContext'
+    | 'includeToolsContext'
   >,
+  filterContext = false,
 ): InferTelemetryEvent<EVENT> {
-  return Object.assign(
+  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 as Context,
+      includeContext: telemetry.includeRuntimeContext,
+    });
+  }
+
+  if (filterContext && event != null && typeof event === 'object') {
+    if ('toolsContext' in event) {
+      augmentedEvent.toolsContext = filterToolsContext({
+        toolsContext: event.toolsContext as Record<string, Context>,
+        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 as string,
+        toolContext: event.toolContext,
+        includeToolsContext: telemetry.includeToolsContext,
+      });
+    }
+  }
+
+  return augmentedEvent;
 }
 
 /**
@@ -86,6 +136,8 @@ export function createTelemetryDispatcher({
     recordInputs: telemetry?.recordInputs,
     recordOutputs: telemetry?.recordOutputs,
     functionId: telemetry?.functionId,
+    includeRuntimeContext: telemetry?.includeRuntimeContext,
+    includeToolsContext: telemetry?.includeToolsContext,
   };
 
   const mergeTelemetryCallback = <KEY extends TelemetryCallbackKey>(
@@ -127,7 +179,7 @@ export function createTelemetryDispatcher({
       await runWithTracingChannelSpan(
         {
           type,
-          event: augmentEvent(event, telemetryMetadata),
+          event: augmentEvent(event, telemetryMetadata, true),
         },
         execute,
       ),
@@ -136,7 +188,7 @@ export function createTelemetryDispatcher({
       openTelemetryChannelSpanContext({
         message: {
           type,
-          event: augmentEvent(event, telemetryMetadata),
+          event: augmentEvent(event, telemetryMetadata, true),
         },
         completion,
       }),