@langchain/google 0.1.0 → 0.1.1

package/dist/clients/node.cjs

@@ -1,11 +1,10 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_const = require('../const.cjs');
 const require_misc = require('../utils/misc.cjs');
 const require_errors = require('../utils/errors.cjs');
 const require_gcp_auth = require('../utils/gcp-auth.cjs');
 const require_index = require('./index.cjs');
-const __langchain_core_utils_env = require_rolldown_runtime.__toESM(require("@langchain/core/utils/env"));
-const google_auth_library = require_rolldown_runtime.__toESM(require("google-auth-library"));
+let _langchain_core_utils_env = require("@langchain/core/utils/env");
+let google_auth_library = require("google-auth-library");
 
 //#region src/clients/node.ts
 /**
@@ -175,17 +174,15 @@ var NodeApiClient = class extends require_index.ApiClient {
 	constructor(params = {}) {
 		super();
 		this.params = params;
-		this.apiKey = params.apiKey ?? (0, __langchain_core_utils_env.getEnvironmentVariable)("GOOGLE_API_KEY");
+		this.apiKey = params.apiKey ?? (0, _langchain_core_utils_env.getEnvironmentVariable)("GOOGLE_API_KEY");
 		this.credentials = require_misc.iife(() => {
 			if (params.credentials) return require_gcp_auth.normalizeGCPCredentials(params.credentials);
-			const credentialsVar = (0, __langchain_core_utils_env.getEnvironmentVariable)("GOOGLE_CLOUD_CREDENTIALS");
+			const credentialsVar = (0, _langchain_core_utils_env.getEnvironmentVariable)("GOOGLE_CLOUD_CREDENTIALS");
 			if (credentialsVar) return require_gcp_auth.normalizeGCPCredentials(credentialsVar);
-			return void 0;
 		});
 		this.googleAuth = require_misc.iife(() => {
 			if (params.googleAuthOptions) return new google_auth_library.GoogleAuth(params.googleAuthOptions);
 			if (!this.apiKey && !this.credentials) return new google_auth_library.GoogleAuth();
-			return void 0;
 		});
 	}
 	/**
@@ -230,12 +227,9 @@ var NodeApiClient = class extends require_index.ApiClient {
 	async fetch(request) {
 		if (this.apiKey) request.headers.set(require_const.GOOGLE_API_KEY_HEADER, this.apiKey);
 		else if (this.credentials) request.headers.set(require_const.GCP_API_KEY_HEADER, `Bearer ${require_gcp_auth.getGCPCredentialsAccessToken(this.credentials)}`);
-		else if (this.googleAuth) {
-			const authHeaders = await this.googleAuth.getRequestHeaders(request.url);
-			authHeaders.forEach((value, key) => {
-				if (value !== null) request.headers.set(key, value);
-			});
-		}
+		else if (this.googleAuth) (await this.googleAuth.getRequestHeaders(request.url)).forEach((value, key) => {
+			if (value !== null) request.headers.set(key, value);
+		});
 		return fetch(request);
 	}
 };
@@ -315,8 +309,7 @@ function ensureAuthScopes(authOptions, requiredScopes) {
 	};
 	else {
 		const existingScopes = Array.isArray(authOptions.scopes) ? authOptions.scopes : [authOptions.scopes];
-		const missingScopes = requiredScopes.filter((scope) => !existingScopes.includes(scope));
-		if (missingScopes.length > 0) throw new require_errors.ConfigurationError(`Invalid auth scopes. Scopes must include ${requiredScopes.join(", ")}`);
+		if (requiredScopes.filter((scope) => !existingScopes.includes(scope)).length > 0) throw new require_errors.ConfigurationError(`Invalid auth scopes. Scopes must include ${requiredScopes.join(", ")}`);
 	}
 	return authOptions;
 }

package/dist/clients/node.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"node.cjs","names":["ApiClient","params: NodeApiClientParams","iife","normalizeGCPCredentials","GoogleAuth","request: Request","GOOGLE_API_KEY_HEADER","GCP_API_KEY_HEADER","getGCPCredentialsAccessToken","authOptions: GoogleAuthOptions","requiredScopes: string[]","ConfigurationError"],"sources":["../../src/clients/node.ts"],"sourcesContent":["import { GoogleAuth, type GoogleAuthOptions } from \"google-auth-library\";\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { GCP_API_KEY_HEADER, GOOGLE_API_KEY_HEADER } from \"../const.js\";\nimport { ApiClient } from \"./index.js\";\nimport {\n  GCPCredentials,\n  getGCPCredentialsAccessToken,\n  normalizeGCPCredentials,\n} from \"../utils/gcp-auth.js\";\nimport { ConfigurationError } from \"../utils/errors.js\";\nimport { iife } from \"../utils/misc.js\";\n\n/**\n * Configuration parameters for the NodeApiClient.\n *\n * This interface defines the authentication options available for Node.js-based\n * API clients. Authentication can be provided via an API key, GCP service\n * account credentials, or advanced Google Auth options. The client will\n * automatically check environment variables if explicit values are not provided.\n *\n * @interface\n */\nexport interface NodeApiClientParams {\n  /**\n   * Google API key for authentication.\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @see https://cloud.google.com/docs/authentication/api-keys\n   */\n  apiKey?: string;\n\n  /**\n   * GCP service account credentials for authentication.\n   *\n   * Can be provided as either:\n   * - A JSON string containing the service account key\n   * - A GCPCredentials object\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable.\n   *\n   * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys\n   */\n  credentials?: string | GCPCredentials;\n\n  /**\n   * Google Auth options configuration.\n   *\n   * Provides fine-grained control over authentication behavior using the\n   * google-auth-library. This option enables:\n   * - Custom OAuth2 scopes\n   * - Application Default Credentials (ADC)\n   * - Impersonation and delegation\n   * - Custom credential sources\n   *\n   * When provided, this takes precedence over simple credential-based auth\n   * but is lower priority than API key authentication.\n   *\n   * @see https://github.com/googleapis/google-auth-library-nodejs\n   * @see https://cloud.google.com/docs/authentication/application-default-credentials\n   */\n  googleAuthOptions?: GoogleAuthOptions;\n}\n\n/**\n * Node.js-specific API client for Google services.\n *\n * This client provides comprehensive authentication for Google API requests in\n * Node.js environments, leveraging the full capabilities of the google-auth-library.\n * It supports three authentication methods with the following priority:\n *\n * 1. **API Key Authentication**: Simple key-based authentication suitable for\n *    public APIs and development environments.\n *\n * 2. **Service Account Credentials**: OAuth2-based authentication using GCP\n *    service account keys. The client automatically handles token generation\n *    and caching using a web-compatible implementation.\n *\n * 3. **Google Auth Library**: Advanced authentication using google-auth-library,\n *    supporting Application Default Credentials (ADC), custom scopes, and\n *    various credential sources.\n *\n * The client follows this authentication priority:\n * 1. Explicit `apiKey` parameter\n * 2. `GOOGLE_API_KEY` environment variable\n * 3. Explicit `credentials` parameter\n * 4. `GOOGLE_CLOUD_CREDENTIALS` environment variable\n * 5. `googleAuthOptions` parameter\n * 6. Application Default Credentials (if googleAuthOptions is provided without explicit credentials)\n *\n * @extends ApiClient\n *\n * @example\n * ```typescript\n * // Using API key\n * const client = new NodeApiClient({\n *   apiKey: 'your-api-key'\n * });\n *\n * // Using service account credentials\n * const client = new NodeApiClient({\n *   credentials: {\n *     type: \"service_account\",\n *     project_id: \"my-project\",\n *     private_key_id: \"key-id\",\n *     private_key: \"-----BEGIN PRIVATE KEY-----\\n...\",\n *     client_email: \"service-account@project.iam.gserviceaccount.com\",\n *     // ... other required fields\n *   }\n * });\n *\n * // Using Google Auth with custom scopes\n * const client = new NodeApiClient({\n *   googleAuthOptions: {\n *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n *     keyFilename: '/path/to/service-account-key.json'\n *   }\n * });\n *\n * // Using Application Default Credentials\n * const client = new NodeApiClient({\n *   googleAuthOptions: {}\n * });\n *\n * // Using environment variables\n * // Set GOOGLE_API_KEY or GOOGLE_CLOUD_CREDENTIALS\n * const client = new NodeApiClient();\n *\n * // Make authenticated requests\n * const request = new Request('https://api.google.com/...');\n * const response = await client.fetch(request);\n * ```\n *\n * @remarks\n * - API keys are added via the `X-Goog-Api-Key` header\n * - Service account tokens are added via the `Authorization` header with Bearer scheme\n * - Google Auth headers are automatically generated and added by google-auth-library\n * - Tokens are automatically cached and refreshed as needed\n * - For web/edge environments without google-auth-library, use WebApiClient instead\n *\n * @see {@link WebApiClient} for web-compatible authentication without google-auth-library\n * @see {@link GCPCredentials} for service account credential structure\n * @see {@link GoogleAuthOptions} for advanced authentication configuration\n */\nexport class NodeApiClient extends ApiClient {\n  hasApiKey(): boolean {\n    return typeof this.apiKey === \"string\" && this.apiKey !== \"\";\n  }\n\n  async getProjectId(): Promise<string> {\n    if (typeof this.credentials !== \"undefined\") {\n      return this.credentials.project_id;\n    } else if (typeof this.googleAuth !== \"undefined\") {\n      return this.googleAuth.getProjectId();\n    } else {\n      return super.getProjectId();\n    }\n  }\n\n  /**\n   * The Google API key used for authentication, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @protected\n   */\n  protected apiKey?: string;\n\n  /**\n   * The normalized GCP service account credentials, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable, and is normalized\n   * to ensure immutability.\n   *\n   * @protected\n   */\n  protected credentials?: GCPCredentials;\n\n  /**\n   * The Google Auth instance for advanced authentication, if configured.\n   *\n   * This instance is created when `googleAuthOptions` is provided and\n   * handles Application Default Credentials, custom scopes, and other\n   * advanced authentication scenarios.\n   *\n   * @protected\n   */\n  protected googleAuth?: GoogleAuth;\n\n  /**\n   * Creates a new NodeApiClient instance.\n   *\n   * The constructor initializes authentication credentials by checking:\n   * 1. Explicit parameters passed to the constructor\n   * 2. Environment variables (`GOOGLE_API_KEY`, `GOOGLE_CLOUD_CREDENTIALS`)\n   * 3. Application Default Credentials (if googleAuthOptions is provided)\n   *\n   * Credentials are normalized and frozen to prevent accidental modification.\n   * The GoogleAuth instance is lazily initialized only when googleAuthOptions\n   * is provided.\n   *\n   * @param params - Configuration parameters for the client. Defaults to an empty object.\n   *\n   * @example\n   * ```typescript\n   * // Minimal configuration (uses environment variables or ADC)\n   * const client = new NodeApiClient();\n   *\n   * // With explicit API key\n   * const client = new WebApiClient({\n   *   apiKey: 'your-api-key'\n   * });\n   *\n   * // With service account credentials as JSON string\n   * const client = new WebApiClient({\n   *   credentials: '{\"type\":\"service_account\",...}'\n   * });\n   *\n   * // With service account credentials as object\n   * const client = new NodeApiClient({\n   *   credentials: {\n   *     type: \"service_account\",\n   *     // ... other fields\n   *   }\n   * });\n   *\n   * // With Google Auth options\n   * const client = new NodeApiClient({\n   *   googleAuthOptions: {\n   *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n   *     projectId: 'my-project'\n   *   }\n   * });\n   * ```\n   */\n  constructor(protected params: NodeApiClientParams = {}) {\n    super();\n\n    this.apiKey = params.apiKey ?? getEnvironmentVariable(\"GOOGLE_API_KEY\");\n    this.credentials = iife(() => {\n      if (params.credentials) {\n        return normalizeGCPCredentials(params.credentials);\n      }\n      const credentialsVar = getEnvironmentVariable(\"GOOGLE_CLOUD_CREDENTIALS\");\n      if (credentialsVar) {\n        return normalizeGCPCredentials(credentialsVar);\n      }\n      return undefined;\n    });\n    this.googleAuth = iife(() => {\n      if (params.googleAuthOptions) {\n        return new GoogleAuth(params.googleAuthOptions);\n      }\n      if (!this.apiKey && !this.credentials) {\n        return new GoogleAuth();\n      }\n      return undefined;\n    });\n  }\n\n  /**\n   * Executes an HTTP request with appropriate Google API authentication.\n   *\n   * This method adds authentication headers to the request based on the\n   * configured authentication method, following this priority:\n   *\n   * 1. If an API key is configured, adds the `X-Goog-Api-Key` header\n   * 2. If service account credentials are configured, generates an access token\n   *    and adds it via the `Authorization` header with Bearer scheme\n   * 3. If Google Auth is configured, uses google-auth-library to generate\n   *    appropriate authentication headers (may include Authorization, x-goog-user-project, etc.)\n   *\n   * The authentication priority ensures that explicit API keys take precedence,\n   * followed by service account credentials, and finally Google Auth options.\n   *\n   * @param request - The HTTP request to execute. Headers will be modified\n   *                  in-place to include authentication information.\n   * @returns A Promise that resolves to the HTTP response\n   *\n   * @throws {AuthError} If service account authentication fails (e.g., invalid\n   *                     credentials, network error, or token generation failure)\n   * @throws {Error} If Google Auth authentication fails (e.g., missing credentials,\n   *                 invalid configuration, or ADC not available)\n   *\n   * @example\n   * ```typescript\n   * const client = new NodeApiClient({ apiKey: 'your-key' });\n   * const request = new Request('https://generativelanguage.googleapis.com/v1/models');\n   * const response = await client.fetch(request);\n   * const data = await response.json();\n   * ```\n   *\n   * @remarks\n   * - The request object is modified in-place by adding headers\n   * - Service account tokens are automatically cached and refreshed\n   * - Google Auth tokens are managed by google-auth-library with automatic refresh\n   * - Only one authentication method is used per request (based on priority)\n   * - Google Auth may add multiple headers depending on the authentication type\n   */\n  async fetch(request: Request): Promise<Response> {\n    if (this.apiKey) {\n      request.headers.set(GOOGLE_API_KEY_HEADER, this.apiKey);\n    } else if (this.credentials) {\n      request.headers.set(\n        GCP_API_KEY_HEADER,\n        `Bearer ${getGCPCredentialsAccessToken(this.credentials)}`\n      );\n    } else if (this.googleAuth) {\n      const authHeaders = await this.googleAuth.getRequestHeaders(request.url);\n      authHeaders.forEach((value, key) => {\n        if (value !== null) {\n          request.headers.set(key, value);\n        }\n      });\n    }\n    return fetch(request);\n  }\n}\n\n/**\n * Ensures that Google Auth options include required OAuth2 scopes.\n *\n * This utility function validates and augments GoogleAuthOptions to ensure\n * that all required OAuth2 scopes are present. It handles three scenarios:\n *\n * 1. **No auth options provided**: Creates new options with required scopes\n * 2. **Auth options without scopes**: Adds required scopes to existing options\n * 3. **Auth options with scopes**: Validates that all required scopes are present\n *\n * This is particularly useful when working with Google APIs that require specific\n * scopes for access, ensuring that authentication is properly configured before\n * making API requests.\n *\n * @param authOptions - The existing Google Auth options to validate/augment.\n *                      Can be undefined or an empty object.\n * @param requiredScopes - Array of OAuth2 scope URLs that must be present.\n *                         These are typically Google API scope URLs like\n *                         'https://www.googleapis.com/auth/cloud-platform'\n * @returns The validated/augmented GoogleAuthOptions with all required scopes\n *\n * @throws {Error} If authOptions already has scopes but is missing any of the\n *                 required scopes. This prevents accidental scope reduction that\n *                 could break API access.\n *\n * @example\n * ```typescript\n * // Create new options with required scopes\n * const options = ensureAuthScopes(undefined, [\n *   'https://www.googleapis.com/auth/cloud-platform'\n * ]);\n * // Result: { scopes: ['https://www.googleapis.com/auth/cloud-platform'] }\n *\n * // Add scopes to existing options\n * const options = ensureAuthScopes(\n *   { projectId: 'my-project' },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: { projectId: 'my-project', scopes: [...] }\n *\n * // Validate existing scopes\n * const options = ensureAuthScopes(\n *   { scopes: ['https://www.googleapis.com/auth/cloud-platform'] },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: Original options (validation passed)\n *\n * // Error case - missing required scope\n * try {\n *   ensureAuthScopes(\n *     { scopes: ['https://www.googleapis.com/auth/userinfo.email'] },\n *     ['https://www.googleapis.com/auth/cloud-platform']\n *   );\n * } catch (error) {\n *   // Error: Invalid auth scopes. Scopes must include ...\n * }\n * ```\n *\n * @remarks\n * - Scopes can be provided as a string or array of strings in GoogleAuthOptions\n * - The function normalizes single-string scopes to arrays for validation\n * - Required scopes are not automatically added if existing scopes are present;\n *   instead, an error is thrown to prevent unintended scope changes\n * - This function does not modify the original authOptions object\n *\n * @see https://developers.google.com/identity/protocols/oauth2/scopes\n * @see {@link GoogleAuthOptions} for the full authentication configuration interface\n */\nexport function ensureAuthScopes(\n  authOptions: GoogleAuthOptions,\n  requiredScopes: string[]\n): GoogleAuthOptions {\n  if (!authOptions) {\n    return { scopes: requiredScopes };\n  } else if (!authOptions.scopes) {\n    return { ...authOptions, scopes: requiredScopes };\n  } else {\n    const existingScopes = Array.isArray(authOptions.scopes)\n      ? authOptions.scopes\n      : [authOptions.scopes];\n    const missingScopes = requiredScopes.filter(\n      (scope) => !existingScopes.includes(scope)\n    );\n    if (missingScopes.length > 0) {\n      throw new ConfigurationError(\n        `Invalid auth scopes. Scopes must include ${requiredScopes.join(\", \")}`\n      );\n    }\n  }\n  return authOptions;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkJA,IAAa,gBAAb,cAAmCA,wBAAU;CAC3C,YAAqB;AACnB,SAAO,OAAO,KAAK,WAAW,YAAY,KAAK,WAAW;CAC3D;CAED,MAAM,eAAgC;AACpC,MAAI,OAAO,KAAK,gBAAgB,YAC9B,QAAO,KAAK,YAAY;WACf,OAAO,KAAK,eAAe,YACpC,QAAO,KAAK,WAAW,cAAc;MAErC,QAAO,MAAM,cAAc;CAE9B;;;;;;;;;CAUD,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDV,YAAsBC,SAA8B,CAAE,GAAE;EACtD,OAAO;EADa;EAGpB,KAAK,SAAS,OAAO,iEAAiC,iBAAiB;EACvE,KAAK,cAAcC,kBAAK,MAAM;AAC5B,OAAI,OAAO,YACT,QAAOC,yCAAwB,OAAO,YAAY;GAEpD,MAAM,wEAAwC,2BAA2B;AACzE,OAAI,eACF,QAAOA,yCAAwB,eAAe;AAEhD,UAAO;EACR,EAAC;EACF,KAAK,aAAaD,kBAAK,MAAM;AAC3B,OAAI,OAAO,kBACT,QAAO,IAAIE,+BAAW,OAAO;AAE/B,OAAI,CAAC,KAAK,UAAU,CAAC,KAAK,YACxB,QAAO,IAAIA;AAEb,UAAO;EACR,EAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCD,MAAM,MAAMC,SAAqC;AAC/C,MAAI,KAAK,QACP,QAAQ,QAAQ,IAAIC,qCAAuB,KAAK,OAAO;WAC9C,KAAK,aACd,QAAQ,QAAQ,IACdC,kCACA,CAAC,OAAO,EAAEC,8CAA6B,KAAK,YAAY,EAAE,CAC3D;WACQ,KAAK,YAAY;GAC1B,MAAM,cAAc,MAAM,KAAK,WAAW,kBAAkB,QAAQ,IAAI;GACxE,YAAY,QAAQ,CAAC,OAAO,QAAQ;AAClC,QAAI,UAAU,MACZ,QAAQ,QAAQ,IAAI,KAAK,MAAM;GAElC,EAAC;EACH;AACD,SAAO,MAAM,QAAQ;CACtB;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsED,SAAgB,iBACdC,aACAC,gBACmB;AACnB,KAAI,CAAC,YACH,QAAO,EAAE,QAAQ,eAAgB;UACxB,CAAC,YAAY,OACtB,QAAO;EAAE,GAAG;EAAa,QAAQ;CAAgB;MAC5C;EACL,MAAM,iBAAiB,MAAM,QAAQ,YAAY,OAAO,GACpD,YAAY,SACZ,CAAC,YAAY,MAAO;EACxB,MAAM,gBAAgB,eAAe,OACnC,CAAC,UAAU,CAAC,eAAe,SAAS,MAAM,CAC3C;AACD,MAAI,cAAc,SAAS,EACzB,OAAM,IAAIC,kCACR,CAAC,yCAAyC,EAAE,eAAe,KAAK,KAAK,EAAE;CAG5E;AACD,QAAO;AACR"}
+{"version":3,"file":"node.cjs","names":["ApiClient","iife","normalizeGCPCredentials","GoogleAuth","GOOGLE_API_KEY_HEADER","GCP_API_KEY_HEADER","getGCPCredentialsAccessToken","ConfigurationError"],"sources":["../../src/clients/node.ts"],"sourcesContent":["import { GoogleAuth, type GoogleAuthOptions } from \"google-auth-library\";\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { GCP_API_KEY_HEADER, GOOGLE_API_KEY_HEADER } from \"../const.js\";\nimport { ApiClient } from \"./index.js\";\nimport {\n  GCPCredentials,\n  getGCPCredentialsAccessToken,\n  normalizeGCPCredentials,\n} from \"../utils/gcp-auth.js\";\nimport { ConfigurationError } from \"../utils/errors.js\";\nimport { iife } from \"../utils/misc.js\";\n\n/**\n * Configuration parameters for the NodeApiClient.\n *\n * This interface defines the authentication options available for Node.js-based\n * API clients. Authentication can be provided via an API key, GCP service\n * account credentials, or advanced Google Auth options. The client will\n * automatically check environment variables if explicit values are not provided.\n *\n * @interface\n */\nexport interface NodeApiClientParams {\n  /**\n   * Google API key for authentication.\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @see https://cloud.google.com/docs/authentication/api-keys\n   */\n  apiKey?: string;\n\n  /**\n   * GCP service account credentials for authentication.\n   *\n   * Can be provided as either:\n   * - A JSON string containing the service account key\n   * - A GCPCredentials object\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable.\n   *\n   * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys\n   */\n  credentials?: string | GCPCredentials;\n\n  /**\n   * Google Auth options configuration.\n   *\n   * Provides fine-grained control over authentication behavior using the\n   * google-auth-library. This option enables:\n   * - Custom OAuth2 scopes\n   * - Application Default Credentials (ADC)\n   * - Impersonation and delegation\n   * - Custom credential sources\n   *\n   * When provided, this takes precedence over simple credential-based auth\n   * but is lower priority than API key authentication.\n   *\n   * @see https://github.com/googleapis/google-auth-library-nodejs\n   * @see https://cloud.google.com/docs/authentication/application-default-credentials\n   */\n  googleAuthOptions?: GoogleAuthOptions;\n}\n\n/**\n * Node.js-specific API client for Google services.\n *\n * This client provides comprehensive authentication for Google API requests in\n * Node.js environments, leveraging the full capabilities of the google-auth-library.\n * It supports three authentication methods with the following priority:\n *\n * 1. **API Key Authentication**: Simple key-based authentication suitable for\n *    public APIs and development environments.\n *\n * 2. **Service Account Credentials**: OAuth2-based authentication using GCP\n *    service account keys. The client automatically handles token generation\n *    and caching using a web-compatible implementation.\n *\n * 3. **Google Auth Library**: Advanced authentication using google-auth-library,\n *    supporting Application Default Credentials (ADC), custom scopes, and\n *    various credential sources.\n *\n * The client follows this authentication priority:\n * 1. Explicit `apiKey` parameter\n * 2. `GOOGLE_API_KEY` environment variable\n * 3. Explicit `credentials` parameter\n * 4. `GOOGLE_CLOUD_CREDENTIALS` environment variable\n * 5. `googleAuthOptions` parameter\n * 6. Application Default Credentials (if googleAuthOptions is provided without explicit credentials)\n *\n * @extends ApiClient\n *\n * @example\n * ```typescript\n * // Using API key\n * const client = new NodeApiClient({\n *   apiKey: 'your-api-key'\n * });\n *\n * // Using service account credentials\n * const client = new NodeApiClient({\n *   credentials: {\n *     type: \"service_account\",\n *     project_id: \"my-project\",\n *     private_key_id: \"key-id\",\n *     private_key: \"-----BEGIN PRIVATE KEY-----\\n...\",\n *     client_email: \"service-account@project.iam.gserviceaccount.com\",\n *     // ... other required fields\n *   }\n * });\n *\n * // Using Google Auth with custom scopes\n * const client = new NodeApiClient({\n *   googleAuthOptions: {\n *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n *     keyFilename: '/path/to/service-account-key.json'\n *   }\n * });\n *\n * // Using Application Default Credentials\n * const client = new NodeApiClient({\n *   googleAuthOptions: {}\n * });\n *\n * // Using environment variables\n * // Set GOOGLE_API_KEY or GOOGLE_CLOUD_CREDENTIALS\n * const client = new NodeApiClient();\n *\n * // Make authenticated requests\n * const request = new Request('https://api.google.com/...');\n * const response = await client.fetch(request);\n * ```\n *\n * @remarks\n * - API keys are added via the `X-Goog-Api-Key` header\n * - Service account tokens are added via the `Authorization` header with Bearer scheme\n * - Google Auth headers are automatically generated and added by google-auth-library\n * - Tokens are automatically cached and refreshed as needed\n * - For web/edge environments without google-auth-library, use WebApiClient instead\n *\n * @see {@link WebApiClient} for web-compatible authentication without google-auth-library\n * @see {@link GCPCredentials} for service account credential structure\n * @see {@link GoogleAuthOptions} for advanced authentication configuration\n */\nexport class NodeApiClient extends ApiClient {\n  hasApiKey(): boolean {\n    return typeof this.apiKey === \"string\" && this.apiKey !== \"\";\n  }\n\n  async getProjectId(): Promise<string> {\n    if (typeof this.credentials !== \"undefined\") {\n      return this.credentials.project_id;\n    } else if (typeof this.googleAuth !== \"undefined\") {\n      return this.googleAuth.getProjectId();\n    } else {\n      return super.getProjectId();\n    }\n  }\n\n  /**\n   * The Google API key used for authentication, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @protected\n   */\n  protected apiKey?: string;\n\n  /**\n   * The normalized GCP service account credentials, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable, and is normalized\n   * to ensure immutability.\n   *\n   * @protected\n   */\n  protected credentials?: GCPCredentials;\n\n  /**\n   * The Google Auth instance for advanced authentication, if configured.\n   *\n   * This instance is created when `googleAuthOptions` is provided and\n   * handles Application Default Credentials, custom scopes, and other\n   * advanced authentication scenarios.\n   *\n   * @protected\n   */\n  protected googleAuth?: GoogleAuth;\n\n  /**\n   * Creates a new NodeApiClient instance.\n   *\n   * The constructor initializes authentication credentials by checking:\n   * 1. Explicit parameters passed to the constructor\n   * 2. Environment variables (`GOOGLE_API_KEY`, `GOOGLE_CLOUD_CREDENTIALS`)\n   * 3. Application Default Credentials (if googleAuthOptions is provided)\n   *\n   * Credentials are normalized and frozen to prevent accidental modification.\n   * The GoogleAuth instance is lazily initialized only when googleAuthOptions\n   * is provided.\n   *\n   * @param params - Configuration parameters for the client. Defaults to an empty object.\n   *\n   * @example\n   * ```typescript\n   * // Minimal configuration (uses environment variables or ADC)\n   * const client = new NodeApiClient();\n   *\n   * // With explicit API key\n   * const client = new WebApiClient({\n   *   apiKey: 'your-api-key'\n   * });\n   *\n   * // With service account credentials as JSON string\n   * const client = new WebApiClient({\n   *   credentials: '{\"type\":\"service_account\",...}'\n   * });\n   *\n   * // With service account credentials as object\n   * const client = new NodeApiClient({\n   *   credentials: {\n   *     type: \"service_account\",\n   *     // ... other fields\n   *   }\n   * });\n   *\n   * // With Google Auth options\n   * const client = new NodeApiClient({\n   *   googleAuthOptions: {\n   *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n   *     projectId: 'my-project'\n   *   }\n   * });\n   * ```\n   */\n  constructor(protected params: NodeApiClientParams = {}) {\n    super();\n\n    this.apiKey = params.apiKey ?? getEnvironmentVariable(\"GOOGLE_API_KEY\");\n    this.credentials = iife(() => {\n      if (params.credentials) {\n        return normalizeGCPCredentials(params.credentials);\n      }\n      const credentialsVar = getEnvironmentVariable(\"GOOGLE_CLOUD_CREDENTIALS\");\n      if (credentialsVar) {\n        return normalizeGCPCredentials(credentialsVar);\n      }\n      return undefined;\n    });\n    this.googleAuth = iife(() => {\n      if (params.googleAuthOptions) {\n        return new GoogleAuth(params.googleAuthOptions);\n      }\n      if (!this.apiKey && !this.credentials) {\n        return new GoogleAuth();\n      }\n      return undefined;\n    });\n  }\n\n  /**\n   * Executes an HTTP request with appropriate Google API authentication.\n   *\n   * This method adds authentication headers to the request based on the\n   * configured authentication method, following this priority:\n   *\n   * 1. If an API key is configured, adds the `X-Goog-Api-Key` header\n   * 2. If service account credentials are configured, generates an access token\n   *    and adds it via the `Authorization` header with Bearer scheme\n   * 3. If Google Auth is configured, uses google-auth-library to generate\n   *    appropriate authentication headers (may include Authorization, x-goog-user-project, etc.)\n   *\n   * The authentication priority ensures that explicit API keys take precedence,\n   * followed by service account credentials, and finally Google Auth options.\n   *\n   * @param request - The HTTP request to execute. Headers will be modified\n   *                  in-place to include authentication information.\n   * @returns A Promise that resolves to the HTTP response\n   *\n   * @throws {AuthError} If service account authentication fails (e.g., invalid\n   *                     credentials, network error, or token generation failure)\n   * @throws {Error} If Google Auth authentication fails (e.g., missing credentials,\n   *                 invalid configuration, or ADC not available)\n   *\n   * @example\n   * ```typescript\n   * const client = new NodeApiClient({ apiKey: 'your-key' });\n   * const request = new Request('https://generativelanguage.googleapis.com/v1/models');\n   * const response = await client.fetch(request);\n   * const data = await response.json();\n   * ```\n   *\n   * @remarks\n   * - The request object is modified in-place by adding headers\n   * - Service account tokens are automatically cached and refreshed\n   * - Google Auth tokens are managed by google-auth-library with automatic refresh\n   * - Only one authentication method is used per request (based on priority)\n   * - Google Auth may add multiple headers depending on the authentication type\n   */\n  async fetch(request: Request): Promise<Response> {\n    if (this.apiKey) {\n      request.headers.set(GOOGLE_API_KEY_HEADER, this.apiKey);\n    } else if (this.credentials) {\n      request.headers.set(\n        GCP_API_KEY_HEADER,\n        `Bearer ${getGCPCredentialsAccessToken(this.credentials)}`\n      );\n    } else if (this.googleAuth) {\n      const authHeaders = await this.googleAuth.getRequestHeaders(request.url);\n      authHeaders.forEach((value, key) => {\n        if (value !== null) {\n          request.headers.set(key, value);\n        }\n      });\n    }\n    return fetch(request);\n  }\n}\n\n/**\n * Ensures that Google Auth options include required OAuth2 scopes.\n *\n * This utility function validates and augments GoogleAuthOptions to ensure\n * that all required OAuth2 scopes are present. It handles three scenarios:\n *\n * 1. **No auth options provided**: Creates new options with required scopes\n * 2. **Auth options without scopes**: Adds required scopes to existing options\n * 3. **Auth options with scopes**: Validates that all required scopes are present\n *\n * This is particularly useful when working with Google APIs that require specific\n * scopes for access, ensuring that authentication is properly configured before\n * making API requests.\n *\n * @param authOptions - The existing Google Auth options to validate/augment.\n *                      Can be undefined or an empty object.\n * @param requiredScopes - Array of OAuth2 scope URLs that must be present.\n *                         These are typically Google API scope URLs like\n *                         'https://www.googleapis.com/auth/cloud-platform'\n * @returns The validated/augmented GoogleAuthOptions with all required scopes\n *\n * @throws {Error} If authOptions already has scopes but is missing any of the\n *                 required scopes. This prevents accidental scope reduction that\n *                 could break API access.\n *\n * @example\n * ```typescript\n * // Create new options with required scopes\n * const options = ensureAuthScopes(undefined, [\n *   'https://www.googleapis.com/auth/cloud-platform'\n * ]);\n * // Result: { scopes: ['https://www.googleapis.com/auth/cloud-platform'] }\n *\n * // Add scopes to existing options\n * const options = ensureAuthScopes(\n *   { projectId: 'my-project' },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: { projectId: 'my-project', scopes: [...] }\n *\n * // Validate existing scopes\n * const options = ensureAuthScopes(\n *   { scopes: ['https://www.googleapis.com/auth/cloud-platform'] },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: Original options (validation passed)\n *\n * // Error case - missing required scope\n * try {\n *   ensureAuthScopes(\n *     { scopes: ['https://www.googleapis.com/auth/userinfo.email'] },\n *     ['https://www.googleapis.com/auth/cloud-platform']\n *   );\n * } catch (error) {\n *   // Error: Invalid auth scopes. Scopes must include ...\n * }\n * ```\n *\n * @remarks\n * - Scopes can be provided as a string or array of strings in GoogleAuthOptions\n * - The function normalizes single-string scopes to arrays for validation\n * - Required scopes are not automatically added if existing scopes are present;\n *   instead, an error is thrown to prevent unintended scope changes\n * - This function does not modify the original authOptions object\n *\n * @see https://developers.google.com/identity/protocols/oauth2/scopes\n * @see {@link GoogleAuthOptions} for the full authentication configuration interface\n */\nexport function ensureAuthScopes(\n  authOptions: GoogleAuthOptions,\n  requiredScopes: string[]\n): GoogleAuthOptions {\n  if (!authOptions) {\n    return { scopes: requiredScopes };\n  } else if (!authOptions.scopes) {\n    return { ...authOptions, scopes: requiredScopes };\n  } else {\n    const existingScopes = Array.isArray(authOptions.scopes)\n      ? authOptions.scopes\n      : [authOptions.scopes];\n    const missingScopes = requiredScopes.filter(\n      (scope) => !existingScopes.includes(scope)\n    );\n    if (missingScopes.length > 0) {\n      throw new ConfigurationError(\n        `Invalid auth scopes. Scopes must include ${requiredScopes.join(\", \")}`\n      );\n    }\n  }\n  return authOptions;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkJA,IAAa,gBAAb,cAAmCA,wBAAU;CAC3C,YAAqB;AACnB,SAAO,OAAO,KAAK,WAAW,YAAY,KAAK,WAAW;;CAG5D,MAAM,eAAgC;AACpC,MAAI,OAAO,KAAK,gBAAgB,YAC9B,QAAO,KAAK,YAAY;WACf,OAAO,KAAK,eAAe,YACpC,QAAO,KAAK,WAAW,cAAc;MAErC,QAAO,MAAM,cAAc;;;;;;;;;;CAY/B,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDV,YAAY,AAAU,SAA8B,EAAE,EAAE;AACtD,SAAO;EADa;AAGpB,OAAK,SAAS,OAAO,gEAAiC,iBAAiB;AACvE,OAAK,cAAcC,wBAAW;AAC5B,OAAI,OAAO,YACT,QAAOC,yCAAwB,OAAO,YAAY;GAEpD,MAAM,uEAAwC,2BAA2B;AACzE,OAAI,eACF,QAAOA,yCAAwB,eAAe;IAGhD;AACF,OAAK,aAAaD,wBAAW;AAC3B,OAAI,OAAO,kBACT,QAAO,IAAIE,+BAAW,OAAO,kBAAkB;AAEjD,OAAI,CAAC,KAAK,UAAU,CAAC,KAAK,YACxB,QAAO,IAAIA,gCAAY;IAGzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CJ,MAAM,MAAM,SAAqC;AAC/C,MAAI,KAAK,OACP,SAAQ,QAAQ,IAAIC,qCAAuB,KAAK,OAAO;WAC9C,KAAK,YACd,SAAQ,QAAQ,IACdC,kCACA,UAAUC,8CAA6B,KAAK,YAAY,GACzD;WACQ,KAAK,WAEd,EADoB,MAAM,KAAK,WAAW,kBAAkB,QAAQ,IAAI,EAC5D,SAAS,OAAO,QAAQ;AAClC,OAAI,UAAU,KACZ,SAAQ,QAAQ,IAAI,KAAK,MAAM;IAEjC;AAEJ,SAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEzB,SAAgB,iBACd,aACA,gBACmB;AACnB,KAAI,CAAC,YACH,QAAO,EAAE,QAAQ,gBAAgB;UACxB,CAAC,YAAY,OACtB,QAAO;EAAE,GAAG;EAAa,QAAQ;EAAgB;MAC5C;EACL,MAAM,iBAAiB,MAAM,QAAQ,YAAY,OAAO,GACpD,YAAY,SACZ,CAAC,YAAY,OAAO;AAIxB,MAHsB,eAAe,QAClC,UAAU,CAAC,eAAe,SAAS,MAAM,CAC3C,CACiB,SAAS,EACzB,OAAM,IAAIC,kCACR,4CAA4C,eAAe,KAAK,KAAK,GACtE;;AAGL,QAAO"}

package/dist/clients/node.d.cts

@@ -2,7 +2,6 @@ import { GCPCredentials } from "../utils/gcp-auth.cjs";
 import { GoogleAuthOptions } from "google-auth-library";
 
 //#region src/clients/node.d.ts
-
 /**
  * Configuration parameters for the NodeApiClient.
  *

package/dist/clients/node.d.ts

@@ -2,7 +2,6 @@ import { GCPCredentials } from "../utils/gcp-auth.js";
 import { GoogleAuth, GoogleAuthOptions } from "google-auth-library";
 
 //#region src/clients/node.d.ts
-
 /**
  * Configuration parameters for the NodeApiClient.
  *

package/dist/clients/node.js

@@ -179,12 +179,10 @@ var NodeApiClient = class extends ApiClient {
 			if (params.credentials) return normalizeGCPCredentials(params.credentials);
 			const credentialsVar = getEnvironmentVariable("GOOGLE_CLOUD_CREDENTIALS");
 			if (credentialsVar) return normalizeGCPCredentials(credentialsVar);
-			return void 0;
 		});
 		this.googleAuth = iife(() => {
 			if (params.googleAuthOptions) return new GoogleAuth(params.googleAuthOptions);
 			if (!this.apiKey && !this.credentials) return new GoogleAuth();
-			return void 0;
 		});
 	}
 	/**
@@ -229,12 +227,9 @@ var NodeApiClient = class extends ApiClient {
 	async fetch(request) {
 		if (this.apiKey) request.headers.set(GOOGLE_API_KEY_HEADER, this.apiKey);
 		else if (this.credentials) request.headers.set(GCP_API_KEY_HEADER, `Bearer ${getGCPCredentialsAccessToken(this.credentials)}`);
-		else if (this.googleAuth) {
-			const authHeaders = await this.googleAuth.getRequestHeaders(request.url);
-			authHeaders.forEach((value, key) => {
-				if (value !== null) request.headers.set(key, value);
-			});
-		}
+		else if (this.googleAuth) (await this.googleAuth.getRequestHeaders(request.url)).forEach((value, key) => {
+			if (value !== null) request.headers.set(key, value);
+		});
 		return fetch(request);
 	}
 };
@@ -314,8 +309,7 @@ function ensureAuthScopes(authOptions, requiredScopes) {
 	};
 	else {
 		const existingScopes = Array.isArray(authOptions.scopes) ? authOptions.scopes : [authOptions.scopes];
-		const missingScopes = requiredScopes.filter((scope) => !existingScopes.includes(scope));
-		if (missingScopes.length > 0) throw new ConfigurationError(`Invalid auth scopes. Scopes must include ${requiredScopes.join(", ")}`);
+		if (requiredScopes.filter((scope) => !existingScopes.includes(scope)).length > 0) throw new ConfigurationError(`Invalid auth scopes. Scopes must include ${requiredScopes.join(", ")}`);
 	}
 	return authOptions;
 }

package/dist/clients/node.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.js","names":["params: NodeApiClientParams","request: Request","authOptions: GoogleAuthOptions","requiredScopes: string[]"],"sources":["../../src/clients/node.ts"],"sourcesContent":["import { GoogleAuth, type GoogleAuthOptions } from \"google-auth-library\";\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { GCP_API_KEY_HEADER, GOOGLE_API_KEY_HEADER } from \"../const.js\";\nimport { ApiClient } from \"./index.js\";\nimport {\n  GCPCredentials,\n  getGCPCredentialsAccessToken,\n  normalizeGCPCredentials,\n} from \"../utils/gcp-auth.js\";\nimport { ConfigurationError } from \"../utils/errors.js\";\nimport { iife } from \"../utils/misc.js\";\n\n/**\n * Configuration parameters for the NodeApiClient.\n *\n * This interface defines the authentication options available for Node.js-based\n * API clients. Authentication can be provided via an API key, GCP service\n * account credentials, or advanced Google Auth options. The client will\n * automatically check environment variables if explicit values are not provided.\n *\n * @interface\n */\nexport interface NodeApiClientParams {\n  /**\n   * Google API key for authentication.\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @see https://cloud.google.com/docs/authentication/api-keys\n   */\n  apiKey?: string;\n\n  /**\n   * GCP service account credentials for authentication.\n   *\n   * Can be provided as either:\n   * - A JSON string containing the service account key\n   * - A GCPCredentials object\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable.\n   *\n   * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys\n   */\n  credentials?: string | GCPCredentials;\n\n  /**\n   * Google Auth options configuration.\n   *\n   * Provides fine-grained control over authentication behavior using the\n   * google-auth-library. This option enables:\n   * - Custom OAuth2 scopes\n   * - Application Default Credentials (ADC)\n   * - Impersonation and delegation\n   * - Custom credential sources\n   *\n   * When provided, this takes precedence over simple credential-based auth\n   * but is lower priority than API key authentication.\n   *\n   * @see https://github.com/googleapis/google-auth-library-nodejs\n   * @see https://cloud.google.com/docs/authentication/application-default-credentials\n   */\n  googleAuthOptions?: GoogleAuthOptions;\n}\n\n/**\n * Node.js-specific API client for Google services.\n *\n * This client provides comprehensive authentication for Google API requests in\n * Node.js environments, leveraging the full capabilities of the google-auth-library.\n * It supports three authentication methods with the following priority:\n *\n * 1. **API Key Authentication**: Simple key-based authentication suitable for\n *    public APIs and development environments.\n *\n * 2. **Service Account Credentials**: OAuth2-based authentication using GCP\n *    service account keys. The client automatically handles token generation\n *    and caching using a web-compatible implementation.\n *\n * 3. **Google Auth Library**: Advanced authentication using google-auth-library,\n *    supporting Application Default Credentials (ADC), custom scopes, and\n *    various credential sources.\n *\n * The client follows this authentication priority:\n * 1. Explicit `apiKey` parameter\n * 2. `GOOGLE_API_KEY` environment variable\n * 3. Explicit `credentials` parameter\n * 4. `GOOGLE_CLOUD_CREDENTIALS` environment variable\n * 5. `googleAuthOptions` parameter\n * 6. Application Default Credentials (if googleAuthOptions is provided without explicit credentials)\n *\n * @extends ApiClient\n *\n * @example\n * ```typescript\n * // Using API key\n * const client = new NodeApiClient({\n *   apiKey: 'your-api-key'\n * });\n *\n * // Using service account credentials\n * const client = new NodeApiClient({\n *   credentials: {\n *     type: \"service_account\",\n *     project_id: \"my-project\",\n *     private_key_id: \"key-id\",\n *     private_key: \"-----BEGIN PRIVATE KEY-----\\n...\",\n *     client_email: \"service-account@project.iam.gserviceaccount.com\",\n *     // ... other required fields\n *   }\n * });\n *\n * // Using Google Auth with custom scopes\n * const client = new NodeApiClient({\n *   googleAuthOptions: {\n *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n *     keyFilename: '/path/to/service-account-key.json'\n *   }\n * });\n *\n * // Using Application Default Credentials\n * const client = new NodeApiClient({\n *   googleAuthOptions: {}\n * });\n *\n * // Using environment variables\n * // Set GOOGLE_API_KEY or GOOGLE_CLOUD_CREDENTIALS\n * const client = new NodeApiClient();\n *\n * // Make authenticated requests\n * const request = new Request('https://api.google.com/...');\n * const response = await client.fetch(request);\n * ```\n *\n * @remarks\n * - API keys are added via the `X-Goog-Api-Key` header\n * - Service account tokens are added via the `Authorization` header with Bearer scheme\n * - Google Auth headers are automatically generated and added by google-auth-library\n * - Tokens are automatically cached and refreshed as needed\n * - For web/edge environments without google-auth-library, use WebApiClient instead\n *\n * @see {@link WebApiClient} for web-compatible authentication without google-auth-library\n * @see {@link GCPCredentials} for service account credential structure\n * @see {@link GoogleAuthOptions} for advanced authentication configuration\n */\nexport class NodeApiClient extends ApiClient {\n  hasApiKey(): boolean {\n    return typeof this.apiKey === \"string\" && this.apiKey !== \"\";\n  }\n\n  async getProjectId(): Promise<string> {\n    if (typeof this.credentials !== \"undefined\") {\n      return this.credentials.project_id;\n    } else if (typeof this.googleAuth !== \"undefined\") {\n      return this.googleAuth.getProjectId();\n    } else {\n      return super.getProjectId();\n    }\n  }\n\n  /**\n   * The Google API key used for authentication, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @protected\n   */\n  protected apiKey?: string;\n\n  /**\n   * The normalized GCP service account credentials, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable, and is normalized\n   * to ensure immutability.\n   *\n   * @protected\n   */\n  protected credentials?: GCPCredentials;\n\n  /**\n   * The Google Auth instance for advanced authentication, if configured.\n   *\n   * This instance is created when `googleAuthOptions` is provided and\n   * handles Application Default Credentials, custom scopes, and other\n   * advanced authentication scenarios.\n   *\n   * @protected\n   */\n  protected googleAuth?: GoogleAuth;\n\n  /**\n   * Creates a new NodeApiClient instance.\n   *\n   * The constructor initializes authentication credentials by checking:\n   * 1. Explicit parameters passed to the constructor\n   * 2. Environment variables (`GOOGLE_API_KEY`, `GOOGLE_CLOUD_CREDENTIALS`)\n   * 3. Application Default Credentials (if googleAuthOptions is provided)\n   *\n   * Credentials are normalized and frozen to prevent accidental modification.\n   * The GoogleAuth instance is lazily initialized only when googleAuthOptions\n   * is provided.\n   *\n   * @param params - Configuration parameters for the client. Defaults to an empty object.\n   *\n   * @example\n   * ```typescript\n   * // Minimal configuration (uses environment variables or ADC)\n   * const client = new NodeApiClient();\n   *\n   * // With explicit API key\n   * const client = new WebApiClient({\n   *   apiKey: 'your-api-key'\n   * });\n   *\n   * // With service account credentials as JSON string\n   * const client = new WebApiClient({\n   *   credentials: '{\"type\":\"service_account\",...}'\n   * });\n   *\n   * // With service account credentials as object\n   * const client = new NodeApiClient({\n   *   credentials: {\n   *     type: \"service_account\",\n   *     // ... other fields\n   *   }\n   * });\n   *\n   * // With Google Auth options\n   * const client = new NodeApiClient({\n   *   googleAuthOptions: {\n   *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n   *     projectId: 'my-project'\n   *   }\n   * });\n   * ```\n   */\n  constructor(protected params: NodeApiClientParams = {}) {\n    super();\n\n    this.apiKey = params.apiKey ?? getEnvironmentVariable(\"GOOGLE_API_KEY\");\n    this.credentials = iife(() => {\n      if (params.credentials) {\n        return normalizeGCPCredentials(params.credentials);\n      }\n      const credentialsVar = getEnvironmentVariable(\"GOOGLE_CLOUD_CREDENTIALS\");\n      if (credentialsVar) {\n        return normalizeGCPCredentials(credentialsVar);\n      }\n      return undefined;\n    });\n    this.googleAuth = iife(() => {\n      if (params.googleAuthOptions) {\n        return new GoogleAuth(params.googleAuthOptions);\n      }\n      if (!this.apiKey && !this.credentials) {\n        return new GoogleAuth();\n      }\n      return undefined;\n    });\n  }\n\n  /**\n   * Executes an HTTP request with appropriate Google API authentication.\n   *\n   * This method adds authentication headers to the request based on the\n   * configured authentication method, following this priority:\n   *\n   * 1. If an API key is configured, adds the `X-Goog-Api-Key` header\n   * 2. If service account credentials are configured, generates an access token\n   *    and adds it via the `Authorization` header with Bearer scheme\n   * 3. If Google Auth is configured, uses google-auth-library to generate\n   *    appropriate authentication headers (may include Authorization, x-goog-user-project, etc.)\n   *\n   * The authentication priority ensures that explicit API keys take precedence,\n   * followed by service account credentials, and finally Google Auth options.\n   *\n   * @param request - The HTTP request to execute. Headers will be modified\n   *                  in-place to include authentication information.\n   * @returns A Promise that resolves to the HTTP response\n   *\n   * @throws {AuthError} If service account authentication fails (e.g., invalid\n   *                     credentials, network error, or token generation failure)\n   * @throws {Error} If Google Auth authentication fails (e.g., missing credentials,\n   *                 invalid configuration, or ADC not available)\n   *\n   * @example\n   * ```typescript\n   * const client = new NodeApiClient({ apiKey: 'your-key' });\n   * const request = new Request('https://generativelanguage.googleapis.com/v1/models');\n   * const response = await client.fetch(request);\n   * const data = await response.json();\n   * ```\n   *\n   * @remarks\n   * - The request object is modified in-place by adding headers\n   * - Service account tokens are automatically cached and refreshed\n   * - Google Auth tokens are managed by google-auth-library with automatic refresh\n   * - Only one authentication method is used per request (based on priority)\n   * - Google Auth may add multiple headers depending on the authentication type\n   */\n  async fetch(request: Request): Promise<Response> {\n    if (this.apiKey) {\n      request.headers.set(GOOGLE_API_KEY_HEADER, this.apiKey);\n    } else if (this.credentials) {\n      request.headers.set(\n        GCP_API_KEY_HEADER,\n        `Bearer ${getGCPCredentialsAccessToken(this.credentials)}`\n      );\n    } else if (this.googleAuth) {\n      const authHeaders = await this.googleAuth.getRequestHeaders(request.url);\n      authHeaders.forEach((value, key) => {\n        if (value !== null) {\n          request.headers.set(key, value);\n        }\n      });\n    }\n    return fetch(request);\n  }\n}\n\n/**\n * Ensures that Google Auth options include required OAuth2 scopes.\n *\n * This utility function validates and augments GoogleAuthOptions to ensure\n * that all required OAuth2 scopes are present. It handles three scenarios:\n *\n * 1. **No auth options provided**: Creates new options with required scopes\n * 2. **Auth options without scopes**: Adds required scopes to existing options\n * 3. **Auth options with scopes**: Validates that all required scopes are present\n *\n * This is particularly useful when working with Google APIs that require specific\n * scopes for access, ensuring that authentication is properly configured before\n * making API requests.\n *\n * @param authOptions - The existing Google Auth options to validate/augment.\n *                      Can be undefined or an empty object.\n * @param requiredScopes - Array of OAuth2 scope URLs that must be present.\n *                         These are typically Google API scope URLs like\n *                         'https://www.googleapis.com/auth/cloud-platform'\n * @returns The validated/augmented GoogleAuthOptions with all required scopes\n *\n * @throws {Error} If authOptions already has scopes but is missing any of the\n *                 required scopes. This prevents accidental scope reduction that\n *                 could break API access.\n *\n * @example\n * ```typescript\n * // Create new options with required scopes\n * const options = ensureAuthScopes(undefined, [\n *   'https://www.googleapis.com/auth/cloud-platform'\n * ]);\n * // Result: { scopes: ['https://www.googleapis.com/auth/cloud-platform'] }\n *\n * // Add scopes to existing options\n * const options = ensureAuthScopes(\n *   { projectId: 'my-project' },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: { projectId: 'my-project', scopes: [...] }\n *\n * // Validate existing scopes\n * const options = ensureAuthScopes(\n *   { scopes: ['https://www.googleapis.com/auth/cloud-platform'] },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: Original options (validation passed)\n *\n * // Error case - missing required scope\n * try {\n *   ensureAuthScopes(\n *     { scopes: ['https://www.googleapis.com/auth/userinfo.email'] },\n *     ['https://www.googleapis.com/auth/cloud-platform']\n *   );\n * } catch (error) {\n *   // Error: Invalid auth scopes. Scopes must include ...\n * }\n * ```\n *\n * @remarks\n * - Scopes can be provided as a string or array of strings in GoogleAuthOptions\n * - The function normalizes single-string scopes to arrays for validation\n * - Required scopes are not automatically added if existing scopes are present;\n *   instead, an error is thrown to prevent unintended scope changes\n * - This function does not modify the original authOptions object\n *\n * @see https://developers.google.com/identity/protocols/oauth2/scopes\n * @see {@link GoogleAuthOptions} for the full authentication configuration interface\n */\nexport function ensureAuthScopes(\n  authOptions: GoogleAuthOptions,\n  requiredScopes: string[]\n): GoogleAuthOptions {\n  if (!authOptions) {\n    return { scopes: requiredScopes };\n  } else if (!authOptions.scopes) {\n    return { ...authOptions, scopes: requiredScopes };\n  } else {\n    const existingScopes = Array.isArray(authOptions.scopes)\n      ? authOptions.scopes\n      : [authOptions.scopes];\n    const missingScopes = requiredScopes.filter(\n      (scope) => !existingScopes.includes(scope)\n    );\n    if (missingScopes.length > 0) {\n      throw new ConfigurationError(\n        `Invalid auth scopes. Scopes must include ${requiredScopes.join(\", \")}`\n      );\n    }\n  }\n  return authOptions;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkJA,IAAa,gBAAb,cAAmC,UAAU;CAC3C,YAAqB;AACnB,SAAO,OAAO,KAAK,WAAW,YAAY,KAAK,WAAW;CAC3D;CAED,MAAM,eAAgC;AACpC,MAAI,OAAO,KAAK,gBAAgB,YAC9B,QAAO,KAAK,YAAY;WACf,OAAO,KAAK,eAAe,YACpC,QAAO,KAAK,WAAW,cAAc;MAErC,QAAO,MAAM,cAAc;CAE9B;;;;;;;;;CAUD,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDV,YAAsBA,SAA8B,CAAE,GAAE;EACtD,OAAO;EADa;EAGpB,KAAK,SAAS,OAAO,UAAU,uBAAuB,iBAAiB;EACvE,KAAK,cAAc,KAAK,MAAM;AAC5B,OAAI,OAAO,YACT,QAAO,wBAAwB,OAAO,YAAY;GAEpD,MAAM,iBAAiB,uBAAuB,2BAA2B;AACzE,OAAI,eACF,QAAO,wBAAwB,eAAe;AAEhD,UAAO;EACR,EAAC;EACF,KAAK,aAAa,KAAK,MAAM;AAC3B,OAAI,OAAO,kBACT,QAAO,IAAI,WAAW,OAAO;AAE/B,OAAI,CAAC,KAAK,UAAU,CAAC,KAAK,YACxB,QAAO,IAAI;AAEb,UAAO;EACR,EAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCD,MAAM,MAAMC,SAAqC;AAC/C,MAAI,KAAK,QACP,QAAQ,QAAQ,IAAI,uBAAuB,KAAK,OAAO;WAC9C,KAAK,aACd,QAAQ,QAAQ,IACd,oBACA,CAAC,OAAO,EAAE,6BAA6B,KAAK,YAAY,EAAE,CAC3D;WACQ,KAAK,YAAY;GAC1B,MAAM,cAAc,MAAM,KAAK,WAAW,kBAAkB,QAAQ,IAAI;GACxE,YAAY,QAAQ,CAAC,OAAO,QAAQ;AAClC,QAAI,UAAU,MACZ,QAAQ,QAAQ,IAAI,KAAK,MAAM;GAElC,EAAC;EACH;AACD,SAAO,MAAM,QAAQ;CACtB;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsED,SAAgB,iBACdC,aACAC,gBACmB;AACnB,KAAI,CAAC,YACH,QAAO,EAAE,QAAQ,eAAgB;UACxB,CAAC,YAAY,OACtB,QAAO;EAAE,GAAG;EAAa,QAAQ;CAAgB;MAC5C;EACL,MAAM,iBAAiB,MAAM,QAAQ,YAAY,OAAO,GACpD,YAAY,SACZ,CAAC,YAAY,MAAO;EACxB,MAAM,gBAAgB,eAAe,OACnC,CAAC,UAAU,CAAC,eAAe,SAAS,MAAM,CAC3C;AACD,MAAI,cAAc,SAAS,EACzB,OAAM,IAAI,mBACR,CAAC,yCAAyC,EAAE,eAAe,KAAK,KAAK,EAAE;CAG5E;AACD,QAAO;AACR"}
+{"version":3,"file":"node.js","names":[],"sources":["../../src/clients/node.ts"],"sourcesContent":["import { GoogleAuth, type GoogleAuthOptions } from \"google-auth-library\";\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { GCP_API_KEY_HEADER, GOOGLE_API_KEY_HEADER } from \"../const.js\";\nimport { ApiClient } from \"./index.js\";\nimport {\n  GCPCredentials,\n  getGCPCredentialsAccessToken,\n  normalizeGCPCredentials,\n} from \"../utils/gcp-auth.js\";\nimport { ConfigurationError } from \"../utils/errors.js\";\nimport { iife } from \"../utils/misc.js\";\n\n/**\n * Configuration parameters for the NodeApiClient.\n *\n * This interface defines the authentication options available for Node.js-based\n * API clients. Authentication can be provided via an API key, GCP service\n * account credentials, or advanced Google Auth options. The client will\n * automatically check environment variables if explicit values are not provided.\n *\n * @interface\n */\nexport interface NodeApiClientParams {\n  /**\n   * Google API key for authentication.\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @see https://cloud.google.com/docs/authentication/api-keys\n   */\n  apiKey?: string;\n\n  /**\n   * GCP service account credentials for authentication.\n   *\n   * Can be provided as either:\n   * - A JSON string containing the service account key\n   * - A GCPCredentials object\n   *\n   * If not provided, the client will attempt to read from the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable.\n   *\n   * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys\n   */\n  credentials?: string | GCPCredentials;\n\n  /**\n   * Google Auth options configuration.\n   *\n   * Provides fine-grained control over authentication behavior using the\n   * google-auth-library. This option enables:\n   * - Custom OAuth2 scopes\n   * - Application Default Credentials (ADC)\n   * - Impersonation and delegation\n   * - Custom credential sources\n   *\n   * When provided, this takes precedence over simple credential-based auth\n   * but is lower priority than API key authentication.\n   *\n   * @see https://github.com/googleapis/google-auth-library-nodejs\n   * @see https://cloud.google.com/docs/authentication/application-default-credentials\n   */\n  googleAuthOptions?: GoogleAuthOptions;\n}\n\n/**\n * Node.js-specific API client for Google services.\n *\n * This client provides comprehensive authentication for Google API requests in\n * Node.js environments, leveraging the full capabilities of the google-auth-library.\n * It supports three authentication methods with the following priority:\n *\n * 1. **API Key Authentication**: Simple key-based authentication suitable for\n *    public APIs and development environments.\n *\n * 2. **Service Account Credentials**: OAuth2-based authentication using GCP\n *    service account keys. The client automatically handles token generation\n *    and caching using a web-compatible implementation.\n *\n * 3. **Google Auth Library**: Advanced authentication using google-auth-library,\n *    supporting Application Default Credentials (ADC), custom scopes, and\n *    various credential sources.\n *\n * The client follows this authentication priority:\n * 1. Explicit `apiKey` parameter\n * 2. `GOOGLE_API_KEY` environment variable\n * 3. Explicit `credentials` parameter\n * 4. `GOOGLE_CLOUD_CREDENTIALS` environment variable\n * 5. `googleAuthOptions` parameter\n * 6. Application Default Credentials (if googleAuthOptions is provided without explicit credentials)\n *\n * @extends ApiClient\n *\n * @example\n * ```typescript\n * // Using API key\n * const client = new NodeApiClient({\n *   apiKey: 'your-api-key'\n * });\n *\n * // Using service account credentials\n * const client = new NodeApiClient({\n *   credentials: {\n *     type: \"service_account\",\n *     project_id: \"my-project\",\n *     private_key_id: \"key-id\",\n *     private_key: \"-----BEGIN PRIVATE KEY-----\\n...\",\n *     client_email: \"service-account@project.iam.gserviceaccount.com\",\n *     // ... other required fields\n *   }\n * });\n *\n * // Using Google Auth with custom scopes\n * const client = new NodeApiClient({\n *   googleAuthOptions: {\n *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n *     keyFilename: '/path/to/service-account-key.json'\n *   }\n * });\n *\n * // Using Application Default Credentials\n * const client = new NodeApiClient({\n *   googleAuthOptions: {}\n * });\n *\n * // Using environment variables\n * // Set GOOGLE_API_KEY or GOOGLE_CLOUD_CREDENTIALS\n * const client = new NodeApiClient();\n *\n * // Make authenticated requests\n * const request = new Request('https://api.google.com/...');\n * const response = await client.fetch(request);\n * ```\n *\n * @remarks\n * - API keys are added via the `X-Goog-Api-Key` header\n * - Service account tokens are added via the `Authorization` header with Bearer scheme\n * - Google Auth headers are automatically generated and added by google-auth-library\n * - Tokens are automatically cached and refreshed as needed\n * - For web/edge environments without google-auth-library, use WebApiClient instead\n *\n * @see {@link WebApiClient} for web-compatible authentication without google-auth-library\n * @see {@link GCPCredentials} for service account credential structure\n * @see {@link GoogleAuthOptions} for advanced authentication configuration\n */\nexport class NodeApiClient extends ApiClient {\n  hasApiKey(): boolean {\n    return typeof this.apiKey === \"string\" && this.apiKey !== \"\";\n  }\n\n  async getProjectId(): Promise<string> {\n    if (typeof this.credentials !== \"undefined\") {\n      return this.credentials.project_id;\n    } else if (typeof this.googleAuth !== \"undefined\") {\n      return this.googleAuth.getProjectId();\n    } else {\n      return super.getProjectId();\n    }\n  }\n\n  /**\n   * The Google API key used for authentication, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_API_KEY` environment variable.\n   *\n   * @protected\n   */\n  protected apiKey?: string;\n\n  /**\n   * The normalized GCP service account credentials, if provided.\n   *\n   * This value is resolved from either the constructor parameter or the\n   * `GOOGLE_CLOUD_CREDENTIALS` environment variable, and is normalized\n   * to ensure immutability.\n   *\n   * @protected\n   */\n  protected credentials?: GCPCredentials;\n\n  /**\n   * The Google Auth instance for advanced authentication, if configured.\n   *\n   * This instance is created when `googleAuthOptions` is provided and\n   * handles Application Default Credentials, custom scopes, and other\n   * advanced authentication scenarios.\n   *\n   * @protected\n   */\n  protected googleAuth?: GoogleAuth;\n\n  /**\n   * Creates a new NodeApiClient instance.\n   *\n   * The constructor initializes authentication credentials by checking:\n   * 1. Explicit parameters passed to the constructor\n   * 2. Environment variables (`GOOGLE_API_KEY`, `GOOGLE_CLOUD_CREDENTIALS`)\n   * 3. Application Default Credentials (if googleAuthOptions is provided)\n   *\n   * Credentials are normalized and frozen to prevent accidental modification.\n   * The GoogleAuth instance is lazily initialized only when googleAuthOptions\n   * is provided.\n   *\n   * @param params - Configuration parameters for the client. Defaults to an empty object.\n   *\n   * @example\n   * ```typescript\n   * // Minimal configuration (uses environment variables or ADC)\n   * const client = new NodeApiClient();\n   *\n   * // With explicit API key\n   * const client = new WebApiClient({\n   *   apiKey: 'your-api-key'\n   * });\n   *\n   * // With service account credentials as JSON string\n   * const client = new WebApiClient({\n   *   credentials: '{\"type\":\"service_account\",...}'\n   * });\n   *\n   * // With service account credentials as object\n   * const client = new NodeApiClient({\n   *   credentials: {\n   *     type: \"service_account\",\n   *     // ... other fields\n   *   }\n   * });\n   *\n   * // With Google Auth options\n   * const client = new NodeApiClient({\n   *   googleAuthOptions: {\n   *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],\n   *     projectId: 'my-project'\n   *   }\n   * });\n   * ```\n   */\n  constructor(protected params: NodeApiClientParams = {}) {\n    super();\n\n    this.apiKey = params.apiKey ?? getEnvironmentVariable(\"GOOGLE_API_KEY\");\n    this.credentials = iife(() => {\n      if (params.credentials) {\n        return normalizeGCPCredentials(params.credentials);\n      }\n      const credentialsVar = getEnvironmentVariable(\"GOOGLE_CLOUD_CREDENTIALS\");\n      if (credentialsVar) {\n        return normalizeGCPCredentials(credentialsVar);\n      }\n      return undefined;\n    });\n    this.googleAuth = iife(() => {\n      if (params.googleAuthOptions) {\n        return new GoogleAuth(params.googleAuthOptions);\n      }\n      if (!this.apiKey && !this.credentials) {\n        return new GoogleAuth();\n      }\n      return undefined;\n    });\n  }\n\n  /**\n   * Executes an HTTP request with appropriate Google API authentication.\n   *\n   * This method adds authentication headers to the request based on the\n   * configured authentication method, following this priority:\n   *\n   * 1. If an API key is configured, adds the `X-Goog-Api-Key` header\n   * 2. If service account credentials are configured, generates an access token\n   *    and adds it via the `Authorization` header with Bearer scheme\n   * 3. If Google Auth is configured, uses google-auth-library to generate\n   *    appropriate authentication headers (may include Authorization, x-goog-user-project, etc.)\n   *\n   * The authentication priority ensures that explicit API keys take precedence,\n   * followed by service account credentials, and finally Google Auth options.\n   *\n   * @param request - The HTTP request to execute. Headers will be modified\n   *                  in-place to include authentication information.\n   * @returns A Promise that resolves to the HTTP response\n   *\n   * @throws {AuthError} If service account authentication fails (e.g., invalid\n   *                     credentials, network error, or token generation failure)\n   * @throws {Error} If Google Auth authentication fails (e.g., missing credentials,\n   *                 invalid configuration, or ADC not available)\n   *\n   * @example\n   * ```typescript\n   * const client = new NodeApiClient({ apiKey: 'your-key' });\n   * const request = new Request('https://generativelanguage.googleapis.com/v1/models');\n   * const response = await client.fetch(request);\n   * const data = await response.json();\n   * ```\n   *\n   * @remarks\n   * - The request object is modified in-place by adding headers\n   * - Service account tokens are automatically cached and refreshed\n   * - Google Auth tokens are managed by google-auth-library with automatic refresh\n   * - Only one authentication method is used per request (based on priority)\n   * - Google Auth may add multiple headers depending on the authentication type\n   */\n  async fetch(request: Request): Promise<Response> {\n    if (this.apiKey) {\n      request.headers.set(GOOGLE_API_KEY_HEADER, this.apiKey);\n    } else if (this.credentials) {\n      request.headers.set(\n        GCP_API_KEY_HEADER,\n        `Bearer ${getGCPCredentialsAccessToken(this.credentials)}`\n      );\n    } else if (this.googleAuth) {\n      const authHeaders = await this.googleAuth.getRequestHeaders(request.url);\n      authHeaders.forEach((value, key) => {\n        if (value !== null) {\n          request.headers.set(key, value);\n        }\n      });\n    }\n    return fetch(request);\n  }\n}\n\n/**\n * Ensures that Google Auth options include required OAuth2 scopes.\n *\n * This utility function validates and augments GoogleAuthOptions to ensure\n * that all required OAuth2 scopes are present. It handles three scenarios:\n *\n * 1. **No auth options provided**: Creates new options with required scopes\n * 2. **Auth options without scopes**: Adds required scopes to existing options\n * 3. **Auth options with scopes**: Validates that all required scopes are present\n *\n * This is particularly useful when working with Google APIs that require specific\n * scopes for access, ensuring that authentication is properly configured before\n * making API requests.\n *\n * @param authOptions - The existing Google Auth options to validate/augment.\n *                      Can be undefined or an empty object.\n * @param requiredScopes - Array of OAuth2 scope URLs that must be present.\n *                         These are typically Google API scope URLs like\n *                         'https://www.googleapis.com/auth/cloud-platform'\n * @returns The validated/augmented GoogleAuthOptions with all required scopes\n *\n * @throws {Error} If authOptions already has scopes but is missing any of the\n *                 required scopes. This prevents accidental scope reduction that\n *                 could break API access.\n *\n * @example\n * ```typescript\n * // Create new options with required scopes\n * const options = ensureAuthScopes(undefined, [\n *   'https://www.googleapis.com/auth/cloud-platform'\n * ]);\n * // Result: { scopes: ['https://www.googleapis.com/auth/cloud-platform'] }\n *\n * // Add scopes to existing options\n * const options = ensureAuthScopes(\n *   { projectId: 'my-project' },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: { projectId: 'my-project', scopes: [...] }\n *\n * // Validate existing scopes\n * const options = ensureAuthScopes(\n *   { scopes: ['https://www.googleapis.com/auth/cloud-platform'] },\n *   ['https://www.googleapis.com/auth/cloud-platform']\n * );\n * // Result: Original options (validation passed)\n *\n * // Error case - missing required scope\n * try {\n *   ensureAuthScopes(\n *     { scopes: ['https://www.googleapis.com/auth/userinfo.email'] },\n *     ['https://www.googleapis.com/auth/cloud-platform']\n *   );\n * } catch (error) {\n *   // Error: Invalid auth scopes. Scopes must include ...\n * }\n * ```\n *\n * @remarks\n * - Scopes can be provided as a string or array of strings in GoogleAuthOptions\n * - The function normalizes single-string scopes to arrays for validation\n * - Required scopes are not automatically added if existing scopes are present;\n *   instead, an error is thrown to prevent unintended scope changes\n * - This function does not modify the original authOptions object\n *\n * @see https://developers.google.com/identity/protocols/oauth2/scopes\n * @see {@link GoogleAuthOptions} for the full authentication configuration interface\n */\nexport function ensureAuthScopes(\n  authOptions: GoogleAuthOptions,\n  requiredScopes: string[]\n): GoogleAuthOptions {\n  if (!authOptions) {\n    return { scopes: requiredScopes };\n  } else if (!authOptions.scopes) {\n    return { ...authOptions, scopes: requiredScopes };\n  } else {\n    const existingScopes = Array.isArray(authOptions.scopes)\n      ? authOptions.scopes\n      : [authOptions.scopes];\n    const missingScopes = requiredScopes.filter(\n      (scope) => !existingScopes.includes(scope)\n    );\n    if (missingScopes.length > 0) {\n      throw new ConfigurationError(\n        `Invalid auth scopes. Scopes must include ${requiredScopes.join(\", \")}`\n      );\n    }\n  }\n  return authOptions;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkJA,IAAa,gBAAb,cAAmC,UAAU;CAC3C,YAAqB;AACnB,SAAO,OAAO,KAAK,WAAW,YAAY,KAAK,WAAW;;CAG5D,MAAM,eAAgC;AACpC,MAAI,OAAO,KAAK,gBAAgB,YAC9B,QAAO,KAAK,YAAY;WACf,OAAO,KAAK,eAAe,YACpC,QAAO,KAAK,WAAW,cAAc;MAErC,QAAO,MAAM,cAAc;;;;;;;;;;CAY/B,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;CAWV,AAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDV,YAAY,AAAU,SAA8B,EAAE,EAAE;AACtD,SAAO;EADa;AAGpB,OAAK,SAAS,OAAO,UAAU,uBAAuB,iBAAiB;AACvE,OAAK,cAAc,WAAW;AAC5B,OAAI,OAAO,YACT,QAAO,wBAAwB,OAAO,YAAY;GAEpD,MAAM,iBAAiB,uBAAuB,2BAA2B;AACzE,OAAI,eACF,QAAO,wBAAwB,eAAe;IAGhD;AACF,OAAK,aAAa,WAAW;AAC3B,OAAI,OAAO,kBACT,QAAO,IAAI,WAAW,OAAO,kBAAkB;AAEjD,OAAI,CAAC,KAAK,UAAU,CAAC,KAAK,YACxB,QAAO,IAAI,YAAY;IAGzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CJ,MAAM,MAAM,SAAqC;AAC/C,MAAI,KAAK,OACP,SAAQ,QAAQ,IAAI,uBAAuB,KAAK,OAAO;WAC9C,KAAK,YACd,SAAQ,QAAQ,IACd,oBACA,UAAU,6BAA6B,KAAK,YAAY,GACzD;WACQ,KAAK,WAEd,EADoB,MAAM,KAAK,WAAW,kBAAkB,QAAQ,IAAI,EAC5D,SAAS,OAAO,QAAQ;AAClC,OAAI,UAAU,KACZ,SAAQ,QAAQ,IAAI,KAAK,MAAM;IAEjC;AAEJ,SAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEzB,SAAgB,iBACd,aACA,gBACmB;AACnB,KAAI,CAAC,YACH,QAAO,EAAE,QAAQ,gBAAgB;UACxB,CAAC,YAAY,OACtB,QAAO;EAAE,GAAG;EAAa,QAAQ;EAAgB;MAC5C;EACL,MAAM,iBAAiB,MAAM,QAAQ,YAAY,OAAO,GACpD,YAAY,SACZ,CAAC,YAAY,OAAO;AAIxB,MAHsB,eAAe,QAClC,UAAU,CAAC,eAAe,SAAS,MAAM,CAC3C,CACiB,SAAS,EACzB,OAAM,IAAI,mBACR,4CAA4C,eAAe,KAAK,KAAK,GACtE;;AAGL,QAAO"}

package/dist/const.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"const.cjs","names":[],"sources":["../src/const.ts"],"sourcesContent":["export const GOOGLE_API_KEY_HEADER = \"x-goog-api-key\";\n\nexport const GCP_API_KEY_HEADER = \"Authorization\";\n\nexport const GENERATIVE_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/generative-language\",\n];\n\nexport const VERTEX_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/cloud-platform\",\n];\n"],"mappings":";;AAAA,MAAa,wBAAwB;AAErC,MAAa,qBAAqB;AAElC,MAAa,4BAA4B,CACvC,qDACD;AAED,MAAa,wBAAwB,CACnC,gDACD"}
+{"version":3,"file":"const.cjs","names":[],"sources":["../src/const.ts"],"sourcesContent":["export const GOOGLE_API_KEY_HEADER = \"x-goog-api-key\";\n\nexport const GCP_API_KEY_HEADER = \"Authorization\";\n\nexport const GENERATIVE_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/generative-language\",\n];\n\nexport const VERTEX_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/cloud-platform\",\n];\n"],"mappings":";;AAAA,MAAa,wBAAwB;AAErC,MAAa,qBAAqB;AAElC,MAAa,4BAA4B,CACvC,sDACD;AAED,MAAa,wBAAwB,CACnC,iDACD"}

package/dist/const.js.map

@@ -1 +1 @@
-{"version":3,"file":"const.js","names":[],"sources":["../src/const.ts"],"sourcesContent":["export const GOOGLE_API_KEY_HEADER = \"x-goog-api-key\";\n\nexport const GCP_API_KEY_HEADER = \"Authorization\";\n\nexport const GENERATIVE_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/generative-language\",\n];\n\nexport const VERTEX_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/cloud-platform\",\n];\n"],"mappings":";AAAA,MAAa,wBAAwB;AAErC,MAAa,qBAAqB;AAElC,MAAa,4BAA4B,CACvC,qDACD;AAED,MAAa,wBAAwB,CACnC,gDACD"}
+{"version":3,"file":"const.js","names":[],"sources":["../src/const.ts"],"sourcesContent":["export const GOOGLE_API_KEY_HEADER = \"x-goog-api-key\";\n\nexport const GCP_API_KEY_HEADER = \"Authorization\";\n\nexport const GENERATIVE_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/generative-language\",\n];\n\nexport const VERTEX_AI_AUTH_SCOPES = [\n  \"https://www.googleapis.com/auth/cloud-platform\",\n];\n"],"mappings":";AAAA,MAAa,wBAAwB;AAErC,MAAa,qBAAqB;AAElC,MAAa,4BAA4B,CACvC,sDACD;AAED,MAAa,wBAAwB,CACnC,iDACD"}

package/dist/converters/messages.cjs

@@ -1,7 +1,6 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_misc = require('../utils/misc.cjs');
 const require_errors = require('../utils/errors.cjs');
-const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+let _langchain_core_messages = require("@langchain/core/messages");
 
 //#region src/converters/messages.ts
 /**
@@ -17,7 +16,7 @@ const geminiContentBlockConverter = {
 		return { text: block.text };
 	},
 	fromStandardImageBlock(block) {
-		if ((0, __langchain_core_messages.isDataContentBlock)(block)) {
+		if ((0, _langchain_core_messages.isDataContentBlock)(block)) {
 			if (block.source_type === "base64") {
 				if (!block.mime_type) throw new require_errors.InvalidInputError("mime_type is required for base64 image blocks");
 				const dataStr = typeof block.data === "string" ? block.data : typeof block.data === "object" && block.data !== null ? btoa(Array.from(block.data).map((byte) => String.fromCharCode(byte)).join("")) : String(block.data);
@@ -27,7 +26,7 @@ const geminiContentBlockConverter = {
 				} };
 			}
 			if (block.source_type === "url") {
-				const parsed = (0, __langchain_core_messages.parseBase64DataUrl)({ dataUrl: block.url });
+				const parsed = (0, _langchain_core_messages.parseBase64DataUrl)({ dataUrl: block.url });
 				if (parsed) {
 					const dataStr = typeof parsed.data === "string" ? parsed.data : btoa(Array.from(parsed.data).map((byte) => String.fromCharCode(byte)).join(""));
 					return { inlineData: {
@@ -48,7 +47,7 @@ const geminiContentBlockConverter = {
 		throw new require_errors.InvalidInputError(`Image content blocks with source_type "${block.source_type}" are not supported for ChatGoogle. Supported source types are: "base64", "url", "id".`);
 	},
 	fromStandardAudioBlock(block) {
-		if ((0, __langchain_core_messages.isDataContentBlock)(block)) {
+		if ((0, _langchain_core_messages.isDataContentBlock)(block)) {
 			if (block.source_type === "base64") {
 				if (!block.mime_type) throw new require_errors.InvalidInputError("mime_type is required for base64 audio blocks");
 				const dataStr = typeof block.data === "string" ? block.data : typeof block.data === "object" && block.data !== null ? btoa(Array.from(block.data).map((byte) => String.fromCharCode(byte)).join("")) : String(block.data);
@@ -58,7 +57,7 @@ const geminiContentBlockConverter = {
 				} };
 			}
 			if (block.source_type === "url") {
-				const parsed = (0, __langchain_core_messages.parseBase64DataUrl)({ dataUrl: block.url });
+				const parsed = (0, _langchain_core_messages.parseBase64DataUrl)({ dataUrl: block.url });
 				if (parsed) {
 					const dataStr = typeof parsed.data === "string" ? parsed.data : btoa(Array.from(parsed.data).map((byte) => String.fromCharCode(byte)).join(""));
 					return { inlineData: {
@@ -79,7 +78,7 @@ const geminiContentBlockConverter = {
 		throw new require_errors.InvalidInputError(`Audio content blocks with source_type "${block.source_type}" are not supported for ChatGoogle. Supported source types are: "base64", "url", "id".`);
 	},
 	fromStandardFileBlock(block) {
-		if ((0, __langchain_core_messages.isDataContentBlock)(block)) {
+		if ((0, _langchain_core_messages.isDataContentBlock)(block)) {
 			if (block.source_type === "base64") {
 				if (!block.mime_type) throw new require_errors.InvalidInputError("mime_type is required for base64 file blocks");
 				const dataStr = typeof block.data === "string" ? block.data : typeof block.data === "object" && block.data !== null ? btoa(Array.from(block.data).map((byte) => String.fromCharCode(byte)).join("")) : String(block.data);
@@ -89,7 +88,7 @@ const geminiContentBlockConverter = {
 				} };
 			}
 			if (block.source_type === "url") {
-				const parsed = (0, __langchain_core_messages.parseBase64DataUrl)({ dataUrl: block.url });
+				const parsed = (0, _langchain_core_messages.parseBase64DataUrl)({ dataUrl: block.url });
 				if (parsed) {
 					const dataStr = typeof parsed.data === "string" ? parsed.data : btoa(Array.from(parsed.data).map((byte) => String.fromCharCode(byte)).join(""));
 					return { inlineData: {
@@ -125,21 +124,15 @@ function convertStandardDataContentBlockToGeminiPart(block) {
 			data: null
 		};
 	}
-	if ("mimeType" in block && "data" in block) {
-		const mimeType = block.mimeType;
-		const data = typeof block.data === "string" ? block.data : uint8arrayToString(block.data);
-		return { inlineData: {
-			mimeType,
-			data
-		} };
-	} else if ("mimeType" in block && "url" in block) {
-		const mimeType = block.mimeType;
-		const fileUri = block.url;
-		return { fileData: {
-			mimeType,
-			fileUri
-		} };
-	} else if ("url" in block && block.url?.startsWith("data:")) {
+	if ("mimeType" in block && "data" in block) return { inlineData: {
+		mimeType: block.mimeType,
+		data: typeof block.data === "string" ? block.data : uint8arrayToString(block.data)
+	} };
+	else if ("mimeType" in block && "url" in block) return { fileData: {
+		mimeType: block.mimeType,
+		fileUri: block.url
+	} };
+	else if ("url" in block && block.url?.startsWith("data:")) {
 		const { mimeType, data } = extractMimeType(block.url);
 		if (mimeType && data) return { inlineData: {
 			mimeType,
@@ -175,12 +168,12 @@ function convertStandardContentBlockToGeminiPart(block) {
 * This is intended to be called from `convertMessagesToGeminiContent`
 */
 function convertStandardContentMessageToGeminiContent(message) {
-	if (__langchain_core_messages.SystemMessage.isInstance(message)) return null;
+	if (_langchain_core_messages.SystemMessage.isInstance(message)) return null;
 	let role;
-	if (__langchain_core_messages.HumanMessage.isInstance(message)) role = "user";
-	else if (__langchain_core_messages.AIMessage.isInstance(message)) role = "model";
-	else if (__langchain_core_messages.ToolMessage.isInstance(message)) role = "function";
-	else if (__langchain_core_messages.ChatMessage.isInstance(message)) {
+	if (_langchain_core_messages.HumanMessage.isInstance(message)) role = "user";
+	else if (_langchain_core_messages.AIMessage.isInstance(message)) role = "model";
+	else if (_langchain_core_messages.ToolMessage.isInstance(message)) role = "function";
+	else if (_langchain_core_messages.ChatMessage.isInstance(message)) {
 		const msgRole = message.role.toLowerCase();
 		if (msgRole === "user" || msgRole === "human") role = "user";
 		else if (msgRole === "assistant" || msgRole === "ai" || msgRole === "model") role = "model";
@@ -189,11 +182,10 @@ function convertStandardContentMessageToGeminiContent(message) {
 	} else role = "user";
 	const parts = [];
 	message.contentBlocks.forEach((block) => {
-		const contentBlock = message.additional_kwargs.originalTextContentBlock || block;
-		const part = convertStandardContentBlockToGeminiPart(contentBlock);
+		const part = convertStandardContentBlockToGeminiPart(message.additional_kwargs.originalTextContentBlock || block);
 		if (part) parts.push(part);
 	});
-	if (__langchain_core_messages.ToolMessage.isInstance(message) && message.tool_call_id) {
+	if (_langchain_core_messages.ToolMessage.isInstance(message) && message.tool_call_id) {
 		const responseContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
 		parts.push({ functionResponse: {
 			name: message.name || "unknown",
@@ -213,7 +205,7 @@ function convertStandardContentMessageToGeminiContent(message) {
 * This is intended to be called from `convertMessagesToGeminiContent`
 */
 function convertLegacyContentMessageToGeminiContent(message, messages) {
-	if (__langchain_core_messages.SystemMessage.isInstance(message)) return null;
+	if (_langchain_core_messages.SystemMessage.isInstance(message)) return null;
 	/**
 	* @deprecated - This is for use by `convertLegacyContentMessageToGeminiContent` only
 	*/
@@ -253,33 +245,26 @@ function convertLegacyContentMessageToGeminiContent(message, messages) {
 			tif: "image/tiff"
 		};
 		try {
-			const pathname = new URL(url).pathname;
-			const extension = pathname.split(".").pop()?.toLowerCase().split(/[?#]/)[0];
+			const extension = new URL(url).pathname.split(".").pop()?.toLowerCase().split(/[?#]/)[0];
 			return extension ? mimeTypeMap[extension] : "application/octet-stream";
 		} catch {
 			const match = url.match(/\.([a-zA-Z0-9]+)(?:[?#]|$)/);
-			if (match) {
-				const extension = match[1].toLowerCase();
-				return mimeTypeMap[extension];
-			}
+			if (match) return mimeTypeMap[match[1].toLowerCase()];
 			return "application/octet-stream";
 		}
 	}
 	function messageContentImageUrlData(content) {
 		const url = typeof content.image_url === "string" ? content.image_url : content.image_url.url;
 		if (!url) throw new require_errors.InvalidInputError("Missing image URL in image_url content block.");
-		const dataUrl = (0, __langchain_core_messages.parseBase64DataUrl)({ dataUrl: url });
+		const dataUrl = (0, _langchain_core_messages.parseBase64DataUrl)({ dataUrl: url });
 		if (dataUrl?.data && dataUrl?.mime_type) return { inlineData: {
 			data: dataUrl.data,
 			mimeType: dataUrl.mime_type
 		} };
-		else {
-			const mimeType = inferMimeTypeFromUrl(url) || "image/png";
-			return { fileData: {
-				mimeType,
-				fileUri: url
-			} };
-		}
+		else return { fileData: {
+			mimeType: inferMimeTypeFromUrl(url) || "image/png",
+			fileUri: url
+		} };
 	}
 	function messageContentImageUrl(content) {
 		const ret = messageContentImageUrlData(content);
@@ -307,10 +292,10 @@ function convertLegacyContentMessageToGeminiContent(message, messages) {
 		return ret;
 	}
 	const role = require_misc.iife(() => {
-		if (__langchain_core_messages.HumanMessage.isInstance(message)) return "user";
-		else if (__langchain_core_messages.AIMessage.isInstance(message)) return "model";
-		else if (__langchain_core_messages.ToolMessage.isInstance(message)) return "function";
-		else if (__langchain_core_messages.ChatMessage.isInstance(message)) {
+		if (_langchain_core_messages.HumanMessage.isInstance(message)) return "user";
+		else if (_langchain_core_messages.AIMessage.isInstance(message)) return "model";
+		else if (_langchain_core_messages.ToolMessage.isInstance(message)) return "function";
+		else if (_langchain_core_messages.ChatMessage.isInstance(message)) {
 			const msgRole = message.role.toLowerCase();
 			if (msgRole === "user" || msgRole === "human") return "user";
 			else if (msgRole === "assistant" || msgRole === "ai" || msgRole === "model") return "model";
@@ -324,9 +309,9 @@ function convertLegacyContentMessageToGeminiContent(message, messages) {
 	} else if (Array.isArray(message.content)) {
 		for (const item of message.content) if (typeof item === "string") parts.push({ text: item });
 		else if (typeof item === "object" && item !== null) if (isMessageContentText(item)) parts.push({ text: item.text });
-		else if ((0, __langchain_core_messages.isDataContentBlock)(item)) parts.push((0, __langchain_core_messages.convertToProviderContentBlock)(item, geminiContentBlockConverter));
+		else if ((0, _langchain_core_messages.isDataContentBlock)(item)) parts.push((0, _langchain_core_messages.convertToProviderContentBlock)(item, geminiContentBlockConverter));
 		else if (item?.type === "functionCall") {
-			const { type, functionCall,...etc } = item;
+			const { type, functionCall, ...etc } = item;
 			parts.push({
 				...etc,
 				functionCall
@@ -335,9 +320,9 @@ function convertLegacyContentMessageToGeminiContent(message, messages) {
 		else if (isMessageContentMedia(item)) parts.push(messageContentMedia(item));
 		else parts.push(item);
 	}
-	if (__langchain_core_messages.ToolMessage.isInstance(message) && message.tool_call_id) {
+	if (_langchain_core_messages.ToolMessage.isInstance(message) && message.tool_call_id) {
 		const responseContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
-		const toolCall = messages.filter(__langchain_core_messages.AIMessage.isInstance).find((msg) => msg.tool_calls?.find((tc) => tc.id === message.tool_call_id));
+		const toolCall = messages.filter(_langchain_core_messages.AIMessage.isInstance).find((msg) => msg.tool_calls?.find((tc) => tc.id === message.tool_call_id));
 		if (!toolCall) throw new require_errors.ToolCallNotFoundError(message.tool_call_id);
 		parts.push({ functionResponse: {
 			name: toolCall?.name || "unknown",
@@ -390,10 +375,8 @@ const convertMessagesToGeminiContents = (messages) => {
 	const contents = [];
 	for (const message of messages) {
 		const content = require_misc.iife(() => {
-			const outputVersion = "output_version" in message.response_metadata ? message.response_metadata?.output_version : "v0";
-			switch (outputVersion) {
+			switch ("output_version" in message.response_metadata ? message.response_metadata?.output_version : "v0") {
 				case "v1": return convertStandardContentMessageToGeminiContent(message);
-				case "v0":
 				default: return convertLegacyContentMessageToGeminiContent(message, messages);
 			}
 		});
@@ -441,10 +424,10 @@ const convertMessagesToGeminiContents = (messages) => {
 */
 const convertMessagesToGeminiSystemInstruction = (messages) => {
 	const systemParts = [];
-	for (const message of messages) if (__langchain_core_messages.SystemMessage.isInstance(message)) {
+	for (const message of messages) if (_langchain_core_messages.SystemMessage.isInstance(message)) {
 		if (message.text.trim()) systemParts.push({ text: message.text });
 	}
-	if (systemParts.length === 0) return void 0;
+	if (systemParts.length === 0) return;
 	return { parts: systemParts };
 };
 /**
@@ -588,8 +571,7 @@ const convertGeminiCandidateToAIMessage = (candidate) => {
 		const ret = [];
 		if (!groundingSupports || groundingSupports.length === 0) return [[]];
 		groundingSupports?.forEach((groundingSupport) => {
-			const segment = groundingSupport?.segment;
-			const partIndex = segment?.partIndex ?? 0;
+			const partIndex = (groundingSupport?.segment)?.partIndex ?? 0;
 			if (ret[partIndex]) ret[partIndex].push(groundingSupport);
 			else ret[partIndex] = [groundingSupport];
 		});
@@ -644,7 +626,7 @@ const convertGeminiCandidateToAIMessage = (candidate) => {
 	};
 	for (const attribute in additional_kwargs) if (additional_kwargs[attribute] === void 0) delete additional_kwargs[attribute];
 	for (const attribute in response_metadata) if (response_metadata[attribute] === void 0) delete response_metadata[attribute];
-	return new __langchain_core_messages.AIMessage({
+	return new _langchain_core_messages.AIMessage({
 		content,
 		tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
 		additional_kwargs,
@@ -662,15 +644,12 @@ const convertGeminiGenerateContentResponseToUsageMetadata = (data) => {
 			const { modality, tokenCount } = modalityTokenCount;
 			if (typeof modality === "undefined" || typeof tokenCount === "undefined") return;
 			const modalityLc = modality.toLowerCase();
-			const currentCount = details[modalityLc] ?? 0;
-			details[modalityLc] = currentCount + tokenCount;
+			details[modalityLc] = (details[modalityLc] ?? 0) + tokenCount;
 		});
 	}
 	const usageMetadata = data.usageMetadata;
 	const inputTokenCount = usageMetadata?.promptTokenCount ?? 0;
-	const candidatesTokenCount = usageMetadata?.candidatesTokenCount ?? 0;
-	const thoughtsTokenCount = usageMetadata?.thoughtsTokenCount ?? 0;
-	const outputTokenCount = candidatesTokenCount + thoughtsTokenCount;
+	const outputTokenCount = (usageMetadata?.candidatesTokenCount ?? 0) + (usageMetadata?.thoughtsTokenCount ?? 0);
 	const totalTokens = usageMetadata?.totalTokenCount ?? inputTokenCount + outputTokenCount;
 	const input_token_details = {};
 	addModalityCounts(usageMetadata?.promptTokensDetails, input_token_details);