@ai-sdk/google 4.0.68 → 4.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.68",
+  "version": "4.0.70",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/download-tool-result-files.ts

@@ -0,0 +1,124 @@
+import type {
+  LanguageModelV4Prompt,
+  LanguageModelV4ToolResultOutput,
+} from '@ai-sdk/provider';
+import {
+  detectMediaType,
+  downloadBlob,
+  isFullMediaType,
+} from '@ai-sdk/provider-utils';
+
+/**
+ * Vertex function responses only accept inline file data. Download remote tool
+ * result files before converting the prompt to the Google request format.
+ */
+export async function downloadToolResultFiles(
+  prompt: LanguageModelV4Prompt,
+  {
+    abortSignal,
+    maxBytes,
+  }: {
+    abortSignal: AbortSignal | undefined;
+    maxBytes: number;
+  },
+): Promise<LanguageModelV4Prompt> {
+  const result: LanguageModelV4Prompt = [];
+
+  for (const message of prompt) {
+    if (message.role === 'assistant') {
+      const content: typeof message.content = [];
+
+      for (const part of message.content) {
+        content.push(
+          part.type === 'tool-result'
+            ? {
+                ...part,
+                output: await downloadToolResultOutput(part.output, {
+                  abortSignal,
+                  maxBytes,
+                }),
+              }
+            : part,
+        );
+      }
+
+      result.push({ ...message, content });
+      continue;
+    }
+
+    if (message.role === 'tool') {
+      const content: typeof message.content = [];
+
+      for (const part of message.content) {
+        if (part.type !== 'tool-result') {
+          content.push(part);
+          continue;
+        }
+
+        content.push({
+          ...part,
+          output: await downloadToolResultOutput(part.output, {
+            abortSignal,
+            maxBytes,
+          }),
+        });
+      }
+
+      result.push({ ...message, content });
+      continue;
+    }
+
+    result.push(message);
+  }
+
+  return result;
+}
+
+async function downloadToolResultOutput(
+  output: LanguageModelV4ToolResultOutput,
+  {
+    abortSignal,
+    maxBytes,
+  }: {
+    abortSignal: AbortSignal | undefined;
+    maxBytes: number;
+  },
+): Promise<LanguageModelV4ToolResultOutput> {
+  if (output.type !== 'content') {
+    return output;
+  }
+
+  const value: typeof output.value = [];
+
+  for (const part of output.value) {
+    if (part.type !== 'file' || part.data.type !== 'url') {
+      value.push(part);
+      continue;
+    }
+
+    const blob = await downloadBlob(part.data.url.toString(), {
+      abortSignal,
+      maxBytes,
+    });
+    const data = new Uint8Array(await blob.arrayBuffer());
+    const detectedMediaType = detectMediaType({
+      data,
+      topLevelType: 'image',
+    });
+
+    value.push({
+      ...part,
+      data: { type: 'data' as const, data },
+      mediaType:
+        detectedMediaType ??
+        (blob.type && !isFullMediaType(part.mediaType)
+          ? blob.type
+          : part.mediaType),
+    });
+  }
+
+  return {
+    ...output,
+    value,
+  };
+}

package/src/google-language-model.ts

@@ -38,10 +38,11 @@ import {
   convertGoogleUsage,
   type GoogleUsageMetadata,
 } from './convert-google-usage';
-import { convertJSONSchemaToOpenAPISchema } from './convert-json-schema-to-openapi-schema';
 import { convertToGoogleMessages } from './convert-to-google-messages';
+import { downloadToolResultFiles } from './download-tool-result-files';
 import { getModelPath } from './get-model-path';
 import { googleFailedResponseHandler } from './google-error';
+import { sanitizeResponseJsonSchema } from './sanitize-response-json-schema';
 import {
   googleLanguageModelOptions,
   type GoogleLanguageModelOptions,
@@ -76,6 +77,13 @@ export type GoogleLanguageModelConfig = {
    * The supported URLs for the model.
    */
   supportedUrls?: () => LanguageModelV4['supportedUrls'];
+
+  /**
+   * Settings for downloading remote files in tool results before conversion.
+   */
+  downloadToolResultFiles?: {
+    maxBytes: number;
+  };
 };
 
 export class GoogleLanguageModel implements LanguageModelV4 {
@@ -132,6 +140,7 @@ export class GoogleLanguageModel implements LanguageModelV4 {
       toolChoice,
       reasoning,
       providerOptions,
+      abortSignal,
     },
     isStreaming = false,
   }: {
@@ -287,14 +296,24 @@ export class GoogleLanguageModel implements LanguageModelV4 {
 
     const { usesGemini3Features } = getGoogleModelCapabilities(modelId);
 
-    const { contents, systemInstruction } = convertToGoogleMessages(prompt, {
-      isGemmaModel,
-      isGemini3Model: usesGemini3Features,
-      onWarning: warning => warnings.push(warning),
-      providerOptionsNames,
-      supportsFunctionResponseParts: usesGemini3Features,
-      includeFunctionCallIds: !isVertexProvider,
-    });
+    const promptWithDownloadedToolResultFiles = config.downloadToolResultFiles
+      ? await downloadToolResultFiles(prompt, {
+          abortSignal,
+          maxBytes: config.downloadToolResultFiles.maxBytes,
+        })
+      : prompt;
+
+    const { contents, systemInstruction } = convertToGoogleMessages(
+      promptWithDownloadedToolResultFiles,
+      {
+        isGemmaModel,
+        isGemini3Model: usesGemini3Features,
+        onWarning: warning => warnings.push(warning),
+        providerOptionsNames,
+        supportsFunctionResponseParts: usesGemini3Features,
+        includeFunctionCallIds: !isVertexProvider,
+      },
+    );
 
     const {
       tools: googleTools,
@@ -376,14 +395,14 @@ export class GoogleLanguageModel implements LanguageModelV4 {
           // response format:
           responseMimeType:
             responseFormat?.type === 'json' ? 'application/json' : undefined,
-          responseSchema:
+          responseJsonSchema:
             responseFormat?.type === 'json' &&
             responseFormat.schema != null &&
-            // Google GenAI does not support all OpenAPI Schema features,
-            // so this is needed as an escape hatch:
+            // Google does not support all JSON Schema features in
+            // responseJsonSchema, so this is needed as an escape hatch:
             // TODO convert into provider option
             (googleOptions?.structuredOutputs ?? true)
-              ? convertJSONSchemaToOpenAPISchema(responseFormat.schema)
+              ? sanitizeResponseJsonSchema(responseFormat.schema)
               : undefined,
           ...(googleOptions?.audioTimestamp && {
             audioTimestamp: googleOptions.audioTimestamp,

package/src/google-prepare-tools.ts

@@ -3,10 +3,6 @@ import {
   type LanguageModelV4CallOptions,
   type SharedV4Warning,
 } from '@ai-sdk/provider';
-import {
-  convertJSONSchemaToOpenAPISchema,
-  isRecursiveJSONSchemaReferenceError,
-} from './convert-json-schema-to-openapi-schema';
 import type { GoogleModelId } from './google-language-model-options';
 import { getGoogleModelCapabilities } from './google-model-capabilities';
 
@@ -18,8 +14,7 @@ type FunctionTool = Extract<
 type GoogleFunctionDeclaration = {
   name: string;
   description: string;
-  parameters?: unknown;
-  parametersJsonSchema?: unknown;
+  parametersJsonSchema: unknown;
 };
 
 export function prepareTools({
@@ -317,24 +312,9 @@ export function prepareTools({
 function prepareFunctionDeclaration(
   tool: FunctionTool,
 ): GoogleFunctionDeclaration {
-  const declaration = {
+  return {
     name: tool.name,
     description: tool.description ?? '',
+    parametersJsonSchema: tool.inputSchema,
   };
-
-  try {
-    return {
-      ...declaration,
-      parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema),
-    };
-  } catch (error) {
-    if (!isRecursiveJSONSchemaReferenceError(error)) {
-      throw error;
-    }
-
-    return {
-      ...declaration,
-      parametersJsonSchema: tool.inputSchema,
-    };
-  }
 }

package/src/realtime/google-realtime-event-mapper.ts

@@ -6,7 +6,6 @@ import type {
   Experimental_RealtimeModelV4SessionConfig as RealtimeModelV4SessionConfig,
 } from '@ai-sdk/provider';
 import { isRecord, safeParseJSON } from '@ai-sdk/provider-utils';
-import { convertJSONSchemaToOpenAPISchema } from '../convert-json-schema-to-openapi-schema';
 import { getModelPath } from '../get-model-path';
 import type { GoogleRealtimeModelOptions } from './google-realtime-model-options';
 
@@ -337,11 +336,33 @@ export class GoogleRealtimeEventMapper {
   }
 }
 
+/**
+ * The value Gemini accepts for `functionResponse.response`.
+ *
+ * The field is typed `google.protobuf.Struct`, which is an object and nothing else, so
+ * a string, number, array or `null` on the wire is a protocol violation and the socket
+ * closes with 1007. `onToolCall` returns `unknown` and `addToolOutput` takes `unknown`,
+ * so those shapes reach here as perfectly valid JSON.
+ *
+ * The field's own docstring says what to do with one: "Use `output` key to specify
+ * function output ... If `output` and `error` keys are not specified, then whole
+ * `response` is treated as function output." An object is passed through unchanged and
+ * everything else is wrapped.
+ */
+function toFunctionResponseStruct(value: unknown): Record<string, unknown> {
+  const isStruct =
+    typeof value === 'object' && value !== null && !Array.isArray(value);
+  return isStruct ? (value as Record<string, unknown>) : { output: value };
+}
+
 async function serializeFunctionCallOutput(
   item: RealtimeModelV4FunctionCallOutput,
 ): Promise<unknown> {
   const parseResult = await safeParseJSON({ text: item.output });
-  const response = parseResult.success ? parseResult.value : {};
+  const response = parseResult.success
+    ? toFunctionResponseStruct(parseResult.value)
+    : // Preserve non-JSON output in the required object wrapper.
+      { output: item.output };
 
   return {
     toolResponse: {
@@ -402,7 +423,7 @@ export function buildGoogleSessionConfig(
         functionDeclarations: config.tools.map(tool => ({
           name: tool.name,
           description: tool.description,
-          parameters: convertJSONSchemaToOpenAPISchema(tool.parameters),
+          parametersJsonSchema: tool.parameters,
         })),
       },
     ];

package/src/sanitize-response-json-schema.ts

@@ -0,0 +1,65 @@
+import type { JSONSchema7, JSONSchema7Definition } from '@ai-sdk/provider';
+
+/**
+ * Recursively replaces `const` with a single-value `enum` in the JSON Schema
+ * locations supported by Google because `responseJsonSchema` does not support
+ * `const`. All other schema properties are preserved.
+ */
+export function sanitizeResponseJsonSchema(schema: JSONSchema7): JSONSchema7 {
+  const {
+    const: constValue,
+    properties,
+    items,
+    additionalProperties,
+    anyOf,
+    oneOf,
+    ...result
+  } = schema;
+
+  return {
+    ...result,
+    ...(constValue !== undefined ? { enum: [constValue] } : {}),
+    ...(properties != null
+      ? { properties: sanitizeDefinitions(properties) }
+      : {}),
+    ...(items != null
+      ? {
+          items: Array.isArray(items)
+            ? items.map(sanitizeDefinition)
+            : sanitizeDefinition(items),
+        }
+      : {}),
+    ...(additionalProperties != null
+      ? {
+          additionalProperties:
+            typeof additionalProperties === 'boolean'
+              ? additionalProperties
+              : sanitizeDefinition(additionalProperties),
+        }
+      : {}),
+    ...(anyOf != null ? { anyOf: anyOf.map(sanitizeDefinition) } : {}),
+    ...(oneOf != null ? { oneOf: oneOf.map(sanitizeDefinition) } : {}),
+    ...(result.$defs != null
+      ? { $defs: sanitizeDefinitions(result.$defs) }
+      : {}),
+  };
+}
+
+function sanitizeDefinitions(
+  definitions: Record<string, JSONSchema7Definition>,
+): Record<string, JSONSchema7Definition> {
+  return Object.fromEntries(
+    Object.entries(definitions).map(([name, definition]) => [
+      name,
+      sanitizeDefinition(definition),
+    ]),
+  );
+}
+
+function sanitizeDefinition(
+  definition: JSONSchema7Definition,
+): JSONSchema7Definition {
+  return typeof definition === 'boolean'
+    ? definition
+    : sanitizeResponseJsonSchema(definition);
+}