@ai-sdk/google 4.0.69 → 4.0.71

package/dist/internal/index.d.ts

@@ -137,7 +137,7 @@ declare class GoogleLanguageModel implements LanguageModelV4 {
                 stopSequences: string[] | undefined;
                 seed: number | undefined;
                 responseMimeType: string | undefined;
-                responseSchema: unknown;
+                responseJsonSchema: _ai_sdk_provider.JSONSchema7 | undefined;
             };
             contents: GoogleContent[];
             systemInstruction: GoogleSystemInstruction | undefined;
@@ -149,8 +149,7 @@ declare class GoogleLanguageModel implements LanguageModelV4 {
                 functionDeclarations: {
                     name: string;
                     description: string;
-                    parameters?: unknown;
-                    parametersJsonSchema?: unknown;
+                    parametersJsonSchema: unknown;
                 }[];
             } | Record<string, any>)[] | undefined;
             toolConfig: {

package/dist/internal/index.js

@@ -46,289 +46,9 @@ function convertGoogleUsage(usage) {
   };
 }
 
-// src/convert-json-schema-to-openapi-schema.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-var recursiveReferenceFunctionalityPrefix = "recursive JSON Schema reference:";
-function isRecursiveJSONSchemaReferenceError(error) {
-  return UnsupportedFunctionalityError.isInstance(error) && error.functionality.startsWith(recursiveReferenceFunctionalityPrefix);
-}
-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 (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 = {};
-  if (description) result.description = description;
-  if (required) result.required = required;
-  if (format) result.format = format;
-  if (type) {
-    if (Array.isArray(type)) {
-      const hasNull = type.includes("null");
-      const nonNullTypes = type.filter((t) => t !== "null");
-      if (nonNullTypes.length === 0) {
-        result.type = "null";
-      } else {
-        result.anyOf = nonNullTypes.map((t) => ({ type: t }));
-        if (hasNull) {
-          result.nullable = true;
-        }
-      }
-    } else {
-      result.type = type;
-    }
-  }
-  const values = enumValues != null ? enumValues : constValue !== void 0 ? [constValue] : void 0;
-  if (values !== void 0) {
-    addEnumToSchema({ values, type, result });
-  }
-  if (properties != null) {
-    result.properties = Object.entries(properties).reduce(
-      (acc, [key, value]) => {
-        acc[key] = convertJSONSchemaDefinition(value, false, referenceContext);
-        return acc;
-      },
-      {}
-    );
-  }
-  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) {
-    if (anyOf.some(
-      (schema) => typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null"
-    )) {
-      const nonNullSchemas = anyOf.filter(
-        (schema) => !(typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null")
-      );
-      if (nonNullSchemas.length === 1) {
-        const converted = convertJSONSchemaDefinition(
-          nonNullSchemas[0],
-          false,
-          referenceContext
-        );
-        if (typeof converted === "object") {
-          result.nullable = true;
-          Object.assign(result, converted);
-        }
-      } else {
-        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 !== void 0) {
-    result.minLength = minLength;
-  }
-  if (minItems !== void 0) {
-    result.minItems = minItems;
-  }
-  if (maxItems !== void 0) {
-    result.maxItems = maxItems;
-  }
-  return result;
-}
-function convertJSONSchemaReference({
-  jsonSchema,
-  reference,
-  isRoot,
-  referenceContext
-}) {
-  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);
-  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 addEnumToSchema({
-  values,
-  type,
-  result
-}) {
-  const nullable = Array.isArray(type) && type.includes("null") || type === void 0 && values.includes(null);
-  const enumValues = nullable ? values.filter((value) => value !== null) : values;
-  if (values.length > 0 && values.every((value) => value === null)) {
-    const typeAllowsNull = type === void 0 || 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 === void 0) {
-    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;
-  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
-}) {
-  if (values.length === 0) {
-    return void 0;
-  }
-  const typeAllows = (enumType) => type === void 0 || 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 void 0;
-}
-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-messages.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+  UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
 import {
   convertToBase64,
@@ -485,7 +205,7 @@ function convertToGoogleMessages(prompt, options) {
     switch (role) {
       case "system": {
         if (!systemMessagesAllowed) {
-          throw new UnsupportedFunctionalityError2({
+          throw new UnsupportedFunctionalityError({
             functionality: "system messages are only supported at the beginning of the conversation"
           });
         }
@@ -514,7 +234,7 @@ function convertToGoogleMessages(prompt, options) {
                 }
                 case "reference": {
                   if (isVertexLike) {
-                    throw new UnsupportedFunctionalityError2({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "file parts with provider references"
                     });
                   }
@@ -582,7 +302,7 @@ function convertToGoogleMessages(prompt, options) {
               case "reasoning-file": {
                 switch (part.data.type) {
                   case "url": {
-                    throw new UnsupportedFunctionalityError2({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "File data URLs in assistant messages are not supported"
                     });
                   }
@@ -602,13 +322,13 @@ function convertToGoogleMessages(prompt, options) {
               case "file": {
                 switch (part.data.type) {
                   case "url": {
-                    throw new UnsupportedFunctionalityError2({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "File data URLs in assistant messages are not supported"
                     });
                   }
                   case "reference": {
                     if (isVertexLike) {
-                      throw new UnsupportedFunctionalityError2({
+                      throw new UnsupportedFunctionalityError({
                         functionality: "file parts with provider references"
                       });
                     }
@@ -900,6 +620,44 @@ var googleFailedResponseHandler = createJsonErrorResponseHandler({
   errorToMessage: (data) => data.error.message
 });
 
+// src/sanitize-response-json-schema.ts
+function sanitizeResponseJsonSchema(schema) {
+  const {
+    const: constValue,
+    properties,
+    items,
+    additionalProperties,
+    anyOf,
+    oneOf,
+    ...result
+  } = schema;
+  return {
+    ...result,
+    ...constValue !== void 0 ? { 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) {
+  return Object.fromEntries(
+    Object.entries(definitions).map(([name, definition]) => [
+      name,
+      sanitizeDefinition(definition)
+    ])
+  );
+}
+function sanitizeDefinition(definition) {
+  return typeof definition === "boolean" ? definition : sanitizeResponseJsonSchema(definition);
+}
+
 // src/google-language-model-options.ts
 import {
   lazySchema as lazySchema2,
@@ -1114,7 +872,7 @@ function getGoogleModelCapabilities(modelId) {
 
 // src/google-prepare-tools.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 function prepareTools({
   tools,
@@ -1344,7 +1102,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError3({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -1352,24 +1110,11 @@ function prepareTools({
 }
 function prepareFunctionDeclaration(tool) {
   var _a;
-  const declaration = {
+  return {
     name: tool.name,
-    description: (_a = tool.description) != null ? _a : ""
+    description: (_a = tool.description) != null ? _a : "",
+    parametersJsonSchema: tool.inputSchema
   };
-  try {
-    return {
-      ...declaration,
-      parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
-    };
-  } catch (error) {
-    if (!isRecursiveJSONSchemaReferenceError(error)) {
-      throw error;
-    }
-    return {
-      ...declaration,
-      parametersJsonSchema: tool.inputSchema
-    };
-  }
 }
 
 // src/google-json-accumulator.ts
@@ -1855,10 +1600,10 @@ var GoogleLanguageModel = class _GoogleLanguageModel {
           seed,
           // response format:
           responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
-          responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
-          // so this is needed as an escape hatch:
+          responseJsonSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google does not support all JSON Schema features in
+          // responseJsonSchema, so this is needed as an escape hatch:
           // TODO convert into provider option
-          ((_c = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _c : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
+          ((_c = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _c : true) ? sanitizeResponseJsonSchema(responseFormat.schema) : void 0,
           ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
             audioTimestamp: googleOptions.audioTimestamp
           },