@google/adk 1.6.0 → 2.0.0

package/dist/esm/artifacts/gcs_artifact_service.js

@@ -1,20 +1,58 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Storage } from "@google-cloud/storage";
 import { createPartFromBase64, createPartFromText } from "@google/genai";
 import { logger } from "../utils/logger.js";
+import { loadOptionalPeer } from "../utils/optional_peer.js";
 const GCS_FILE_URI_METADATA_KEY = "adkFileUri";
 const GCS_FILE_MIME_TYPE_METADATA_KEY = "adkFileMimeType";
 const GCS_DISPLAY_NAME_METADATA_KEY = "adkDisplayName";
 const GCS_IS_TEXT_METADATA_KEY = "adkIsText";
-class GcsArtifactService {
+const _GcsArtifactService = class _GcsArtifactService {
   constructor(bucket, options) {
-    this.bucket = new Storage(options).bucket(bucket);
+    this.bucketName = bucket;
+    this.storageOptions = options;
+  }
+  /**
+   * Resolves the GCS bucket handle, loading the `@google-cloud/storage`
+   * optional peer on first use.
+   */
+  getBucket() {
+    var _a;
+    (_a = this.bucketPromise) != null ? _a : this.bucketPromise = loadOptionalPeer(
+      { packageName: "@google-cloud/storage", feature: "GcsArtifactService" },
+      () => Promise.resolve().then(() => __toESM(require("@google-cloud/storage"), 1))
+    ).then(
+      ({ Storage }) => new Storage(this.storageOptions).bucket(this.bucketName)
+    );
+    return this.bucketPromise;
   }
   async saveArtifact(request) {
     if (!request.artifact.inlineData && !request.artifact.text && !request.artifact.fileData) {
@@ -22,7 +60,8 @@ class GcsArtifactService {
     }
     const versions = await this.listVersions(request);
     const version = versions.length > 0 ? Math.max(...versions) + 1 : 0;
-    const file = this.bucket.file(
+    const bucket = await this.getBucket();
+    const file = bucket.file(
       getFileName({
         ...request,
         version
@@ -79,7 +118,7 @@ class GcsArtifactService {
         }
         version = Math.max(...versions);
       }
-      const file = this.bucket.file(
+      const file = (await this.getBucket()).file(
         getFileName({
           ...request,
           version
@@ -121,9 +160,10 @@ class GcsArtifactService {
   async listArtifactKeys(request) {
     const sessionPrefix = `${request.appName}/${request.userId}/${request.sessionId}/`;
     const usernamePrefix = `${request.appName}/${request.userId}/user/`;
+    const bucket = await this.getBucket();
     const [[sessionFiles], [userSessionFiles]] = await Promise.all([
-      this.bucket.getFiles({ prefix: sessionPrefix }),
-      this.bucket.getFiles({ prefix: usernamePrefix })
+      bucket.getFiles({ prefix: sessionPrefix }),
+      bucket.getFiles({ prefix: usernamePrefix })
     ]);
     return [
       ...extractArtifactKeys(sessionFiles, sessionPrefix),
@@ -132,9 +172,10 @@ class GcsArtifactService {
   }
   async deleteArtifact(request) {
     const versions = await this.listVersions(request);
+    const bucket = await this.getBucket();
     await Promise.all(
       versions.map((version) => {
-        const file = this.bucket.file(
+        const file = bucket.file(
           getFileName({
             ...request,
             version
@@ -148,7 +189,8 @@ class GcsArtifactService {
   async listVersions(request) {
     const prefix = getFileName(request);
     const searchPrefix = prefix + "/";
-    const [files] = await this.bucket.getFiles({ prefix: searchPrefix });
+    const bucket = await this.getBucket();
+    const [files] = await bucket.getFiles({ prefix: searchPrefix });
     const versions = [];
     for (const file of files) {
       const version = file.name.split("/").pop();
@@ -183,7 +225,7 @@ class GcsArtifactService {
         }
         version = Math.max(...versions);
       }
-      const file = this.bucket.file(
+      const file = (await this.getBucket()).file(
         getFileName({
           ...request,
           version
@@ -204,7 +246,9 @@ class GcsArtifactService {
       return void 0;
     }
   }
-}
+};
+__name(_GcsArtifactService, "GcsArtifactService");
+let GcsArtifactService = _GcsArtifactService;
 function getFileName({
   appName,
   userId,
@@ -217,6 +261,7 @@ function getFileName({
   const prefix = isUser ? `${appName}/${userId}/user/${cleanFilename}` : `${appName}/${userId}/${sessionId}/${cleanFilename}`;
   return version !== void 0 ? `${prefix}/${version}` : prefix;
 }
+__name(getFileName, "getFileName");
 function extractArtifactKeys(files, fileNamePrefix, keyPrefix = "") {
   const keys = /* @__PURE__ */ new Set();
   for (const file of files) {
@@ -229,6 +274,7 @@ function extractArtifactKeys(files, fileNamePrefix, keyPrefix = "") {
   }
   return [...keys];
 }
+__name(extractArtifactKeys, "extractArtifactKeys");
 function getFileNameFromPath(filePath) {
   const parts = filePath.split("/");
   if (parts.length < 2) {
@@ -236,6 +282,7 @@ function getFileNameFromPath(filePath) {
   }
   return parts.slice(0, -1).join("/");
 }
+__name(getFileNameFromPath, "getFileNameFromPath");
 export {
   GcsArtifactService
 };

package/dist/esm/artifacts/in_memory_artifact_service.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -9,7 +11,8 @@ import { logger } from "../utils/logger.js";
 function isInMemoryConnectionString(uri) {
   return uri === "memory://";
 }
-class InMemoryArtifactService {
+__name(isInMemoryConnectionString, "isInMemoryConnectionString");
+const _InMemoryArtifactService = class _InMemoryArtifactService {
   constructor() {
     this.artifacts = {};
   }
@@ -145,19 +148,24 @@ class InMemoryArtifactService {
     }
     return Promise.resolve(void 0);
   }
-}
+};
+__name(_InMemoryArtifactService, "InMemoryArtifactService");
+let InMemoryArtifactService = _InMemoryArtifactService;
 function artifactPath(appName, userId, sessionId, filename) {
   if (fileHasUserNamespace(filename)) {
     return `${artifactPrefix("user", appName, userId)}${encodeURIComponent(filename)}`;
   }
   return `${artifactPrefix("session", appName, userId, sessionId)}${encodeURIComponent(filename)}`;
 }
+__name(artifactPath, "artifactPath");
 function artifactPrefix(scope, ...parts) {
   return `${[scope, ...parts].map(encodeURIComponent).join("/")}/`;
 }
+__name(artifactPrefix, "artifactPrefix");
 function fileHasUserNamespace(filename) {
   return filename.startsWith("user:");
 }
+__name(fileHasUserNamespace, "fileHasUserNamespace");
 export {
   InMemoryArtifactService,
   isInMemoryConnectionString

package/dist/esm/artifacts/registry.js

@@ -1,10 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { redactUriPassword } from "../utils/redact_uri.js";
 import { FileArtifactService } from "./file_artifact_service.js";
 import { GcsArtifactService } from "./gcs_artifact_service.js";
 import {
@@ -23,8 +26,11 @@ function getArtifactServiceFromUri(uri) {
     const rootDir = uri.split("://")[1];
     return new FileArtifactService(rootDir);
   }
-  throw new Error(`Unsupported artifact service URI: ${uri}`);
+  throw new Error(
+    `Unsupported artifact service URI: ${redactUriPassword(uri)}`
+  );
 }
+__name(getArtifactServiceFromUri, "getArtifactServiceFromUri");
 export {
   getArtifactServiceFromUri
 };

package/dist/esm/artifacts/scoped_artifact_service.js

@@ -1,11 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class ScopedArtifactService {
+const _ScopedArtifactService = class _ScopedArtifactService {
   constructor(delegate, appName, userId, sessionId) {
     this.delegate = delegate;
     this.appName = appName;
@@ -67,7 +69,9 @@ class ScopedArtifactService {
       ...request
     });
   }
-}
+};
+__name(_ScopedArtifactService, "ScopedArtifactService");
+let ScopedArtifactService = _ScopedArtifactService;
 export {
   ScopedArtifactService
 };

package/dist/esm/auth/auth_handler.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -7,7 +9,7 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { OAuth2CredentialExchanger } from "./oauth2/oauth2_credential_exchanger.js";
-class AuthHandler {
+const _AuthHandler = class _AuthHandler {
   constructor(authConfig) {
     this.authConfig = authConfig;
   }
@@ -125,7 +127,9 @@ class AuthHandler {
     };
     return exchangedAuthCredential;
   }
-}
+};
+__name(_AuthHandler, "AuthHandler");
+let AuthHandler = _AuthHandler;
 export {
   AuthHandler
 };

package/dist/esm/auth/auth_preprocessor.js

@@ -1,12 +1,14 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import {
-  REQUEST_EUC_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
   handleFunctionCallsAsync
 } from "../agents/functions.js";
 import { isLlmAgent } from "../agents/llm_agent.js";
@@ -18,57 +20,61 @@ import {
 } from "../events/event.js";
 import { State } from "../sessions/state.js";
 import { camelCaseKeys } from "../utils/case_utils.js";
+import { logger } from "../utils/logger.js";
 import { AuthHandler } from "./auth_handler.js";
+import { bindCredentialResponse } from "./credential_response_binding.js";
 const TOOLSET_AUTH_CREDENTIAL_ID_PREFIX = "_adk_toolset_auth_";
-async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses, state) {
-  const requestedAuthConfigById = {};
+function requestedAuthConfigs(events, authFcIds, agentName) {
+  const requests = /* @__PURE__ */ new Map();
   for (const event of events) {
-    const eventFunctionCalls = getFunctionCalls(event);
-    for (const functionCall of eventFunctionCalls) {
-      if (functionCall.id && authFcIds.has(functionCall.id) && functionCall.name === REQUEST_EUC_FUNCTION_CALL_NAME) {
-        const args = camelCaseKeys(functionCall.args);
-        const authConfig = args == null ? void 0 : args.authConfig;
-        if (authConfig) {
-          requestedAuthConfigById[functionCall.id] = authConfig;
-        }
-      }
+    if (event.author !== agentName) {
+      continue;
     }
-  }
-  for (const fcId of authFcIds) {
-    const authConfig = authResponses[fcId];
-    const requestedAuthConfig = requestedAuthConfigById[fcId];
-    if (requestedAuthConfig && requestedAuthConfig.credentialKey) {
-      authConfig.credentialKey = requestedAuthConfig.credentialKey;
+    for (const functionCall of getFunctionCalls(event)) {
+      if (!functionCall.id || !authFcIds.has(functionCall.id) || functionCall.name !== REQUEST_CREDENTIAL_FUNCTION_CALL_NAME) {
+        continue;
+      }
+      const args = camelCaseKeys(functionCall.args);
+      if (args == null ? void 0 : args.authConfig) {
+        requests.set(functionCall.id, { config: args.authConfig, args });
+      }
     }
-    await new AuthHandler(authConfig).parseAndStoreAuthResponse(state);
   }
+  return requests;
+}
+__name(requestedAuthConfigs, "requestedAuthConfigs");
+async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses, state, agentName) {
+  var _a;
+  const requests = requestedAuthConfigs(events, authFcIds, agentName);
   const toolsToResume = /* @__PURE__ */ new Set();
   for (const fcId of authFcIds) {
-    const requestedAuthConfig = requestedAuthConfigById[fcId];
-    if (!requestedAuthConfig) {
+    const request = requests.get(fcId);
+    if (!request) {
+      logger.warn(
+        `Ignoring credential response '${fcId}': no matching request from this agent.`
+      );
       continue;
     }
-    for (const event of events) {
-      const eventFunctionCalls = getFunctionCalls(event);
-      for (const functionCall of eventFunctionCalls) {
-        if (functionCall.id === fcId && functionCall.name === REQUEST_EUC_FUNCTION_CALL_NAME) {
-          const args = camelCaseKeys(
-            functionCall.args
-          );
-          const functionCallId = args == null ? void 0 : args.functionCallId;
-          if (functionCallId) {
-            if (functionCallId.startsWith(TOOLSET_AUTH_CREDENTIAL_ID_PREFIX)) {
-              continue;
-            }
-            toolsToResume.add(functionCallId);
-          }
-        }
-      }
+    const authConfig = bindCredentialResponse(
+      request.config,
+      authResponses[fcId]
+    );
+    if (!authConfig) {
+      logger.warn(
+        `Ignoring credential response '${fcId}': it carries no credential for the request this agent raised.`
+      );
+      continue;
+    }
+    await new AuthHandler(authConfig).parseAndStoreAuthResponse(state);
+    const functionCallId = (_a = request.args) == null ? void 0 : _a.functionCallId;
+    if (functionCallId && !functionCallId.startsWith(TOOLSET_AUTH_CREDENTIAL_ID_PREFIX)) {
+      toolsToResume.add(functionCallId);
     }
   }
   return toolsToResume;
 }
-class AuthPreprocessor extends BaseLlmRequestProcessor {
+__name(storeAuthAndCollectResumeTargets, "storeAuthAndCollectResumeTargets");
+const _AuthPreprocessor = class _AuthPreprocessor extends BaseLlmRequestProcessor {
   async *runAsync(invocationContext) {
     const agent = invocationContext.agent;
     if (!isLlmAgent(agent)) {
@@ -96,7 +102,7 @@ class AuthPreprocessor extends BaseLlmRequestProcessor {
     const authFcIds = /* @__PURE__ */ new Set();
     const authResponses = {};
     for (const functionCallResponse of responses) {
-      if (functionCallResponse.name !== REQUEST_EUC_FUNCTION_CALL_NAME) {
+      if (functionCallResponse.name !== REQUEST_CREDENTIAL_FUNCTION_CALL_NAME) {
         continue;
       }
       if (functionCallResponse.id) {
@@ -112,7 +118,8 @@ class AuthPreprocessor extends BaseLlmRequestProcessor {
       events,
       authFcIds,
       authResponses,
-      state
+      state,
+      agent.name
     );
     if (toolsToResume.size === 0) {
       return;
@@ -149,7 +156,9 @@ class AuthPreprocessor extends BaseLlmRequestProcessor {
       }
     }
   }
-}
+};
+__name(_AuthPreprocessor, "AuthPreprocessor");
+let AuthPreprocessor = _AuthPreprocessor;
 const AUTH_PREPROCESSOR = new AuthPreprocessor();
 export {
   AUTH_PREPROCESSOR,

package/dist/esm/auth/auth_provider_registry.js

@@ -1,11 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class AuthProviderRegistry {
+const _AuthProviderRegistry = class _AuthProviderRegistry {
   constructor() {
     this.providers = /* @__PURE__ */ new Map();
   }
@@ -27,7 +29,9 @@ class AuthProviderRegistry {
   getProvider(authScheme) {
     return this.providers.get(authScheme.type);
   }
-}
+};
+__name(_AuthProviderRegistry, "AuthProviderRegistry");
+let AuthProviderRegistry = _AuthProviderRegistry;
 export {
   AuthProviderRegistry
 };

package/dist/esm/auth/auth_schemes.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -27,6 +29,7 @@ function getOAuthGrantTypeFromFlow(flow) {
   }
   return void 0;
 }
+__name(getOAuthGrantTypeFromFlow, "getOAuthGrantTypeFromFlow");
 export {
   OAuthGrantType,
   getOAuthGrantTypeFromFlow

package/dist/esm/auth/credential_response_binding.js

@@ -0,0 +1,74 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function readField(source, name) {
+  if (typeof source !== "object" || source === null) {
+    return void 0;
+  }
+  const record = source;
+  if (name in record) {
+    return record[name];
+  }
+  return record[name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`)];
+}
+__name(readField, "readField");
+function readString(source, name) {
+  const value = readField(source, name);
+  return typeof value === "string" ? value : void 0;
+}
+__name(readString, "readString");
+function bindCredential(request, supplied) {
+  var _a;
+  const requested = request.exchangedAuthCredential;
+  if (!((_a = requested == null ? void 0 : requested.oauth2) == null ? void 0 : _a.authUri)) {
+    return supplied;
+  }
+  const suppliedOAuth2 = readField(supplied, "oauth2");
+  const answer = {};
+  const authResponseUri = readString(suppliedOAuth2, "authResponseUri");
+  if (authResponseUri !== void 0) {
+    answer.authResponseUri = authResponseUri;
+  }
+  const authCode = readString(suppliedOAuth2, "authCode");
+  if (authCode !== void 0) {
+    answer.authCode = authCode;
+  }
+  if (authResponseUri === void 0 && authCode === void 0) {
+    return void 0;
+  }
+  return {
+    ...requested,
+    oauth2: { ...requested.oauth2, ...answer }
+  };
+}
+__name(bindCredential, "bindCredential");
+function bindCredentialResponse(request, response) {
+  const { authScheme, credentialKey } = request;
+  if (!authScheme || !credentialKey) {
+    return void 0;
+  }
+  const supplied = readField(response, "exchangedAuthCredential");
+  if (typeof supplied !== "object" || supplied === null) {
+    return void 0;
+  }
+  const exchangedAuthCredential = bindCredential(request, supplied);
+  if (!exchangedAuthCredential) {
+    return void 0;
+  }
+  return {
+    authScheme,
+    credentialKey,
+    rawAuthCredential: request.rawAuthCredential,
+    exchangedAuthCredential
+  };
+}
+__name(bindCredentialResponse, "bindCredentialResponse");
+export {
+  bindCredentialResponse
+};

package/dist/esm/auth/credential_service/in_memory_credential_service.js

@@ -1,11 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class InMemoryCredentialService {
+const _InMemoryCredentialService = class _InMemoryCredentialService {
   constructor() {
     /**
      * A map from app name to a map from user ID to a map from credential key to
@@ -40,7 +42,9 @@ class InMemoryCredentialService {
     }
     return this.credentials[appName][userId];
   }
-}
+};
+__name(_InMemoryCredentialService, "InMemoryCredentialService");
+let InMemoryCredentialService = _InMemoryCredentialService;
 export {
   InMemoryCredentialService
 };

package/dist/esm/auth/credential_service/session_state_credential_service.js

@@ -1,11 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class SessionStateCredentialService {
+const _SessionStateCredentialService = class _SessionStateCredentialService {
   loadCredential(authConfig, toolContext) {
     return Promise.resolve(toolContext.state.get(authConfig.credentialKey));
   }
@@ -17,7 +19,9 @@ class SessionStateCredentialService {
       );
     }
   }
-}
+};
+__name(_SessionStateCredentialService, "SessionStateCredentialService");
+let SessionStateCredentialService = _SessionStateCredentialService;
 export {
   SessionStateCredentialService
 };

package/dist/esm/auth/exchanger/base_credential_exchanger.js

@@ -1,12 +1,16 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class CredentialExchangeError extends Error {
-}
+const _CredentialExchangeError = class _CredentialExchangeError extends Error {
+};
+__name(_CredentialExchangeError, "CredentialExchangeError");
+let CredentialExchangeError = _CredentialExchangeError;
 export {
   CredentialExchangeError
 };

package/dist/esm/auth/exchanger/credential_exchanger_registry.js

@@ -1,11 +1,13 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class CredentialExchangerRegistry {
+const _CredentialExchangerRegistry = class _CredentialExchangerRegistry {
   constructor() {
     this.exchangers = {};
   }
@@ -25,7 +27,9 @@ class CredentialExchangerRegistry {
   getExchanger(credentialType) {
     return this.exchangers[credentialType];
   }
-}
+};
+__name(_CredentialExchangerRegistry, "CredentialExchangerRegistry");
+let CredentialExchangerRegistry = _CredentialExchangerRegistry;
 export {
   CredentialExchangerRegistry
 };