@ai-sdk/google 3.0.109 → 3.0.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "3.0.109",
+  "version": "3.0.111",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "3.0.15",
-    "@ai-sdk/provider-utils": "4.0.45"
+    "@ai-sdk/provider-utils": "4.0.46"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

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

@@ -1,4 +1,18 @@
-import type { JSONSchema7Definition } from '@ai-sdk/provider';
+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>;
+};
 
 /**
  * Converts JSON Schema 7 to OpenAPI Schema 3.0
@@ -7,26 +21,52 @@ export function convertJSONSchemaToOpenAPISchema(
   jsonSchema: JSONSchema7Definition | undefined,
   isRoot = true,
 ): unknown {
-  // Handle empty object schemas: undefined at root, preserved when nested
+  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 (typeof jsonSchema === 'object' && jsonSchema.description) {
+    if (jsonSchema.description) {
       return { type: 'object', description: jsonSchema.description };
     }
     return { type: 'object' };
   }
 
-  if (typeof jsonSchema === 'boolean') {
-    return { type: 'boolean', properties: {} };
-  }
-
   const {
     type,
     description,
@@ -81,7 +121,7 @@ export function convertJSONSchemaToOpenAPISchema(
   if (properties != null) {
     result.properties = Object.entries(properties).reduce(
       (acc, [key, value]) => {
-        acc[key] = convertJSONSchemaToOpenAPISchema(value, false);
+        acc[key] = convertJSONSchemaDefinition(value, false, referenceContext);
         return acc;
       },
       {} as Record<string, unknown>,
@@ -90,13 +130,15 @@ export function convertJSONSchemaToOpenAPISchema(
 
   if (items) {
     result.items = Array.isArray(items)
-      ? items.map(item => convertJSONSchemaToOpenAPISchema(item, false))
-      : convertJSONSchemaToOpenAPISchema(items, false);
+      ? items.map(item =>
+          convertJSONSchemaDefinition(item, false, referenceContext),
+        )
+      : convertJSONSchemaDefinition(items, false, referenceContext);
   }
 
   if (allOf) {
     result.allOf = allOf.map(item =>
-      convertJSONSchemaToOpenAPISchema(item, false),
+      convertJSONSchemaDefinition(item, false, referenceContext),
     );
   }
   if (anyOf) {
@@ -112,9 +154,10 @@ export function convertJSONSchemaToOpenAPISchema(
 
       if (nonNullSchemas.length === 1) {
         // If there's only one non-null schema, convert it and make it nullable
-        const converted = convertJSONSchemaToOpenAPISchema(
+        const converted = convertJSONSchemaDefinition(
           nonNullSchemas[0],
           false,
+          referenceContext,
         );
         if (typeof converted === 'object') {
           result.nullable = true;
@@ -123,19 +166,19 @@ export function convertJSONSchemaToOpenAPISchema(
       } else {
         // If there are multiple non-null schemas, keep them in anyOf
         result.anyOf = nonNullSchemas.map(item =>
-          convertJSONSchemaToOpenAPISchema(item, false),
+          convertJSONSchemaDefinition(item, false, referenceContext),
         );
         result.nullable = true;
       }
     } else {
       result.anyOf = anyOf.map(item =>
-        convertJSONSchemaToOpenAPISchema(item, false),
+        convertJSONSchemaDefinition(item, false, referenceContext),
       );
     }
   }
   if (oneOf) {
     result.oneOf = oneOf.map(item =>
-      convertJSONSchemaToOpenAPISchema(item, false),
+      convertJSONSchemaDefinition(item, false, referenceContext),
     );
   }
 
@@ -146,6 +189,123 @@ export function convertJSONSchemaToOpenAPISchema(
   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: `recursive JSON Schema reference: ${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.',
+  });
+}
 function isEmptyObjectSchema(jsonSchema: JSONSchema7Definition): boolean {
   return (
     jsonSchema != null &&