@google/adk 2.2.1 → 2.4.0

package/dist/esm/tools/google_api_tool/googleapi_to_openapi_converter.js

@@ -0,0 +1,393 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from "node:fs";
+import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
+const GOOGLE_DISCOVERY_BASE_URL = "https://www.googleapis.com/discovery/v1/apis";
+const GOOGLE_OAUTH2_AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
+const GOOGLE_OAUTH2_TOKEN_URL = "https://oauth2.googleapis.com/token";
+function normalizeGoogleSchemaRef(ref) {
+  if (ref.startsWith("#")) {
+    return `#/components/schemas/${ref.slice(1)}`;
+  }
+  return `#/components/schemas/${ref}`;
+}
+__name(normalizeGoogleSchemaRef, "normalizeGoogleSchemaRef");
+function convertInfo(googleApiSpec, openapiSpec, apiName, apiVersion) {
+  var _a, _b, _c, _d;
+  openapiSpec.info = {
+    title: (_a = googleApiSpec.title) != null ? _a : `${apiName} API`,
+    description: (_b = googleApiSpec.description) != null ? _b : "",
+    version: (_c = googleApiSpec.version) != null ? _c : apiVersion,
+    contact: {},
+    termsOfService: (_d = googleApiSpec.documentationLink) != null ? _d : ""
+  };
+  const docsLink = googleApiSpec.documentationLink;
+  if (docsLink) {
+    openapiSpec.externalDocs = {
+      description: "API Documentation",
+      url: docsLink
+    };
+  }
+}
+__name(convertInfo, "convertInfo");
+function convertServers(googleApiSpec, openapiSpec, apiName, apiVersion) {
+  var _a, _b;
+  let baseUrl = `${(_a = googleApiSpec.rootUrl) != null ? _a : ""}${(_b = googleApiSpec.servicePath) != null ? _b : ""}`;
+  if (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+  openapiSpec.servers = [
+    {
+      url: baseUrl,
+      description: `${apiName} ${apiVersion} API`
+    }
+  ];
+}
+__name(convertServers, "convertServers");
+function convertSecuritySchemes(googleApiSpec, openapiSpec) {
+  var _a, _b, _c, _d, _e;
+  openapiSpec.components = (_a = openapiSpec.components) != null ? _a : {};
+  openapiSpec.components.securitySchemes = (_b = openapiSpec.components.securitySchemes) != null ? _b : {};
+  const oauth2 = (_c = googleApiSpec.auth) == null ? void 0 : _c.oauth2;
+  const hasOauth2 = oauth2 !== void 0 && Object.keys(oauth2).length > 0;
+  const formattedScopes = {};
+  if (hasOauth2) {
+    const scopes = (_d = oauth2.scopes) != null ? _d : {};
+    for (const [scope, scopeInfo] of Object.entries(scopes)) {
+      formattedScopes[scope] = (_e = scopeInfo.description) != null ? _e : "";
+    }
+    openapiSpec.components.securitySchemes["oauth2"] = {
+      type: "oauth2",
+      description: "OAuth 2.0 authentication",
+      flows: {
+        authorizationCode: {
+          authorizationUrl: GOOGLE_OAUTH2_AUTH_URL,
+          tokenUrl: GOOGLE_OAUTH2_TOKEN_URL,
+          scopes: formattedScopes
+        }
+      }
+    };
+  }
+  openapiSpec.components.securitySchemes["apiKey"] = {
+    type: "apiKey",
+    in: "query",
+    name: "key",
+    description: "API key for accessing this API"
+  };
+  openapiSpec.security = [
+    hasOauth2 ? { oauth2: Object.keys(formattedScopes) } : {},
+    { apiKey: [] }
+  ];
+}
+__name(convertSecuritySchemes, "convertSecuritySchemes");
+function convertSchemaObject(schemaDef) {
+  var _a;
+  const result = {};
+  if (schemaDef.type !== void 0) {
+    const gtype = schemaDef.type;
+    if (gtype === "object") {
+      result["type"] = "object";
+      if (schemaDef.properties !== void 0) {
+        const properties = {};
+        for (const [propName, propDef] of Object.entries(
+          schemaDef.properties
+        )) {
+          properties[propName] = convertSchemaObject(propDef);
+        }
+        result["properties"] = properties;
+      }
+      const requiredFields = [];
+      for (const [propName, propDef] of Object.entries(
+        (_a = schemaDef.properties) != null ? _a : {}
+      )) {
+        if (propDef.required) {
+          requiredFields.push(propName);
+        }
+      }
+      if (requiredFields.length > 0) {
+        result["required"] = requiredFields;
+      }
+    } else if (gtype === "array") {
+      result["type"] = "array";
+      if (schemaDef.items !== void 0) {
+        result["items"] = convertSchemaObject(schemaDef.items);
+      }
+    } else if (gtype === "any") {
+      result["oneOf"] = [
+        { type: "object" },
+        { type: "array" },
+        { type: "string" },
+        { type: "number" },
+        { type: "boolean" },
+        { type: "null" }
+      ];
+    } else {
+      result["type"] = gtype;
+    }
+  }
+  if (schemaDef.$ref !== void 0) {
+    result["$ref"] = normalizeGoogleSchemaRef(schemaDef.$ref);
+  }
+  if (schemaDef.format !== void 0) {
+    result["format"] = schemaDef.format;
+  }
+  if (schemaDef.enum !== void 0) {
+    result["enum"] = schemaDef.enum;
+  }
+  if (schemaDef.description !== void 0) {
+    result["description"] = schemaDef.description;
+  }
+  if (schemaDef.pattern !== void 0) {
+    result["pattern"] = schemaDef.pattern;
+  }
+  if (schemaDef.default !== void 0) {
+    result["default"] = schemaDef.default;
+  }
+  return result;
+}
+__name(convertSchemaObject, "convertSchemaObject");
+function convertSchemas(googleApiSpec, openapiSpec) {
+  var _a, _b, _c;
+  openapiSpec.components = (_a = openapiSpec.components) != null ? _a : {};
+  openapiSpec.components.schemas = (_b = openapiSpec.components.schemas) != null ? _b : {};
+  const schemas = (_c = googleApiSpec.schemas) != null ? _c : {};
+  for (const [schemaName, schemaDef] of Object.entries(schemas)) {
+    openapiSpec.components.schemas[schemaName] = convertSchemaObject(schemaDef);
+  }
+}
+__name(convertSchemas, "convertSchemas");
+function extractPathParameters(path) {
+  const params = [];
+  for (const match of path.matchAll(/\{\+?([^{}]+)\}/g)) {
+    params.push(match[1]);
+  }
+  return params;
+}
+__name(extractPathParameters, "extractPathParameters");
+function convertParameterSchema(paramData) {
+  var _a;
+  const schema = {
+    type: (_a = paramData.type) != null ? _a : "string"
+  };
+  if (paramData.enum !== void 0) {
+    schema["enum"] = paramData.enum;
+  }
+  if (paramData.format !== void 0) {
+    schema["format"] = paramData.format;
+  }
+  if (paramData.default !== void 0) {
+    schema["default"] = paramData.default;
+  }
+  if (paramData.pattern !== void 0) {
+    schema["pattern"] = paramData.pattern;
+  }
+  return schema;
+}
+__name(convertParameterSchema, "convertParameterSchema");
+function convertOperation(methodData, pathParams) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const parameters = [];
+  for (const paramName of pathParams) {
+    parameters.push({
+      name: paramName,
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    });
+  }
+  const pathParamSet = new Set(pathParams);
+  for (const [paramName, paramData] of Object.entries(
+    (_a = methodData.parameters) != null ? _a : {}
+  )) {
+    if (pathParamSet.has(paramName)) {
+      continue;
+    }
+    const location = (_b = paramData.location) != null ? _b : "query";
+    parameters.push({
+      name: paramName,
+      in: location,
+      description: (_c = paramData.description) != null ? _c : "",
+      required: location === "path" ? true : (_d = paramData.required) != null ? _d : false,
+      schema: convertParameterSchema(paramData)
+    });
+  }
+  const response200 = {
+    description: "Successful operation"
+  };
+  const responseRef = (_e = methodData.response) == null ? void 0 : _e.$ref;
+  if (responseRef) {
+    response200.content = {
+      "application/json": {
+        schema: { $ref: normalizeGoogleSchemaRef(responseRef) }
+      }
+    };
+  }
+  const operation = {
+    operationId: (_f = methodData.id) != null ? _f : "",
+    summary: (_g = methodData.description) != null ? _g : "",
+    description: (_h = methodData.description) != null ? _h : "",
+    parameters,
+    responses: {
+      "200": response200,
+      "400": { description: "Bad request" },
+      "401": { description: "Unauthorized" },
+      "403": { description: "Forbidden" },
+      "404": { description: "Not found" },
+      "500": { description: "Server error" }
+    }
+  };
+  const requestRef = (_i = methodData.request) == null ? void 0 : _i.$ref;
+  if (requestRef) {
+    operation.requestBody = {
+      description: "Request body",
+      content: {
+        "application/json": {
+          schema: { $ref: normalizeGoogleSchemaRef(requestRef) }
+        }
+      },
+      required: true
+    };
+  }
+  const scopes = (_j = methodData.scopes) != null ? _j : [];
+  if (scopes.length > 0) {
+    operation.security = [{ oauth2: scopes }];
+  }
+  return operation;
+}
+__name(convertOperation, "convertOperation");
+function convertMethods(methods, _resourcePath, openapiSpec) {
+  var _a, _b, _c;
+  for (const methodData of Object.values(methods)) {
+    const httpMethod = ((_a = methodData.httpMethod) != null ? _a : "GET").toLowerCase();
+    let restPath = ((_c = (_b = methodData.flatPath) != null ? _b : methodData.path) != null ? _c : "/").replace(
+      /\{\+([^{}]+)\}/g,
+      (_match, paramName) => `{${paramName}}`
+    );
+    if (!restPath.startsWith("/")) {
+      restPath = `/${restPath}`;
+    }
+    const pathParams = extractPathParameters(restPath);
+    if (!openapiSpec.paths[restPath]) {
+      openapiSpec.paths[restPath] = {};
+    }
+    const pathItem = openapiSpec.paths[restPath];
+    pathItem[httpMethod] = convertOperation(methodData, pathParams);
+  }
+}
+__name(convertMethods, "convertMethods");
+function convertResources(resources, openapiSpec, parentPath = "") {
+  var _a;
+  for (const [resourceName, resourceData] of Object.entries(resources)) {
+    const resourcePath = `${parentPath}/${resourceName}`;
+    convertMethods((_a = resourceData.methods) != null ? _a : {}, resourcePath, openapiSpec);
+    if (resourceData.resources && Object.keys(resourceData.resources).length > 0) {
+      convertResources(resourceData.resources, openapiSpec, resourcePath);
+    }
+  }
+}
+__name(convertResources, "convertResources");
+let GoogleApiToOpenApiConverter = class {
+  constructor(apiName, apiVersion) {
+    this.googleApiSpec = null;
+    this.apiName = apiName;
+    this.apiVersion = apiVersion;
+    this.openapiSpec = {
+      openapi: "3.0.0",
+      info: {},
+      servers: [],
+      paths: {},
+      components: { schemas: {}, securitySchemes: {} }
+    };
+  }
+  async fetchGoogleApiSpec() {
+    try {
+      logger.debug(
+        `Fetching Google API spec for ${this.apiName} ${this.apiVersion}`
+      );
+      const url = `${GOOGLE_DISCOVERY_BASE_URL}/${encodeURIComponent(this.apiName)}/${encodeURIComponent(this.apiVersion)}/rest`;
+      const response = await globalThis.fetch(url);
+      if (response.status >= 400) {
+        throw new Error(
+          `HTTP Error ${response.status}: Failed to fetch Google API spec for ${this.apiName} ${this.apiVersion}`
+        );
+      }
+      const spec = await response.json();
+      if (!spec || typeof spec !== "object" || Object.keys(spec).length === 0) {
+        throw new Error("Failed to retrieve API specification");
+      }
+      this.googleApiSpec = spec;
+      logger.debug(`Successfully fetched ${this.apiName} API specification`);
+    } catch (error) {
+      logger.error(
+        `Error fetching API spec: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  async convert() {
+    var _a, _b, _c;
+    if (!this.googleApiSpec) {
+      await this.fetchGoogleApiSpec();
+    }
+    const spec = (_a = this.googleApiSpec) != null ? _a : {};
+    convertInfo(spec, this.openapiSpec, this.apiName, this.apiVersion);
+    convertServers(spec, this.openapiSpec, this.apiName, this.apiVersion);
+    convertSecuritySchemes(spec, this.openapiSpec);
+    convertSchemas(spec, this.openapiSpec);
+    convertResources((_b = spec.resources) != null ? _b : {}, this.openapiSpec);
+    convertMethods((_c = spec.methods) != null ? _c : {}, "/", this.openapiSpec);
+    return this.openapiSpec;
+  }
+  saveOpenapiSpec(outputPath) {
+    fs.writeFileSync(
+      outputPath,
+      JSON.stringify(this.openapiSpec, null, 2),
+      "utf-8"
+    );
+    logger.info(`OpenAPI specification saved to ${outputPath}`);
+  }
+};
+__name(GoogleApiToOpenApiConverter, "GoogleApiToOpenApiConverter");
+__decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter.prototype, "fetchGoogleApiSpec", 1);
+__decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter.prototype, "convert", 1);
+__decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter.prototype, "saveOpenapiSpec", 1);
+GoogleApiToOpenApiConverter = __decorateClass([
+  experimental
+], GoogleApiToOpenApiConverter);
+export {
+  GoogleApiToOpenApiConverter,
+  convertInfo,
+  convertMethods,
+  convertOperation,
+  convertParameterSchema,
+  convertResources,
+  convertSchemaObject,
+  convertSchemas,
+  convertSecuritySchemes,
+  convertServers,
+  extractPathParameters,
+  normalizeGoogleSchemaRef
+};

package/dist/esm/tools/google_api_tool/index.js

@@ -0,0 +1,31 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleApiTool, isGoogleApiTool } from "./google_api_tool.js";
+import { GoogleApiToolset, isGoogleApiToolset } from "./google_api_toolset.js";
+import {
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset
+} from "./google_api_toolsets.js";
+export {
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  GoogleApiTool,
+  GoogleApiToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset,
+  isGoogleApiTool,
+  isGoogleApiToolset
+};

package/dist/esm/tools/load_artifacts_tool.js

@@ -9,6 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { Type } from "@google/genai";
 import { appendInstructions } from "../models/llm_request.js";
+import { base64Decode } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
 import {
   BaseTool
@@ -37,6 +38,11 @@ function isInlineMimeTypeSupported(mimeType) {
   ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
 }
 __name(isInlineMimeTypeSupported, "isInlineMimeTypeSupported");
+function base64ByteLength(data) {
+  const digits = data.replace(/[=\s]/g, "").length;
+  return Math.floor(digits * 3 / 4);
+}
+__name(base64ByteLength, "base64ByteLength");
 function asSafePartForLlm(artifact, artifactName) {
   const inlineData = artifact.inlineData;
   if (!inlineData) {
@@ -53,15 +59,13 @@ function asSafePartForLlm(artifact, artifactName) {
     };
   }
   const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
-  const decodedBuffer = Buffer.from(data, "base64");
   if (isTextLike) {
     try {
-      const decoded = decodedBuffer.toString("utf8");
-      return { text: decoded };
+      return { text: base64Decode(data.replace(/-/g, "+").replace(/_/g, "/")) };
     } catch {
     }
   }
-  const sizeKb = decodedBuffer.length / 1024;
+  const sizeKb = base64ByteLength(data) / 1024;
   return {
     text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
   };
@@ -188,5 +192,6 @@ let LoadArtifactsTool = _LoadArtifactsTool;
 const LOAD_ARTIFACTS = new LoadArtifactsTool();
 export {
   LOAD_ARTIFACTS,
-  LoadArtifactsTool
+  LoadArtifactsTool,
+  asSafePartForLlm
 };

package/dist/esm/tools/load_memory_tool.js

@@ -13,11 +13,13 @@ import {
   BaseTool
 } from "./base_tool.js";
 const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
-  constructor() {
+  constructor(options = {}) {
+    var _a;
     super({
       name: "load_memory",
       description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
     });
+    this.textOnlyContent = (_a = options.textOnlyContent) != null ? _a : false;
   }
   _getDeclaration() {
     return {
@@ -39,12 +41,12 @@ const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
     args,
     toolContext
   }) {
-    try {
-      const query = args["query"];
-      if (!toolContext.invocationContext.memoryService) {
-        throw new Error("Memory service is not initialized.");
-      }
-      const searchMemoryResponse = await toolContext.searchMemory(query);
+    const query = args["query"];
+    if (!toolContext.invocationContext.memoryService) {
+      throw new Error("Memory service is not initialized.");
+    }
+    const searchMemoryResponse = await toolContext.searchMemory(query);
+    if (this.textOnlyContent) {
       return {
         memories: searchMemoryResponse.memories.map((m) => {
           var _a, _b;
@@ -59,10 +61,10 @@ const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
           };
         })
       };
-    } catch (e) {
-      console.error("ERROR in LoadMemoryTool runAsync:", e);
-      throw e;
     }
+    return {
+      memories: searchMemoryResponse.memories
+    };
   }
   async processLlmRequest(request) {
     await super.processLlmRequest(request);

package/dist/esm/tools/mcp/index.js

@@ -5,7 +5,13 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { toGeminiSchema } from "../../utils/gemini_schema_util.js";
+import { genaiSchemaToJsonSchema } from "../../utils/genai_schema_to_json.js";
 export * from "./load_mcp_resource_tool.js";
 export * from "./mcp_session_manager.js";
 export * from "./mcp_tool.js";
 export * from "./mcp_toolset.js";
+export {
+  genaiSchemaToJsonSchema,
+  toGeminiSchema
+};

package/dist/esm/tools/mcp/mcp_session_manager.js

@@ -52,6 +52,18 @@ function buildTransportOptions(params) {
   };
 }
 __name(buildTransportOptions, "buildTransportOptions");
+function buildSseTransportOptions(params) {
+  const { transportOptions, header, headers } = params;
+  const callerHeaders = (transportOptions == null ? void 0 : transportOptions.requestInit) === void 0 ? header != null ? header : headers : transportOptions.requestInit.headers;
+  return {
+    ...transportOptions,
+    requestInit: {
+      ...transportOptions == null ? void 0 : transportOptions.requestInit,
+      headers: mergeTrackingHeaders(callerHeaders)
+    }
+  };
+}
+__name(buildSseTransportOptions, "buildSseTransportOptions");
 const _MCPSessionManager = class _MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
@@ -90,6 +102,19 @@ const _MCPSessionManager = class _MCPSessionManager {
           await client.connect(transport);
           break;
         }
+        case "SseConnectionParams": {
+          const { SSEClientTransport } = await loadOptionalPeer(
+            MCP_SDK,
+            () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/sse.js"), 1))
+          );
+          const transport = new SSEClientTransport(
+            new URL(this.connectionParams.url),
+            buildSseTransportOptions(this.connectionParams)
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
+        }
         default: {
           const _exhaustiveCheck = this.connectionParams;
           break;

package/dist/esm/tools/mcp/mcp_toolset.js

@@ -35,20 +35,7 @@ const _MCPToolset = class _MCPToolset extends BaseToolset {
       };
       return new MCPTool(toolWithPrefix, this.mcpSessionManager, tool.name);
     });
-    const filter = this.toolFilter;
-    if (!filter || Array.isArray(filter) && filter.length === 0) {
-      return tools;
-    }
-    if (Array.isArray(filter)) {
-      return tools.filter((tool) => filter.includes(tool.name));
-    }
-    if (context) {
-      return tools.filter((tool) => filter(tool, context));
-    }
-    logger.warn(
-      "MCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
-    );
-    return tools;
+    return tools.filter((tool) => this.isToolSelected(tool, context));
   }
   /**
    * Lists the names of the resources advertised by the MCP server.

package/dist/esm/tools/openapi_tool/auth/auth_helpers.js

@@ -131,12 +131,11 @@ function bearerJwtScheme() {
 }
 __name(bearerJwtScheme, "bearerJwtScheme");
 function bearerTokenParam(authScheme, token) {
-  var _a;
   const param = {
     originalName: "Authorization",
     paramLocation: "header",
     paramSchema: { type: "string" },
-    description: (_a = authScheme.description) != null ? _a : "Bearer token",
+    description: authScheme.description || "Bearer token",
     name: `${INTERNAL_AUTH_PREFIX}Authorization`,
     required: true
   };

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js

@@ -19,9 +19,46 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   AuthCredentialTypes
 } from "../../../../auth/auth_credential.js";
-import { OAuth2CredentialExchanger } from "../../../../auth/oauth2/oauth2_credential_exchanger.js";
+import { OAuthGrantType } from "../../../../auth/auth_schemes.js";
+import {
+  determineGrantType,
+  OAuth2CredentialExchanger
+} from "../../../../auth/oauth2/oauth2_credential_exchanger.js";
 import { experimental } from "../../../../utils/experimental.js";
+import { generateAuthToken } from "./oauth2_exchanger.js";
 import { ServiceAccountCredentialExchanger } from "./service_account_exchanger.js";
+function isPendingAuthorizationCode(authScheme, authCredential) {
+  var _a, _b, _c;
+  return !!authScheme && determineGrantType(authScheme) === OAuthGrantType.AUTHORIZATION_CODE && !((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) && !((_b = authCredential.oauth2) == null ? void 0 : _b.authCode) && !((_c = authCredential.oauth2) == null ? void 0 : _c.authResponseUri);
+}
+__name(isPendingAuthorizationCode, "isPendingAuthorizationCode");
+function createDefaultOAuth2Exchanger() {
+  const tokenFetcher = new OAuth2CredentialExchanger();
+  return {
+    async exchange(params) {
+      const { authScheme, authCredential } = params;
+      if (authScheme && authCredential.http) {
+        return {
+          credential: authCredential,
+          wasExchanged: false
+        };
+      }
+      if (isPendingAuthorizationCode(authScheme, authCredential)) {
+        return {
+          credential: authCredential,
+          wasExchanged: false
+        };
+      }
+      const { credential, wasExchanged } = await tokenFetcher.exchange(params);
+      const bearer = generateAuthToken(credential);
+      return {
+        credential: bearer,
+        wasExchanged: wasExchanged || bearer !== credential
+      };
+    }
+  };
+}
+__name(createDefaultOAuth2Exchanger, "createDefaultOAuth2Exchanger");
 let AutoAuthCredentialExchanger = class {
   /**
    * @param customExchangers - Optional exchangers that add to or override the
@@ -29,14 +66,24 @@ let AutoAuthCredentialExchanger = class {
    *   exchanger instance to use for that type.
    */
   constructor(customExchangers) {
+    /**
+     * The exchanger used for each auth credential type.
+     *
+     * By default `OAUTH2` and `OPEN_ID_CONNECT` run
+     * {@link OAuth2CredentialExchanger} and convert any access token with
+     * {@link generateAuthToken}, and `SERVICE_ACCOUNT` maps to a
+     * {@link ServiceAccountCredentialExchanger}, with any custom exchangers from
+     * the constructor merged over them. The map is live: an entry added or
+     * replaced after construction is used by the next {@link exchange} call.
+     */
     this.exchangers = /* @__PURE__ */ new Map();
     this.exchangers.set(
       AuthCredentialTypes.OAUTH2,
-      new OAuth2CredentialExchanger()
+      createDefaultOAuth2Exchanger()
     );
     this.exchangers.set(
       AuthCredentialTypes.OPEN_ID_CONNECT,
-      new OAuth2CredentialExchanger()
+      createDefaultOAuth2Exchanger()
     );
     this.exchangers.set(
       AuthCredentialTypes.SERVICE_ACCOUNT,