@google/adk 1.5.0 → 2.0.0

package/dist/esm/artifacts/file_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 2026 Google LLC
@@ -10,7 +12,7 @@ import * as path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 import { logger } from "../utils/logger.js";
 const USER_NAMESPACE_PREFIX = "user:";
-class FileArtifactService {
+const _FileArtifactService = class _FileArtifactService {
   constructor(rootDirOrUri) {
     try {
       const rootDir = rootDirOrUri.startsWith("file://") ? fileURLToPath(rootDirOrUri) : rootDirOrUri;
@@ -321,7 +323,9 @@ class FileArtifactService {
       return void 0;
     }
   }
-}
+};
+__name(_FileArtifactService, "FileArtifactService");
+let FileArtifactService = _FileArtifactService;
 const SAFE_SEGMENT_RE = /^[a-zA-Z0-9_@-][a-zA-Z0-9_.@-]{0,255}$/;
 function assertSafeSegment(value, label) {
   if (!value || !SAFE_SEGMENT_RE.test(value)) {
@@ -330,6 +334,7 @@ function assertSafeSegment(value, label) {
     );
   }
 }
+__name(assertSafeSegment, "assertSafeSegment");
 function assertInsideRoot(resolvedPath, rootDir, label) {
   const root = path.resolve(rootDir);
   const resolved = path.resolve(resolvedPath);
@@ -339,27 +344,33 @@ function assertInsideRoot(resolvedPath, rootDir, label) {
     );
   }
 }
+__name(assertInsideRoot, "assertInsideRoot");
 function getUserRoot(rootDir, userId) {
   assertSafeSegment(userId, "userId");
   const result = path.join(rootDir, "users", userId);
   assertInsideRoot(result, rootDir, "userRoot");
   return result;
 }
+__name(getUserRoot, "getUserRoot");
 function isUserScoped(sessionId, filename) {
   return !sessionId || filename.startsWith(USER_NAMESPACE_PREFIX);
 }
+__name(isUserScoped, "isUserScoped");
 function getUserArtifactsDir(userRoot) {
   return path.join(userRoot, "artifacts");
 }
+__name(getUserArtifactsDir, "getUserArtifactsDir");
 function getSessionArtifactsDir(baseRoot, sessionId) {
   assertSafeSegment(sessionId, "sessionId");
   const result = path.join(baseRoot, "sessions", sessionId, "artifacts");
   assertInsideRoot(result, baseRoot, "sessionArtifactsDir");
   return result;
 }
+__name(getSessionArtifactsDir, "getSessionArtifactsDir");
 function getVersionsDir(artifactDir) {
   return path.join(artifactDir, "versions");
 }
+__name(getVersionsDir, "getVersionsDir");
 function getArtifactDir(rootDir, userId, sessionId, filename) {
   const userRoot = getUserRoot(rootDir, userId);
   let scopeRoot;
@@ -391,6 +402,7 @@ function getArtifactDir(rootDir, userId, sessionId, filename) {
   }
   return artifactDir;
 }
+__name(getArtifactDir, "getArtifactDir");
 async function getArtifactVersionsFromDir(artifactDir) {
   const versionsDir = getVersionsDir(artifactDir);
   try {
@@ -405,6 +417,7 @@ async function getArtifactVersionsFromDir(artifactDir) {
     return [];
   }
 }
+__name(getArtifactVersionsFromDir, "getArtifactVersionsFromDir");
 async function getCanonicalUri(rootDir, userId, sessionId, filename, version) {
   const artifactDir = await getArtifactDir(
     rootDir,
@@ -421,13 +434,16 @@ async function getCanonicalUri(rootDir, userId, sessionId, filename, version) {
   );
   return pathToFileURL(payloadPath).toString();
 }
+__name(getCanonicalUri, "getCanonicalUri");
 async function writeMetadata(metadataPath, metadata) {
   await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
+__name(writeMetadata, "writeMetadata");
 async function readMetadata(metadataPath) {
   const content = await fs.readFile(metadataPath, "utf-8");
   return JSON.parse(content);
 }
+__name(readMetadata, "readMetadata");
 async function getLatestMetadata(artifactDir) {
   const versions = await getArtifactVersionsFromDir(artifactDir);
   if (versions.length === 0) {
@@ -449,6 +465,7 @@ async function getLatestMetadata(artifactDir) {
     return void 0;
   }
 }
+__name(getLatestMetadata, "getLatestMetadata");
 async function* iterateArtifactDirs(dir) {
   try {
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -470,6 +487,7 @@ async function* iterateArtifactDirs(dir) {
   } catch (_e) {
   }
 }
+__name(iterateArtifactDirs, "iterateArtifactDirs");
 function fileUriToPath(uri) {
   try {
     return fileURLToPath(uri);
@@ -481,9 +499,11 @@ function fileUriToPath(uri) {
     return void 0;
   }
 }
+__name(fileUriToPath, "fileUriToPath");
 function asPosixPath(p) {
   return p.split(path.sep).join("/");
 }
+__name(asPosixPath, "asPosixPath");
 export {
   FileArtifactService,
   assertInsideRoot,

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 = {};
   }
@@ -70,16 +73,14 @@ class InMemoryArtifactService {
     userId,
     sessionId
   }) {
-    const sessionPrefix = `${appName}/${userId}/${sessionId}/`;
-    const usernamespacePrefix = `${appName}/${userId}/user/`;
+    const sessionPrefix = artifactPrefix("session", appName, userId, sessionId);
+    const userPrefix = artifactPrefix("user", appName, userId);
     const filenames = [];
     for (const path in this.artifacts) {
       if (path.startsWith(sessionPrefix)) {
-        const filename = path.replace(sessionPrefix, "");
-        filenames.push(filename);
-      } else if (path.startsWith(usernamespacePrefix)) {
-        const filename = path.replace(usernamespacePrefix, "");
-        filenames.push(filename);
+        filenames.push(decodeURIComponent(path.slice(sessionPrefix.length)));
+      } else if (path.startsWith(userPrefix)) {
+        filenames.push(decodeURIComponent(path.slice(userPrefix.length)));
       }
     }
     return Promise.resolve(filenames.sort());
@@ -147,16 +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 `${appName}/${userId}/user/${filename}`;
+    return `${artifactPrefix("user", appName, userId)}${encodeURIComponent(filename)}`;
   }
-  return `${appName}/${userId}/${sessionId}/${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