@ai-sdk/google 4.0.69 → 4.0.70

package/package.json

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

package/src/google-language-model.ts

@@ -38,11 +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,
@@ -395,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);
+}

package/src/convert-json-schema-to-openapi-schema.ts

@@ -1,456 +0,0 @@
-import {
-  UnsupportedFunctionalityError,
-  type JSONSchema7,
-  type JSONSchema7Definition,
-} from '@ai-sdk/provider';
-
-type JSONSchema7WithDefinitions = JSONSchema7 & {
-  $defs?: Record<string, JSONSchema7Definition>;
-};
-
-type ReferenceContext = {
-  definitions: Record<string, JSONSchema7Definition> | undefined;
-  dollarDefinitions: Record<string, JSONSchema7Definition> | undefined;
-  resolvingReferences: ReadonlySet<string>;
-};
-
-const recursiveReferenceFunctionalityPrefix =
-  'recursive JSON Schema reference:';
-
-export function isRecursiveJSONSchemaReferenceError(
-  error: unknown,
-): error is UnsupportedFunctionalityError {
-  return (
-    UnsupportedFunctionalityError.isInstance(error) &&
-    error.functionality.startsWith(recursiveReferenceFunctionalityPrefix)
-  );
-}
-
-/**
- * Converts JSON Schema 7 to OpenAPI Schema 3.0
- */
-export function convertJSONSchemaToOpenAPISchema(
-  jsonSchema: JSONSchema7Definition | undefined,
-  isRoot = true,
-): unknown {
-  const rootSchema =
-    typeof jsonSchema === 'object'
-      ? (jsonSchema as JSONSchema7WithDefinitions)
-      : undefined;
-
-  return convertJSONSchemaDefinition(jsonSchema, isRoot, {
-    definitions: rootSchema?.definitions,
-    dollarDefinitions: rootSchema?.$defs,
-    resolvingReferences: new Set(),
-  });
-}
-
-function convertJSONSchemaDefinition(
-  jsonSchema: JSONSchema7Definition | undefined,
-  isRoot: boolean,
-  referenceContext: ReferenceContext,
-): unknown {
-  if (jsonSchema == null) {
-    return undefined;
-  }
-
-  if (typeof jsonSchema === 'boolean') {
-    return { type: 'boolean', properties: {} };
-  }
-
-  if (jsonSchema.$ref != null) {
-    return convertJSONSchemaReference({
-      jsonSchema,
-      reference: jsonSchema.$ref,
-      isRoot,
-      referenceContext,
-    });
-  }
-
-  // Handle empty object schemas: undefined at root, preserved when nested
-  if (isEmptyObjectSchema(jsonSchema)) {
-    if (isRoot) {
-      return undefined;
-    }
-
-    if (jsonSchema.description) {
-      return { type: 'object', description: jsonSchema.description };
-    }
-    return { type: 'object' };
-  }
-
-  const {
-    type,
-    description,
-    required,
-    properties,
-    items,
-    allOf,
-    anyOf,
-    oneOf,
-    format,
-    const: constValue,
-    minLength,
-    minItems,
-    maxItems,
-    enum: enumValues,
-  } = jsonSchema;
-
-  const result: Record<string, unknown> = {};
-
-  if (description) result.description = description;
-  if (required) result.required = required;
-  if (format) result.format = format;
-
-  // Handle type
-  if (type) {
-    if (Array.isArray(type)) {
-      const hasNull = type.includes('null');
-      const nonNullTypes = type.filter(t => t !== 'null');
-
-      if (nonNullTypes.length === 0) {
-        // Only null type
-        result.type = 'null';
-      } else {
-        // One or more non-null types: always use anyOf
-        result.anyOf = nonNullTypes.map(t => ({ type: t }));
-        if (hasNull) {
-          result.nullable = true;
-        }
-      }
-    } else {
-      result.type = type;
-    }
-  }
-
-  const values =
-    enumValues ?? (constValue !== undefined ? [constValue] : undefined);
-
-  if (values !== undefined) {
-    addEnumToSchema({ values, type, result });
-  }
-
-  if (properties != null) {
-    result.properties = Object.entries(properties).reduce(
-      (acc, [key, value]) => {
-        acc[key] = convertJSONSchemaDefinition(value, false, referenceContext);
-        return acc;
-      },
-      {} as Record<string, unknown>,
-    );
-  }
-
-  if (items) {
-    result.items = Array.isArray(items)
-      ? items.map(item =>
-          convertJSONSchemaDefinition(item, false, referenceContext),
-        )
-      : convertJSONSchemaDefinition(items, false, referenceContext);
-  }
-
-  if (allOf) {
-    result.allOf = allOf.map(item =>
-      convertJSONSchemaDefinition(item, false, referenceContext),
-    );
-  }
-  if (anyOf) {
-    // Handle cases where anyOf includes a null type
-    if (
-      anyOf.some(
-        schema => typeof schema === 'object' && schema?.type === 'null',
-      )
-    ) {
-      const nonNullSchemas = anyOf.filter(
-        schema => !(typeof schema === 'object' && schema?.type === 'null'),
-      );
-
-      if (nonNullSchemas.length === 1) {
-        // If there's only one non-null schema, convert it and make it nullable
-        const converted = convertJSONSchemaDefinition(
-          nonNullSchemas[0],
-          false,
-          referenceContext,
-        );
-        if (typeof converted === 'object') {
-          result.nullable = true;
-          Object.assign(result, converted);
-        }
-      } else {
-        // If there are multiple non-null schemas, keep them in anyOf
-        result.anyOf = nonNullSchemas.map(item =>
-          convertJSONSchemaDefinition(item, false, referenceContext),
-        );
-        result.nullable = true;
-      }
-    } else {
-      result.anyOf = anyOf.map(item =>
-        convertJSONSchemaDefinition(item, false, referenceContext),
-      );
-    }
-  }
-  if (oneOf) {
-    result.oneOf = oneOf.map(item =>
-      convertJSONSchemaDefinition(item, false, referenceContext),
-    );
-  }
-
-  if (minLength !== undefined) {
-    result.minLength = minLength;
-  }
-
-  if (minItems !== undefined) {
-    result.minItems = minItems;
-  }
-
-  if (maxItems !== undefined) {
-    result.maxItems = maxItems;
-  }
-
-  return result;
-}
-
-function convertJSONSchemaReference({
-  jsonSchema,
-  reference,
-  isRoot,
-  referenceContext,
-}: {
-  jsonSchema: JSONSchema7;
-  reference: string;
-  isRoot: boolean;
-  referenceContext: ReferenceContext;
-}): unknown {
-  const { definition, referenceKey } = getReferencedDefinition(
-    reference,
-    referenceContext,
-  );
-
-  if (referenceContext.resolvingReferences.has(referenceKey)) {
-    throw new UnsupportedFunctionalityError({
-      functionality: `${recursiveReferenceFunctionalityPrefix} ${reference}`,
-      message:
-        'Google schema conversion does not support recursive JSON Schema references.',
-    });
-  }
-
-  const resolvingReferences = new Set(referenceContext.resolvingReferences);
-  resolvingReferences.add(referenceKey);
-
-  // Inline references instead of emitting Google's `ref` / `defs` fields.
-  // Those fields are supported by Vertex AI's Schema representation but are
-  // rejected by the Gemini Developer API representation used by this shared
-  // converter.
-  const { $ref: _reference, ...siblingSchema } = jsonSchema;
-  const resolvedSchema =
-    typeof definition === 'boolean'
-      ? definition
-        ? siblingSchema
-        : false
-      : { ...definition, ...siblingSchema };
-
-  return convertJSONSchemaDefinition(resolvedSchema, isRoot, {
-    ...referenceContext,
-    resolvingReferences,
-  });
-}
-
-function getReferencedDefinition(
-  reference: string,
-  referenceContext: ReferenceContext,
-): {
-  definition: JSONSchema7Definition;
-  referenceKey: string;
-} {
-  const definitionSources = [
-    {
-      prefix: '#/$defs/',
-      definitions: referenceContext.dollarDefinitions,
-    },
-    {
-      prefix: '#/definitions/',
-      definitions: referenceContext.definitions,
-    },
-  ];
-
-  const source = definitionSources.find(({ prefix }) =>
-    reference.startsWith(prefix),
-  );
-  const encodedDefinitionName = source
-    ? reference.slice(source.prefix.length)
-    : undefined;
-
-  if (
-    source == null ||
-    encodedDefinitionName == null ||
-    encodedDefinitionName.length === 0 ||
-    encodedDefinitionName.includes('/')
-  ) {
-    throwUnsupportedReference(reference);
-  }
-
-  let decodedDefinitionName: string;
-  try {
-    decodedDefinitionName = decodeURIComponent(encodedDefinitionName);
-  } catch {
-    throwUnsupportedReference(reference);
-  }
-
-  if (
-    decodedDefinitionName.includes('/') ||
-    /~(?![01])/u.test(decodedDefinitionName) ||
-    source.definitions == null
-  ) {
-    throwUnsupportedReference(reference);
-  }
-
-  const definitionName = decodedDefinitionName.replace(/~[01]/g, match =>
-    match === '~1' ? '/' : '~',
-  );
-
-  if (
-    !Object.prototype.hasOwnProperty.call(source.definitions, definitionName)
-  ) {
-    throwUnsupportedReference(reference);
-  }
-
-  return {
-    definition: source.definitions[definitionName],
-    referenceKey: `${source.prefix}${definitionName}`,
-  };
-}
-
-function throwUnsupportedReference(reference: string): never {
-  throw new UnsupportedFunctionalityError({
-    functionality: `JSON Schema reference: ${reference}`,
-    message:
-      'Google schema conversion only supports references to direct children of root-level $defs or definitions.',
-  });
-}
-
-type EnumValues = NonNullable<JSONSchema7['enum']>;
-type EnumType = 'string' | 'number' | 'integer' | 'boolean';
-type GoogleEnumSchema = {
-  type?: JSONSchema7['type'];
-  enum?: JSONSchema7['enum'];
-  format?: JSONSchema7['format'];
-  anyOf?: JSONSchema7['anyOf'];
-  nullable?: boolean;
-};
-
-function addEnumToSchema({
-  values,
-  type,
-  result,
-}: {
-  values: EnumValues;
-  type: JSONSchema7['type'];
-  result: GoogleEnumSchema;
-}) {
-  const nullable =
-    (Array.isArray(type) && type.includes('null')) ||
-    (type === undefined && values.includes(null));
-
-  // Gemini uses nullable instead of a null enum member.
-  const enumValues = nullable ? values.filter(value => value !== null) : values;
-
-  if (values.length > 0 && values.every(value => value === null)) {
-    const typeAllowsNull =
-      type === undefined ||
-      type === 'null' ||
-      (Array.isArray(type) && type.includes('null'));
-
-    if (typeAllowsNull) {
-      result.type = 'null';
-      if (Array.isArray(type)) {
-        delete result.anyOf;
-      }
-      return;
-    }
-  }
-
-  const enumType = getEnumType({ values: enumValues, type });
-
-  if (enumType === undefined) {
-    throw new UnsupportedFunctionalityError({
-      functionality: 'JSON Schema enum with mixed or unsupported values',
-      message:
-        'Google does not support this JSON Schema enum. Enum values must share one supported primitive type and match the schema type.',
-    });
-  }
-
-  result.type = enumType;
-
-  // The earlier type-array conversion created anyOf. The enum gives us one
-  // concrete value type, so store that type directly.
-  if (Array.isArray(type)) {
-    delete result.anyOf;
-  }
-
-  if (nullable) {
-    result.nullable = true;
-  }
-
-  if (enumType === 'string') {
-    result.enum = enumValues;
-  } else {
-    result.format = 'enum';
-    result.enum = enumValues.map(String);
-  }
-}
-
-function getEnumType({
-  values,
-  type,
-}: {
-  values: EnumValues;
-  type: JSONSchema7['type'];
-}): EnumType | undefined {
-  if (values.length === 0) {
-    return undefined;
-  }
-
-  const typeAllows = (enumType: EnumType) =>
-    type === undefined ||
-    type === enumType ||
-    (Array.isArray(type) && type.includes(enumType));
-
-  if (
-    typeAllows('string') &&
-    values.every(value => typeof value === 'string')
-  ) {
-    return 'string';
-  }
-
-  if (
-    (typeAllows('number') || typeAllows('integer')) &&
-    values.every(value => typeof value === 'number' && Number.isFinite(value))
-  ) {
-    if (typeAllows('number')) {
-      return 'number';
-    }
-
-    if (values.every(value => Number.isInteger(value))) {
-      return 'integer';
-    }
-  }
-
-  if (
-    typeAllows('boolean') &&
-    values.every(value => typeof value === 'boolean')
-  ) {
-    return 'boolean';
-  }
-
-  return undefined;
-}
-
-function isEmptyObjectSchema(jsonSchema: JSONSchema7Definition): boolean {
-  return (
-    jsonSchema != null &&
-    typeof jsonSchema === 'object' &&
-    jsonSchema.type === 'object' &&
-    (jsonSchema.properties == null ||
-      Object.keys(jsonSchema.properties).length === 0) &&
-    !jsonSchema.additionalProperties
-  );
-}