@depup/ai-sdk__google 3.0.43-depup.0

package/src/google-prepare-tools.ts

@@ -0,0 +1,254 @@
+import {
+  LanguageModelV3CallOptions,
+  SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { convertJSONSchemaToOpenAPISchema } from './convert-json-schema-to-openapi-schema';
+import { GoogleGenerativeAIModelId } from './google-generative-ai-options';
+
+export function prepareTools({
+  tools,
+  toolChoice,
+  modelId,
+}: {
+  tools: LanguageModelV3CallOptions['tools'];
+  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+  modelId: GoogleGenerativeAIModelId;
+}): {
+  tools:
+    | Array<
+        | {
+            functionDeclarations: Array<{
+              name: string;
+              description: string;
+              parameters: unknown;
+            }>;
+          }
+        | Record<string, any>
+      >
+    | undefined;
+  toolConfig:
+    | undefined
+    | {
+        functionCallingConfig: {
+          mode: 'AUTO' | 'NONE' | 'ANY';
+          allowedFunctionNames?: string[];
+        };
+      };
+  toolWarnings: SharedV3Warning[];
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+
+  const isLatest = (
+    [
+      'gemini-flash-latest',
+      'gemini-flash-lite-latest',
+      'gemini-pro-latest',
+    ] as const satisfies GoogleGenerativeAIModelId[]
+  ).some(id => id === modelId);
+  const isGemini2orNewer =
+    modelId.includes('gemini-2') ||
+    modelId.includes('gemini-3') ||
+    modelId.includes('nano-banana') ||
+    isLatest;
+  const supportsFileSearch =
+    modelId.includes('gemini-2.5') || modelId.includes('gemini-3');
+
+  if (tools == null) {
+    return { tools: undefined, toolConfig: undefined, toolWarnings };
+  }
+
+  // Check for mixed tool types and add warnings
+  const hasFunctionTools = tools.some(tool => tool.type === 'function');
+  const hasProviderTools = tools.some(tool => tool.type === 'provider');
+
+  if (hasFunctionTools && hasProviderTools) {
+    toolWarnings.push({
+      type: 'unsupported',
+      feature: `combination of function and provider-defined tools`,
+    });
+  }
+
+  if (hasProviderTools) {
+    const googleTools: any[] = [];
+
+    const ProviderTools = tools.filter(tool => tool.type === 'provider');
+    ProviderTools.forEach(tool => {
+      switch (tool.id) {
+        case 'google.google_search':
+          if (isGemini2orNewer) {
+            googleTools.push({ googleSearch: { ...tool.args } });
+          } else {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details: 'Google Search requires Gemini 2.0 or newer.',
+            });
+          }
+          break;
+        case 'google.enterprise_web_search':
+          if (isGemini2orNewer) {
+            googleTools.push({ enterpriseWebSearch: {} });
+          } else {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details: 'Enterprise Web Search requires Gemini 2.0 or newer.',
+            });
+          }
+          break;
+        case 'google.url_context':
+          if (isGemini2orNewer) {
+            googleTools.push({ urlContext: {} });
+          } else {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details:
+                'The URL context tool is not supported with other Gemini models than Gemini 2.',
+            });
+          }
+          break;
+        case 'google.code_execution':
+          if (isGemini2orNewer) {
+            googleTools.push({ codeExecution: {} });
+          } else {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details:
+                'The code execution tools is not supported with other Gemini models than Gemini 2.',
+            });
+          }
+          break;
+        case 'google.file_search':
+          if (supportsFileSearch) {
+            googleTools.push({ fileSearch: { ...tool.args } });
+          } else {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details:
+                'The file search tool is only supported with Gemini 2.5 models and Gemini 3 models.',
+            });
+          }
+          break;
+        case 'google.vertex_rag_store':
+          if (isGemini2orNewer) {
+            googleTools.push({
+              retrieval: {
+                vertex_rag_store: {
+                  rag_resources: {
+                    rag_corpus: tool.args.ragCorpus,
+                  },
+                  similarity_top_k: tool.args.topK as number | undefined,
+                },
+              },
+            });
+          } else {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details:
+                'The RAG store tool is not supported with other Gemini models than Gemini 2.',
+            });
+          }
+          break;
+        case 'google.google_maps':
+          if (isGemini2orNewer) {
+            googleTools.push({ googleMaps: {} });
+          } else {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details:
+                'The Google Maps grounding tool is not supported with Gemini models other than Gemini 2 or newer.',
+            });
+          }
+          break;
+        default:
+          toolWarnings.push({
+            type: 'unsupported',
+            feature: `provider-defined tool ${tool.id}`,
+          });
+          break;
+      }
+    });
+
+    return {
+      tools: googleTools.length > 0 ? googleTools : undefined,
+      toolConfig: undefined,
+      toolWarnings,
+    };
+  }
+
+  const functionDeclarations = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case 'function':
+        functionDeclarations.push({
+          name: tool.name,
+          description: tool.description ?? '',
+          parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema),
+        });
+        break;
+      default:
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `function tool ${tool.name}`,
+        });
+        break;
+    }
+  }
+
+  if (toolChoice == null) {
+    return {
+      tools: [{ functionDeclarations }],
+      toolConfig: undefined,
+      toolWarnings,
+    };
+  }
+
+  const type = toolChoice.type;
+
+  switch (type) {
+    case 'auto':
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: { functionCallingConfig: { mode: 'AUTO' } },
+        toolWarnings,
+      };
+    case 'none':
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: { functionCallingConfig: { mode: 'NONE' } },
+        toolWarnings,
+      };
+    case 'required':
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: { functionCallingConfig: { mode: 'ANY' } },
+        toolWarnings,
+      };
+    case 'tool':
+      return {
+        tools: [{ functionDeclarations }],
+        toolConfig: {
+          functionCallingConfig: {
+            mode: 'ANY',
+            allowedFunctionNames: [toolChoice.toolName],
+          },
+        },
+        toolWarnings,
+      };
+    default: {
+      const _exhaustiveCheck: never = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      });
+    }
+  }
+}

package/src/google-provider.ts

@@ -0,0 +1,227 @@
+import {
+  EmbeddingModelV3,
+  Experimental_VideoModelV3,
+  ImageModelV3,
+  LanguageModelV3,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  generateId,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from './version';
+import { GoogleGenerativeAIEmbeddingModel } from './google-generative-ai-embedding-model';
+import { GoogleGenerativeAIEmbeddingModelId } from './google-generative-ai-embedding-options';
+import { GoogleGenerativeAILanguageModel } from './google-generative-ai-language-model';
+import { GoogleGenerativeAIModelId } from './google-generative-ai-options';
+import { googleTools } from './google-tools';
+
+import {
+  GoogleGenerativeAIImageSettings,
+  GoogleGenerativeAIImageModelId,
+} from './google-generative-ai-image-settings';
+import { GoogleGenerativeAIImageModel } from './google-generative-ai-image-model';
+import { GoogleGenerativeAIVideoModel } from './google-generative-ai-video-model';
+import { GoogleGenerativeAIVideoModelId } from './google-generative-ai-video-settings';
+
+export interface GoogleGenerativeAIProvider extends ProviderV3 {
+  (modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+
+  languageModel(modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+
+  chat(modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+
+  /**
+   * Creates a model for image generation.
+   */
+  image(
+    modelId: GoogleGenerativeAIImageModelId,
+    settings?: GoogleGenerativeAIImageSettings,
+  ): ImageModelV3;
+
+  /**
+   * @deprecated Use `chat()` instead.
+   */
+  generativeAI(modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+
+  /**
+   * Creates a model for text embeddings.
+   */
+  embedding(modelId: GoogleGenerativeAIEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * Creates a model for text embeddings.
+   */
+  embeddingModel(modelId: GoogleGenerativeAIEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embedding` instead.
+   */
+  textEmbedding(modelId: GoogleGenerativeAIEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(
+    modelId: GoogleGenerativeAIEmbeddingModelId,
+  ): EmbeddingModelV3;
+
+  /**
+   * Creates a model for video generation.
+   */
+  video(modelId: GoogleGenerativeAIVideoModelId): Experimental_VideoModelV3;
+
+  /**
+   * Creates a model for video generation.
+   */
+  videoModel(
+    modelId: GoogleGenerativeAIVideoModelId,
+  ): Experimental_VideoModelV3;
+
+  tools: typeof googleTools;
+}
+
+export interface GoogleGenerativeAIProviderSettings {
+  /**
+   * Use a different URL prefix for API calls, e.g. to use proxy servers.
+   * The default prefix is `https://generativelanguage.googleapis.com/v1beta`.
+   */
+  baseURL?: string;
+
+  /**
+   * API key that is being send using the `x-goog-api-key` header.
+   * It defaults to the `GOOGLE_GENERATIVE_AI_API_KEY` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * Custom headers to include in the requests.
+   */
+  headers?: Record<string, string | undefined>;
+
+  /**
+   * Custom fetch implementation. You can use it as a middleware to intercept requests,
+   * or to provide a custom fetch implementation for e.g. testing.
+   */
+  fetch?: FetchFunction;
+
+  /**
+   * Optional function to generate a unique ID for each request.
+   */
+  generateId?: () => string;
+
+  /**
+   * Custom provider name
+   * Defaults to 'google.generative-ai'.
+   */
+  name?: string;
+}
+
+/**
+ * Create a Google Generative AI provider instance.
+ */
+export function createGoogleGenerativeAI(
+  options: GoogleGenerativeAIProviderSettings = {},
+): GoogleGenerativeAIProvider {
+  const baseURL =
+    withoutTrailingSlash(options.baseURL) ??
+    'https://generativelanguage.googleapis.com/v1beta';
+
+  const providerName = options.name ?? 'google.generative-ai';
+
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        'x-goog-api-key': loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'GOOGLE_GENERATIVE_AI_API_KEY',
+          description: 'Google Generative AI',
+        }),
+        ...options.headers,
+      },
+      `ai-sdk/google/${VERSION}`,
+    );
+
+  const createChatModel = (modelId: GoogleGenerativeAIModelId) =>
+    new GoogleGenerativeAILanguageModel(modelId, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      generateId: options.generateId ?? generateId,
+      supportedUrls: () => ({
+        '*': [
+          // Google Generative Language "files" endpoint
+          // e.g. https://generativelanguage.googleapis.com/v1beta/files/...
+          new RegExp(`^${baseURL}/files/.*$`),
+          // YouTube URLs (public or unlisted videos)
+          new RegExp(
+            `^https://(?:www\\.)?youtube\\.com/watch\\?v=[\\w-]+(?:&[\\w=&.-]*)?$`,
+          ),
+          new RegExp(`^https://youtu\\.be/[\\w-]+(?:\\?[\\w=&.-]*)?$`),
+        ],
+      }),
+      fetch: options.fetch,
+    });
+
+  const createEmbeddingModel = (modelId: GoogleGenerativeAIEmbeddingModelId) =>
+    new GoogleGenerativeAIEmbeddingModel(modelId, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createImageModel = (
+    modelId: GoogleGenerativeAIImageModelId,
+    settings: GoogleGenerativeAIImageSettings = {},
+  ) =>
+    new GoogleGenerativeAIImageModel(modelId, settings, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createVideoModel = (modelId: GoogleGenerativeAIVideoModelId) =>
+    new GoogleGenerativeAIVideoModel(modelId, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      generateId: options.generateId ?? generateId,
+    });
+
+  const provider = function (modelId: GoogleGenerativeAIModelId) {
+    if (new.target) {
+      throw new Error(
+        'The Google Generative AI model function cannot be called with the new keyword.',
+      );
+    }
+
+    return createChatModel(modelId);
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.generativeAI = createChatModel;
+  provider.embedding = createEmbeddingModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbedding = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.video = createVideoModel;
+  provider.videoModel = createVideoModel;
+  provider.tools = googleTools;
+
+  return provider as GoogleGenerativeAIProvider;
+}
+
+/**
+ * Default Google Generative AI provider instance.
+ */
+export const google = createGoogleGenerativeAI();

package/src/google-supported-file-url.ts

@@ -0,0 +1,20 @@
+export function isSupportedFileUrl(url: URL): boolean {
+  const urlString = url.toString();
+
+  // Google Generative Language files API
+  if (
+    urlString.startsWith(
+      'https://generativelanguage.googleapis.com/v1beta/files/',
+    )
+  ) {
+    return true;
+  }
+
+  // YouTube URLs (public or unlisted videos)
+  const youtubeRegexes = [
+    /^https:\/\/(?:www\.)?youtube\.com\/watch\?v=[\w-]+(?:&[\w=&.-]*)?$/,
+    /^https:\/\/youtu\.be\/[\w-]+(?:\?[\w=&.-]*)?$/,
+  ];
+
+  return youtubeRegexes.some(regex => regex.test(urlString));
+}

package/src/google-tools.ts

@@ -0,0 +1,71 @@
+import { codeExecution } from './tool/code-execution';
+import { enterpriseWebSearch } from './tool/enterprise-web-search';
+import { fileSearch } from './tool/file-search';
+import { googleMaps } from './tool/google-maps';
+import { googleSearch } from './tool/google-search';
+import { urlContext } from './tool/url-context';
+import { vertexRagStore } from './tool/vertex-rag-store';
+
+export const googleTools = {
+  /**
+   * Creates a Google search tool that gives Google direct access to real-time web content.
+   * Must have name "google_search".
+   */
+  googleSearch,
+
+  /**
+   * Creates an Enterprise Web Search tool for grounding responses using a compliance-focused web index.
+   * Designed for highly-regulated industries (finance, healthcare, public sector).
+   * Does not log customer data and supports VPC service controls.
+   * Must have name "enterprise_web_search".
+   *
+   * @note Only available on Vertex AI. Requires Gemini 2.0 or newer.
+   *
+   * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
+   */
+  enterpriseWebSearch,
+
+  /**
+   * Creates a Google Maps grounding tool that gives the model access to Google Maps data.
+   * Must have name "google_maps".
+   *
+   * @see https://ai.google.dev/gemini-api/docs/maps-grounding
+   * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
+   */
+  googleMaps,
+
+  /**
+   * Creates a URL context tool that gives Google direct access to real-time web content.
+   * Must have name "url_context".
+   */
+  urlContext,
+
+  /**
+   * Enables Retrieval Augmented Generation (RAG) via the Gemini File Search tool.
+   * Must have name "file_search".
+   *
+   * @param fileSearchStoreNames - Fully-qualified File Search store resource names.
+   * @param metadataFilter - Optional filter expression to restrict the files that can be retrieved.
+   * @param topK - Optional result limit for the number of chunks returned from File Search.
+   *
+   * @see https://ai.google.dev/gemini-api/docs/file-search
+   */
+  fileSearch,
+  /**
+   * A tool that enables the model to generate and run Python code.
+   * Must have name "code_execution".
+   *
+   * @note Ensure the selected model supports Code Execution.
+   * Multi-tool usage with the code execution tool is typically compatible with Gemini >=2 models.
+   *
+   * @see https://ai.google.dev/gemini-api/docs/code-execution (Google AI)
+   * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/code-execution-api (Vertex AI)
+   */
+  codeExecution,
+
+  /**
+   * Creates a Vertex RAG Store tool that enables the model to perform RAG searches against a Vertex RAG Store.
+   * Must have name "vertex_rag_store".
+   */
+  vertexRagStore,
+};

package/src/index.ts

@@ -0,0 +1,29 @@
+export type { GoogleErrorData } from './google-error';
+export type {
+  GoogleLanguageModelOptions,
+  /** @deprecated Use `GoogleLanguageModelOptions` instead. */
+  GoogleLanguageModelOptions as GoogleGenerativeAIProviderOptions,
+} from './google-generative-ai-options';
+export type { GoogleGenerativeAIProviderMetadata } from './google-generative-ai-prompt';
+export type {
+  GoogleImageModelOptions,
+  /** @deprecated Use `GoogleImageModelOptions` instead. */
+  GoogleImageModelOptions as GoogleGenerativeAIImageProviderOptions,
+} from './google-generative-ai-image-model';
+export type {
+  GoogleEmbeddingModelOptions,
+  /** @deprecated Use `GoogleEmbeddingModelOptions` instead. */
+  GoogleEmbeddingModelOptions as GoogleGenerativeAIEmbeddingProviderOptions,
+} from './google-generative-ai-embedding-options';
+export type {
+  GoogleVideoModelOptions,
+  /** @deprecated Use `GoogleVideoModelOptions` instead. */
+  GoogleVideoModelOptions as GoogleGenerativeAIVideoProviderOptions,
+} from './google-generative-ai-video-model';
+export type { GoogleGenerativeAIVideoModelId } from './google-generative-ai-video-settings';
+export { createGoogleGenerativeAI, google } from './google-provider';
+export type {
+  GoogleGenerativeAIProvider,
+  GoogleGenerativeAIProviderSettings,
+} from './google-provider';
+export { VERSION } from './version';

package/src/internal/index.ts

@@ -0,0 +1,3 @@
+export * from '../google-generative-ai-language-model';
+export { googleTools } from '../google-tools';
+export type { GoogleGenerativeAIModelId } from '../google-generative-ai-options';

package/src/map-google-generative-ai-finish-reason.ts

@@ -0,0 +1,29 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapGoogleGenerativeAIFinishReason({
+  finishReason,
+  hasToolCalls,
+}: {
+  finishReason: string | null | undefined;
+  hasToolCalls: boolean;
+}): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'STOP':
+      return hasToolCalls ? 'tool-calls' : 'stop';
+    case 'MAX_TOKENS':
+      return 'length';
+    case 'IMAGE_SAFETY':
+    case 'RECITATION':
+    case 'SAFETY':
+    case 'BLOCKLIST':
+    case 'PROHIBITED_CONTENT':
+    case 'SPII':
+      return 'content-filter';
+    case 'MALFORMED_FUNCTION_CALL':
+      return 'error';
+    case 'FINISH_REASON_UNSPECIFIED':
+    case 'OTHER':
+    default:
+      return 'other';
+  }
+}

package/src/tool/code-execution.ts

@@ -0,0 +1,35 @@
+import { createProviderToolFactoryWithOutputSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+/**
+ * A tool that enables the model to generate and run Python code.
+ *
+ * @note Ensure the selected model supports Code Execution.
+ * Multi-tool usage with the code execution tool is typically compatible with Gemini >=2 models.
+ *
+ * @see https://ai.google.dev/gemini-api/docs/code-execution (Google AI)
+ * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/code-execution-api (Vertex AI)
+ */
+export const codeExecution = createProviderToolFactoryWithOutputSchema<
+  {
+    language: string;
+    code: string;
+  },
+  {
+    outcome: string;
+    output: string;
+  },
+  {}
+>({
+  id: 'google.code_execution',
+  inputSchema: z.object({
+    language: z.string().describe('The programming language of the code.'),
+    code: z.string().describe('The code to be executed.'),
+  }),
+  outputSchema: z.object({
+    outcome: z
+      .string()
+      .describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
+    output: z.string().describe('The output from the code execution.'),
+  }),
+});

package/src/tool/enterprise-web-search.ts

@@ -0,0 +1,18 @@
+import {
+  createProviderToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+// https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
+
+export const enterpriseWebSearch = createProviderToolFactory<
+  {
+    // Enterprise Web Search does not have any input schema
+  },
+  {}
+>({
+  id: 'google.enterprise_web_search',
+  inputSchema: lazySchema(() => zodSchema(z.object({}))),
+});