ai 7.0.84 → 7.0.86

package/src/generate-image/generate-image-result.ts

@@ -1,9 +1,40 @@
+import type { ImageModelV4ProviderMetadata } from '@ai-sdk/provider';
 import type { GeneratedFile } from '../generate-text';
 import type { ImageModelProviderMetadata } from '../types/image-model';
 import type { ImageModelResponseMetadata } from '../types/image-model-response-metadata';
 import type { ImageModelUsage } from '../types/usage';
 import type { Warning } from '../types/warning';
 
+/**
+ * The result of one underlying image model call.
+ */
+export interface GenerateImageCall {
+  /**
+   * The images generated by this call.
+   */
+  readonly images: Array<GeneratedFile>;
+
+  /**
+   * Provider-specific metadata for this call.
+   */
+  readonly providerMetadata?: ImageModelV4ProviderMetadata;
+
+  /**
+   * Response metadata from the provider.
+   */
+  readonly response: ImageModelResponseMetadata;
+
+  /**
+   * Warnings for this call, e.g. unsupported settings.
+   */
+  readonly warnings: Array<Warning>;
+
+  /**
+   * Token usage for this call, if reported by the provider.
+   */
+  readonly usage?: ImageModelUsage;
+}
+
 /**
  * The result of a `generateImage` call.
  * It contains the images and additional information.
@@ -19,6 +50,11 @@ export interface GenerateImageResult {
    */
   readonly images: Array<GeneratedFile>;
 
+  /**
+   * The results of the underlying image model calls.
+   */
+  readonly calls: Array<GenerateImageCall>;
+
   /**
    * Warnings for the call, e.g. unsupported settings.
    */
@@ -26,12 +62,16 @@ export interface GenerateImageResult {
 
   /**
    * Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+   *
+   * @deprecated Use `calls` to preserve each response with its corresponding images, metadata, warnings, and usage.
    */
   readonly responses: Array<ImageModelResponseMetadata>;
 
   /**
    * Provider-specific metadata. They are passed through from the provider to the AI SDK and enable provider-specific
    * results that can be fully encapsulated in the provider.
+   *
+   * @deprecated Use the provider metadata in `calls` or on individual `images` to preserve its scope.
    */
   readonly providerMetadata: ImageModelProviderMetadata;
 

package/src/generate-image/generate-image.ts

@@ -1,8 +1,10 @@
-import type {
-  ImageModelV4,
-  ImageModelV4CallOptions,
-  ImageModelV4File,
-  ImageModelV4ProviderMetadata,
+import {
+  isJSONObject,
+  type ImageModelV4,
+  type ImageModelV4CallOptions,
+  type ImageModelV4File,
+  type ImageModelV4ProviderMetadata,
+  type JSONObject,
 } from '@ai-sdk/provider';
 import {
   convertBase64ToUint8Array,
@@ -24,10 +26,27 @@ import { addImageModelUsage, type ImageModelUsage } from '../types/usage';
 import type { Warning } from '../types/warning';
 import { prepareRetries } from '../util/prepare-retries';
 import { VERSION } from '../version';
-import type { GenerateImageResult } from './generate-image-result';
+import type {
+  GenerateImageCall,
+  GenerateImageResult,
+} from './generate-image-result';
 import { convertDataContentToUint8Array } from '../prompt/data-content';
 import { splitDataUrl } from '../prompt/split-data-url';
 
+const gatewayCostMetadataKeys = [
+  'cost',
+  'gatewayCost',
+  'inferenceCost',
+  'inputInferenceCost',
+  'marketCost',
+  'outputInferenceCost',
+  'surchargeCost',
+] as const;
+
+type GatewayCostMetadata = {
+  [key in (typeof gatewayCostMetadataKeys)[number]]?: unknown;
+};
+
 export type GenerateImagePrompt =
   | string
   | {
@@ -187,7 +206,8 @@ export async function generateImage({
   );
 
   // collect result images, warnings, and response metadata
-  const images: Array<DefaultGeneratedFile> = [];
+  const images: Array<GeneratedFile> = [];
+  const calls: Array<GenerateImageCall> = [];
   const warnings: Array<Warning> = [];
   const responses: Array<ImageModelResponseMetadata> = [];
   const providerMetadata: ImageModelV4ProviderMetadata = {};
@@ -197,19 +217,29 @@ export async function generateImage({
     totalTokens: undefined,
   };
   for (const result of results) {
-    images.push(
-      ...result.images.map(
-        image =>
-          new DefaultGeneratedFile({
-            data: image,
-            mediaType:
-              detectMediaType({
-                data: image,
-                topLevelType: 'image',
-              }) ?? 'image/png',
-          }),
-      ),
+    const callImages = result.images.map(
+      (image, index) =>
+        new DefaultGeneratedFile({
+          data: image,
+          mediaType:
+            detectMediaType({
+              data: image,
+              topLevelType: 'image',
+            }) ?? 'image/png',
+          providerMetadata: getImageProviderMetadata(
+            result.providerMetadata,
+            index,
+          ),
+        }),
     );
+    images.push(...callImages);
+    calls.push({
+      images: callImages,
+      providerMetadata: result.providerMetadata,
+      response: result.response,
+      warnings: result.warnings,
+      usage: result.usage,
+    });
     warnings.push(...result.warnings);
 
     if (result.usage != null) {
@@ -217,19 +247,33 @@ export async function generateImage({
     }
 
     if (result.providerMetadata) {
-      for (const [providerName, metadata] of Object.entries<{
-        images: unknown;
-      }>(result.providerMetadata)) {
+      for (const [providerName, metadata] of Object.entries(
+        result.providerMetadata,
+      )) {
         if (providerName === 'gateway') {
           const currentEntry = providerMetadata[providerName];
           if (currentEntry != null && typeof currentEntry === 'object') {
+            const currentGatewayMetadata = currentEntry as GatewayCostMetadata;
+            const newGatewayMetadata = metadata as GatewayCostMetadata;
+
             providerMetadata[providerName] = {
               ...(currentEntry as object),
-              ...metadata,
+              ...(metadata as object),
+              ...Object.fromEntries(
+                gatewayCostMetadataKeys.flatMap(key => {
+                  const total = addDecimalStrings(
+                    currentGatewayMetadata[key],
+                    newGatewayMetadata[key],
+                  );
+
+                  return total == null ? [] : [[key, total]];
+                }),
+              ),
             } as ImageModelV4ProviderMetadata[string];
           } else {
-            providerMetadata[providerName] =
-              metadata as ImageModelV4ProviderMetadata[string];
+            providerMetadata[providerName] = {
+              ...(metadata as object),
+            } as ImageModelV4ProviderMetadata[string];
           }
           const imagesValue = (
             providerMetadata[providerName] as { images?: unknown }
@@ -240,9 +284,7 @@ export async function generateImage({
           }
         } else {
           providerMetadata[providerName] ??= { images: [] };
-          providerMetadata[providerName].images.push(
-            ...result.providerMetadata[providerName].images,
-          );
+          providerMetadata[providerName].images.push(...metadata.images);
         }
       }
     }
@@ -258,6 +300,7 @@ export async function generateImage({
 
   return new DefaultGenerateImageResult({
     images,
+    calls,
     warnings,
     responses,
     providerMetadata,
@@ -267,6 +310,7 @@ export async function generateImage({
 
 class DefaultGenerateImageResult implements GenerateImageResult {
   readonly images: Array<GeneratedFile>;
+  readonly calls: Array<GenerateImageCall>;
   readonly warnings: Array<Warning>;
   readonly responses: Array<ImageModelResponseMetadata>;
   readonly providerMetadata: ImageModelV4ProviderMetadata;
@@ -274,12 +318,14 @@ class DefaultGenerateImageResult implements GenerateImageResult {
 
   constructor(options: {
     images: Array<GeneratedFile>;
+    calls: Array<GenerateImageCall>;
     warnings: Array<Warning>;
     responses: Array<ImageModelResponseMetadata>;
     providerMetadata: ImageModelV4ProviderMetadata;
     usage: ImageModelUsage;
   }) {
     this.images = options.images;
+    this.calls = options.calls;
     this.warnings = options.warnings;
     this.responses = options.responses;
     this.providerMetadata = options.providerMetadata;
@@ -291,6 +337,30 @@ class DefaultGenerateImageResult implements GenerateImageResult {
   }
 }
 
+/**
+ * Extracts per-image metadata from the legacy `providerMetadata.<provider>.images` result shape.
+ */
+function getImageProviderMetadata(
+  providerMetadata: ImageModelV4ProviderMetadata | undefined,
+  imageIndex: number,
+): Record<string, JSONObject> | undefined {
+  if (providerMetadata == null) {
+    return undefined;
+  }
+
+  let imageMetadata: Record<string, JSONObject> | undefined;
+
+  for (const [providerName, metadata] of Object.entries(providerMetadata)) {
+    const value = metadata.images?.[imageIndex];
+
+    if (isJSONObject(value) && !Array.isArray(value)) {
+      (imageMetadata ??= {})[providerName] = value;
+    }
+  }
+
+  return imageMetadata;
+}
+
 async function invokeModelMaxImagesPerCall(model: ImageModelV4) {
   const isFunction = model.maxImagesPerCall instanceof Function;
 
@@ -303,6 +373,34 @@ async function invokeModelMaxImagesPerCall(model: ImageModelV4) {
   });
 }
 
+function addDecimalStrings(
+  value1: unknown,
+  value2: unknown,
+): string | undefined {
+  if (
+    typeof value1 !== 'string' ||
+    typeof value2 !== 'string' ||
+    !/^\d+(?:\.\d+)?$/.test(value1) ||
+    !/^\d+(?:\.\d+)?$/.test(value2)
+  ) {
+    return undefined;
+  }
+
+  const [integer1, fraction1 = ''] = value1.split('.');
+  const [integer2, fraction2 = ''] = value2.split('.');
+  const precision = Math.max(fraction1.length, fraction2.length);
+  const sum =
+    BigInt(integer1 + fraction1.padEnd(precision, '0')) +
+    BigInt(integer2 + fraction2.padEnd(precision, '0'));
+  const sumString = sum.toString().padStart(precision + 1, '0');
+
+  return precision === 0
+    ? sumString
+    : `${sumString.slice(0, -precision)}.${sumString.slice(
+        -precision,
+      )}`.replace(/\.?0+$/, '');
+}
+
 function normalizePrompt(
   prompt: GenerateImagePrompt,
 ): Pick<ImageModelV4CallOptions, 'prompt' | 'files' | 'mask'> {

package/src/generate-image/index.ts

@@ -1,2 +1,5 @@
 export { generateImage } from './generate-image';
-export type { GenerateImageResult } from './generate-image-result';
+export type {
+  GenerateImageCall,
+  GenerateImageResult,
+} from './generate-image-result';

package/src/generate-text/convert-language-model-content.ts

@@ -0,0 +1,206 @@
+import type { LanguageModelV4Content } from '@ai-sdk/provider';
+import type { ToolSet } from '@ai-sdk/provider-utils';
+import { ToolCallNotFoundForApprovalError } from '../error/tool-call-not-found-for-approval-error';
+import { getOwn } from '../util/get-own';
+import type { ContentPart } from './content-part';
+import { DefaultGeneratedFile } from './generated-file';
+import type { ToolApprovalRequestOutput } from './tool-approval-request-output';
+import type { ToolApprovalResponseOutput } from './tool-approval-response-output';
+import type { TypedToolCall } from './tool-call';
+import type { TypedToolError } from './tool-error';
+import type { ToolOutput } from './tool-output';
+import type { TypedToolResult } from './tool-result';
+
+export function convertLanguageModelContent<TOOLS extends ToolSet>({
+  content,
+  toolCalls,
+  toolOutputs,
+  toolApprovalRequests,
+  toolApprovalResponses,
+  tools,
+}: {
+  content: Array<LanguageModelV4Content>;
+  toolCalls: Array<TypedToolCall<TOOLS>>;
+  toolOutputs: Array<ToolOutput<TOOLS>>;
+  toolApprovalRequests: Array<ToolApprovalRequestOutput<TOOLS>>;
+  toolApprovalResponses: Array<ToolApprovalResponseOutput<TOOLS>>;
+  tools: TOOLS | undefined;
+}): Array<ContentPart<TOOLS>> {
+  const contentParts: Array<ContentPart<TOOLS>> = [];
+  const toolOutputsWithApprovalResponses: Array<ToolOutput<TOOLS>> = [];
+  const toolOutputsWithoutApprovalResponses: Array<ToolOutput<TOOLS>> = [];
+  const toolCallIdsWithApprovalResponses = new Set(
+    toolApprovalResponses.map(
+      toolApprovalResponse => toolApprovalResponse.toolCall.toolCallId,
+    ),
+  );
+
+  for (const part of content) {
+    switch (part.type) {
+      case 'text':
+      case 'reasoning':
+      case 'custom':
+      case 'source':
+        contentParts.push(part);
+        break;
+
+      case 'file':
+      case 'reasoning-file': {
+        contentParts.push({
+          type: part.type as 'file' | 'reasoning-file',
+          file: new DefaultGeneratedFile({
+            data:
+              part.data.type === 'data'
+                ? part.data.data
+                : part.data.url.toString(),
+            mediaType: part.mediaType,
+          }),
+          ...(part.providerMetadata != null
+            ? { providerMetadata: part.providerMetadata }
+            : {}),
+        });
+        break;
+      }
+
+      case 'tool-call': {
+        const toolCall = toolCalls.find(
+          toolCall => toolCall.toolCallId === part.toolCallId,
+        );
+
+        if (toolCall == null) {
+          throw new Error(`Tool call ${part.toolCallId} not found.`);
+        }
+
+        contentParts.push(toolCall);
+        break;
+      }
+
+      case 'tool-result': {
+        const toolCall = toolCalls.find(
+          toolCall => toolCall.toolCallId === part.toolCallId,
+        );
+
+        // Handle deferred results for provider-executed tools (e.g., programmatic tool calling).
+        // When a server tool (like code_execution) triggers a client tool, the server tool's
+        // result may be deferred to a later turn. In this case, there's no matching tool-call
+        // in the current response.
+        if (toolCall == null) {
+          const tool = getOwn(tools, part.toolName);
+          const supportsDeferredResults =
+            tool?.type === 'provider' && tool.supportsDeferredResults;
+
+          if (!supportsDeferredResults) {
+            throw new Error(`Tool call ${part.toolCallId} not found.`);
+          }
+
+          // Create tool result without tool call input (deferred result)
+          if (part.isError) {
+            contentParts.push({
+              type: 'tool-error' as const,
+              toolCallId: part.toolCallId,
+              toolName: part.toolName as keyof TOOLS & string,
+              input: undefined,
+              error: part.result,
+              providerExecuted: true,
+              dynamic: part.dynamic,
+              ...(part.providerMetadata != null
+                ? { providerMetadata: part.providerMetadata }
+                : {}),
+              ...(tool?.metadata != null
+                ? { toolMetadata: tool.metadata }
+                : {}),
+            } as TypedToolError<TOOLS>);
+          } else {
+            contentParts.push({
+              type: 'tool-result' as const,
+              toolCallId: part.toolCallId,
+              toolName: part.toolName as keyof TOOLS & string,
+              input: undefined,
+              output: part.result,
+              providerExecuted: true,
+              dynamic: part.dynamic,
+              ...(part.providerMetadata != null
+                ? { providerMetadata: part.providerMetadata }
+                : {}),
+              ...(tool?.metadata != null
+                ? { toolMetadata: tool.metadata }
+                : {}),
+            } as TypedToolResult<TOOLS>);
+          }
+          break;
+        }
+
+        if (part.isError) {
+          contentParts.push({
+            type: 'tool-error' as const,
+            toolCallId: part.toolCallId,
+            toolName: part.toolName as keyof TOOLS & string,
+            input: toolCall.input,
+            error: part.result,
+            providerExecuted: true,
+            dynamic: toolCall.dynamic,
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : {}),
+            ...(toolCall.toolMetadata != null
+              ? { toolMetadata: toolCall.toolMetadata }
+              : {}),
+          } as TypedToolError<TOOLS>);
+        } else {
+          contentParts.push({
+            type: 'tool-result' as const,
+            toolCallId: part.toolCallId,
+            toolName: part.toolName as keyof TOOLS & string,
+            input: toolCall.input,
+            output: part.result,
+            providerExecuted: true,
+            dynamic: toolCall.dynamic,
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : {}),
+            ...(toolCall.toolMetadata != null
+              ? { toolMetadata: toolCall.toolMetadata }
+              : {}),
+          } as TypedToolResult<TOOLS>);
+        }
+        break;
+      }
+
+      case 'tool-approval-request': {
+        const toolCall = toolCalls.find(
+          toolCall => toolCall.toolCallId === part.toolCallId,
+        );
+
+        if (toolCall == null) {
+          throw new ToolCallNotFoundForApprovalError({
+            toolCallId: part.toolCallId,
+            approvalId: part.approvalId,
+          });
+        }
+
+        contentParts.push({
+          type: 'tool-approval-request' as const,
+          approvalId: part.approvalId,
+          toolCall,
+        });
+        break;
+      }
+    }
+  }
+
+  for (const toolOutput of toolOutputs) {
+    if (toolCallIdsWithApprovalResponses.has(toolOutput.toolCallId)) {
+      toolOutputsWithApprovalResponses.push(toolOutput);
+    } else {
+      toolOutputsWithoutApprovalResponses.push(toolOutput);
+    }
+  }
+
+  return [
+    ...contentParts,
+    ...toolOutputsWithoutApprovalResponses,
+    ...toolApprovalRequests,
+    ...toolApprovalResponses,
+    ...toolOutputsWithApprovalResponses,
+  ];
+}