@depup/ai-sdk__google 3.0.43-depup.0

package/internal.d.ts

@@ -0,0 +1 @@
+export * from './dist/internal';

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@depup/ai-sdk__google",
+  "version": "3.0.43-depup.0",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "docs/**/*",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "!src/**/__snapshots__",
+    "!src/**/__fixtures__",
+    "CHANGELOG.md",
+    "README.md",
+    "internal.d.ts",
+    "changes.json"
+  ],
+  "directories": {
+    "doc": "./docs"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal/index.d.ts",
+      "import": "./dist/internal/index.mjs",
+      "module": "./dist/internal/index.mjs",
+      "require": "./dist/internal/index.js"
+    }
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "3.0.8",
+    "@ai-sdk/provider-utils": "4.0.19"
+  },
+  "devDependencies": {
+    "@types/node": "20.17.24",
+    "tsup": "^8",
+    "typescript": "5.8.3",
+    "zod": "3.25.76",
+    "@ai-sdk/test-server": "1.0.3",
+    "@vercel/ai-tsconfig": "0.0.0"
+  },
+  "peerDependencies": {
+    "zod": "^3.25.76 || ^4.1.8"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://ai-sdk.dev/docs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vercel/ai.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vercel/ai/issues"
+  },
+  "keywords": [
+    "@ai-sdk/google",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
+    "ai"
+  ],
+  "scripts": {
+    "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
+    "build:watch": "pnpm clean && tsup --watch",
+    "clean": "del-cli dist docs *.tsbuildinfo",
+    "lint": "eslint \"./**/*.ts*\"",
+    "type-check": "tsc --build",
+    "prettier-check": "prettier --check \"./**/*.ts*\"",
+    "test": "pnpm test:node && pnpm test:edge",
+    "test:update": "pnpm test:node -u",
+    "test:watch": "vitest --config vitest.node.config.js",
+    "test:edge": "vitest --config vitest.edge.config.js --run",
+    "test:node": "vitest --config vitest.node.config.js --run"
+  },
+  "description": "@ai-sdk/google with all dependencies updated to latest",
+  "depup": {
+    "changes": {},
+    "depsUpdated": 0,
+    "originalPackage": "@ai-sdk/google",
+    "originalVersion": "3.0.43",
+    "processedAt": "2026-03-18T23:32:40.401Z",
+    "smokeTest": "failed"
+  }
+}

package/src/convert-google-generative-ai-usage.ts

@@ -0,0 +1,51 @@
+import { LanguageModelV3Usage } from '@ai-sdk/provider';
+
+export type GoogleGenerativeAIUsageMetadata = {
+  promptTokenCount?: number | null;
+  candidatesTokenCount?: number | null;
+  totalTokenCount?: number | null;
+  cachedContentTokenCount?: number | null;
+  thoughtsTokenCount?: number | null;
+  trafficType?: string | null;
+};
+
+export function convertGoogleGenerativeAIUsage(
+  usage: GoogleGenerativeAIUsageMetadata | undefined | null,
+): LanguageModelV3Usage {
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    };
+  }
+
+  const promptTokens = usage.promptTokenCount ?? 0;
+  const candidatesTokens = usage.candidatesTokenCount ?? 0;
+  const cachedContentTokens = usage.cachedContentTokenCount ?? 0;
+  const thoughtsTokens = usage.thoughtsTokenCount ?? 0;
+
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens - cachedContentTokens,
+      cacheRead: cachedContentTokens,
+      cacheWrite: undefined,
+    },
+    outputTokens: {
+      total: candidatesTokens + thoughtsTokens,
+      text: candidatesTokens,
+      reasoning: thoughtsTokens,
+    },
+    raw: usage,
+  };
+}

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

@@ -0,0 +1,158 @@
+import { JSONSchema7Definition } from '@ai-sdk/provider';
+
+/**
+ * Converts JSON Schema 7 to OpenAPI Schema 3.0
+ */
+export function convertJSONSchemaToOpenAPISchema(
+  jsonSchema: JSONSchema7Definition | undefined,
+  isRoot = true,
+): unknown {
+  // Handle empty object schemas: undefined at root, preserved when nested
+  if (jsonSchema == null) {
+    return undefined;
+  }
+
+  if (isEmptyObjectSchema(jsonSchema)) {
+    if (isRoot) {
+      return undefined;
+    }
+
+    if (typeof jsonSchema === 'object' && jsonSchema.description) {
+      return { type: 'object', description: jsonSchema.description };
+    }
+    return { type: 'object' };
+  }
+
+  if (typeof jsonSchema === 'boolean') {
+    return { type: 'boolean', properties: {} };
+  }
+
+  const {
+    type,
+    description,
+    required,
+    properties,
+    items,
+    allOf,
+    anyOf,
+    oneOf,
+    format,
+    const: constValue,
+    minLength,
+    enum: enumValues,
+  } = jsonSchema;
+
+  const result: Record<string, unknown> = {};
+
+  if (description) result.description = description;
+  if (required) result.required = required;
+  if (format) result.format = format;
+
+  if (constValue !== undefined) {
+    result.enum = [constValue];
+  }
+
+  // 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;
+    }
+  }
+
+  // Handle enum
+  if (enumValues !== undefined) {
+    result.enum = enumValues;
+  }
+
+  if (properties != null) {
+    result.properties = Object.entries(properties).reduce(
+      (acc, [key, value]) => {
+        acc[key] = convertJSONSchemaToOpenAPISchema(value, false);
+        return acc;
+      },
+      {} as Record<string, unknown>,
+    );
+  }
+
+  if (items) {
+    result.items = Array.isArray(items)
+      ? items.map(item => convertJSONSchemaToOpenAPISchema(item, false))
+      : convertJSONSchemaToOpenAPISchema(items, false);
+  }
+
+  if (allOf) {
+    result.allOf = allOf.map(item =>
+      convertJSONSchemaToOpenAPISchema(item, false),
+    );
+  }
+  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 = convertJSONSchemaToOpenAPISchema(
+          nonNullSchemas[0],
+          false,
+        );
+        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 =>
+          convertJSONSchemaToOpenAPISchema(item, false),
+        );
+        result.nullable = true;
+      }
+    } else {
+      result.anyOf = anyOf.map(item =>
+        convertJSONSchemaToOpenAPISchema(item, false),
+      );
+    }
+  }
+  if (oneOf) {
+    result.oneOf = oneOf.map(item =>
+      convertJSONSchemaToOpenAPISchema(item, false),
+    );
+  }
+
+  if (minLength !== undefined) {
+    result.minLength = minLength;
+  }
+
+  return result;
+}
+
+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
+  );
+}

package/src/convert-to-google-generative-ai-messages.ts

@@ -0,0 +1,236 @@
+import {
+  LanguageModelV3Prompt,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import {
+  GoogleGenerativeAIContent,
+  GoogleGenerativeAIContentPart,
+  GoogleGenerativeAIPrompt,
+} from './google-generative-ai-prompt';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+
+export function convertToGoogleGenerativeAIMessages(
+  prompt: LanguageModelV3Prompt,
+  options?: { isGemmaModel?: boolean; providerOptionsName?: string },
+): GoogleGenerativeAIPrompt {
+  const systemInstructionParts: Array<{ text: string }> = [];
+  const contents: Array<GoogleGenerativeAIContent> = [];
+  let systemMessagesAllowed = true;
+  const isGemmaModel = options?.isGemmaModel ?? false;
+  const providerOptionsName = options?.providerOptionsName ?? 'google';
+
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case 'system': {
+        if (!systemMessagesAllowed) {
+          throw new UnsupportedFunctionalityError({
+            functionality:
+              'system messages are only supported at the beginning of the conversation',
+          });
+        }
+
+        systemInstructionParts.push({ text: content });
+        break;
+      }
+
+      case 'user': {
+        systemMessagesAllowed = false;
+
+        const parts: GoogleGenerativeAIContentPart[] = [];
+
+        for (const part of content) {
+          switch (part.type) {
+            case 'text': {
+              parts.push({ text: part.text });
+              break;
+            }
+
+            case 'file': {
+              // default to image/jpeg for unknown image/* types
+              const mediaType =
+                part.mediaType === 'image/*' ? 'image/jpeg' : part.mediaType;
+
+              parts.push(
+                part.data instanceof URL
+                  ? {
+                      fileData: {
+                        mimeType: mediaType,
+                        fileUri: part.data.toString(),
+                      },
+                    }
+                  : {
+                      inlineData: {
+                        mimeType: mediaType,
+                        data: convertToBase64(part.data),
+                      },
+                    },
+              );
+
+              break;
+            }
+          }
+        }
+
+        contents.push({ role: 'user', parts });
+        break;
+      }
+
+      case 'assistant': {
+        systemMessagesAllowed = false;
+
+        contents.push({
+          role: 'model',
+          parts: content
+            .map(part => {
+              const providerOpts =
+                part.providerOptions?.[providerOptionsName] ??
+                (providerOptionsName !== 'google'
+                  ? part.providerOptions?.google
+                  : part.providerOptions?.vertex);
+              const thoughtSignature =
+                providerOpts?.thoughtSignature != null
+                  ? String(providerOpts.thoughtSignature)
+                  : undefined;
+
+              switch (part.type) {
+                case 'text': {
+                  return part.text.length === 0
+                    ? undefined
+                    : {
+                        text: part.text,
+                        thoughtSignature,
+                      };
+                }
+
+                case 'reasoning': {
+                  return part.text.length === 0
+                    ? undefined
+                    : {
+                        text: part.text,
+                        thought: true,
+                        thoughtSignature,
+                      };
+                }
+
+                case 'file': {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality:
+                        'File data URLs in assistant messages are not supported',
+                    });
+                  }
+
+                  return {
+                    inlineData: {
+                      mimeType: part.mediaType,
+                      data: convertToBase64(part.data),
+                    },
+                    thoughtSignature,
+                  };
+                }
+
+                case 'tool-call': {
+                  return {
+                    functionCall: {
+                      name: part.toolName,
+                      args: part.input,
+                    },
+                    thoughtSignature,
+                  };
+                }
+              }
+            })
+            .filter(part => part !== undefined),
+        });
+        break;
+      }
+
+      case 'tool': {
+        systemMessagesAllowed = false;
+
+        const parts: GoogleGenerativeAIContentPart[] = [];
+
+        for (const part of content) {
+          if (part.type === 'tool-approval-response') {
+            continue;
+          }
+          const output = part.output;
+
+          if (output.type === 'content') {
+            for (const contentPart of output.value) {
+              switch (contentPart.type) {
+                case 'text':
+                  parts.push({
+                    functionResponse: {
+                      name: part.toolName,
+                      response: {
+                        name: part.toolName,
+                        content: contentPart.text,
+                      },
+                    },
+                  });
+                  break;
+                case 'image-data':
+                  parts.push(
+                    {
+                      inlineData: {
+                        mimeType: contentPart.mediaType,
+                        data: contentPart.data,
+                      },
+                    },
+                    {
+                      text: 'Tool executed successfully and returned this image as a response',
+                    },
+                  );
+                  break;
+                default:
+                  parts.push({ text: JSON.stringify(contentPart) });
+                  break;
+              }
+            }
+          } else {
+            parts.push({
+              functionResponse: {
+                name: part.toolName,
+                response: {
+                  name: part.toolName,
+                  content:
+                    output.type === 'execution-denied'
+                      ? (output.reason ?? 'Tool execution denied.')
+                      : output.value,
+                },
+              },
+            });
+          }
+        }
+
+        contents.push({
+          role: 'user',
+          parts,
+        });
+        break;
+      }
+    }
+  }
+
+  if (
+    isGemmaModel &&
+    systemInstructionParts.length > 0 &&
+    contents.length > 0 &&
+    contents[0].role === 'user'
+  ) {
+    const systemText = systemInstructionParts
+      .map(part => part.text)
+      .join('\n\n');
+
+    contents[0].parts.unshift({ text: systemText + '\n\n' });
+  }
+
+  return {
+    systemInstruction:
+      systemInstructionParts.length > 0 && !isGemmaModel
+        ? { parts: systemInstructionParts }
+        : undefined,
+    contents,
+  };
+}

package/src/get-model-path.ts

@@ -0,0 +1,3 @@
+export function getModelPath(modelId: string): string {
+  return modelId.includes('/') ? modelId : `models/${modelId}`;
+}

package/src/google-error.ts

@@ -0,0 +1,26 @@
+import {
+  createJsonErrorResponseHandler,
+  type InferSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const googleErrorDataSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      error: z.object({
+        code: z.number().nullable(),
+        message: z.string(),
+        status: z.string(),
+      }),
+    }),
+  ),
+);
+
+export type GoogleErrorData = InferSchema<typeof googleErrorDataSchema>;
+
+export const googleFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: googleErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});