@ai-sdk/google 3.0.110 → 3.0.111

package/dist/internal/index.mjs

@@ -52,22 +52,41 @@ function convertGoogleGenerativeAIUsage(usage) {
 }
 
 // src/convert-json-schema-to-openapi-schema.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
 function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
+  const rootSchema = typeof jsonSchema === "object" ? jsonSchema : void 0;
+  return convertJSONSchemaDefinition(jsonSchema, isRoot, {
+    definitions: rootSchema == null ? void 0 : rootSchema.definitions,
+    dollarDefinitions: rootSchema == null ? void 0 : rootSchema.$defs,
+    resolvingReferences: /* @__PURE__ */ new Set()
+  });
+}
+function convertJSONSchemaDefinition(jsonSchema, isRoot, referenceContext) {
   if (jsonSchema == null) {
     return void 0;
   }
+  if (typeof jsonSchema === "boolean") {
+    return { type: "boolean", properties: {} };
+  }
+  if (jsonSchema.$ref != null) {
+    return convertJSONSchemaReference({
+      jsonSchema,
+      reference: jsonSchema.$ref,
+      isRoot,
+      referenceContext
+    });
+  }
   if (isEmptyObjectSchema(jsonSchema)) {
     if (isRoot) {
       return void 0;
     }
-    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,
@@ -111,18 +130,20 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
   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;
       },
       {}
     );
   }
   if (items) {
-    result.items = Array.isArray(items) ? items.map((item) => convertJSONSchemaToOpenAPISchema(item, false)) : convertJSONSchemaToOpenAPISchema(items, false);
+    result.items = Array.isArray(items) ? items.map(
+      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
+    ) : convertJSONSchemaDefinition(items, false, referenceContext);
   }
   if (allOf) {
     result.allOf = allOf.map(
-      (item) => convertJSONSchemaToOpenAPISchema(item, false)
+      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
     );
   }
   if (anyOf) {
@@ -133,9 +154,10 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
         (schema) => !(typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null")
       );
       if (nonNullSchemas.length === 1) {
-        const converted = convertJSONSchemaToOpenAPISchema(
+        const converted = convertJSONSchemaDefinition(
           nonNullSchemas[0],
-          false
+          false,
+          referenceContext
         );
         if (typeof converted === "object") {
           result.nullable = true;
@@ -143,19 +165,19 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
         }
       } else {
         result.anyOf = nonNullSchemas.map(
-          (item) => convertJSONSchemaToOpenAPISchema(item, false)
+          (item) => convertJSONSchemaDefinition(item, false, referenceContext)
         );
         result.nullable = true;
       }
     } else {
       result.anyOf = anyOf.map(
-        (item) => convertJSONSchemaToOpenAPISchema(item, false)
+        (item) => convertJSONSchemaDefinition(item, false, referenceContext)
       );
     }
   }
   if (oneOf) {
     result.oneOf = oneOf.map(
-      (item) => convertJSONSchemaToOpenAPISchema(item, false)
+      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
     );
   }
   if (minLength !== void 0) {
@@ -163,13 +185,83 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
   }
   return result;
 }
+function convertJSONSchemaReference({
+  jsonSchema,
+  reference,
+  isRoot,
+  referenceContext
+}) {
+  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);
+  const { $ref: _reference, ...siblingSchema } = jsonSchema;
+  const resolvedSchema = typeof definition === "boolean" ? definition ? siblingSchema : false : { ...definition, ...siblingSchema };
+  return convertJSONSchemaDefinition(resolvedSchema, isRoot, {
+    ...referenceContext,
+    resolvingReferences
+  });
+}
+function getReferencedDefinition(reference, referenceContext) {
+  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) : void 0;
+  if (source == null || encodedDefinitionName == null || encodedDefinitionName.length === 0 || encodedDefinitionName.includes("/")) {
+    throwUnsupportedReference(reference);
+  }
+  let decodedDefinitionName;
+  try {
+    decodedDefinitionName = decodeURIComponent(encodedDefinitionName);
+  } catch (e) {
+    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) {
+  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) {
   return jsonSchema != null && typeof jsonSchema === "object" && jsonSchema.type === "object" && (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0) && !jsonSchema.additionalProperties;
 }
 
 // src/convert-to-google-generative-ai-messages.ts
 import {
-  UnsupportedFunctionalityError
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 import { convertToBase64, secureJsonParse } from "@ai-sdk/provider-utils";
 var SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
@@ -320,7 +412,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
     switch (role) {
       case "system": {
         if (!systemMessagesAllowed) {
-          throw new UnsupportedFunctionalityError({
+          throw new UnsupportedFunctionalityError2({
             functionality: "system messages are only supported at the beginning of the conversation"
           });
         }
@@ -385,7 +477,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
               }
               case "file": {
                 if (part.data instanceof URL) {
-                  throw new UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError2({
                     functionality: "File data URLs in assistant messages are not supported"
                   });
                 }
@@ -782,7 +874,7 @@ function getGoogleModelCapabilities(modelId) {
 
 // src/google-prepare-tools.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 function prepareTools({
   tools,
@@ -1021,7 +1113,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError2({
+      throw new UnsupportedFunctionalityError3({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }