@google/adk 2.2.0 → 2.3.0

package/dist/cjs/tools/langchain_tool.js

@@ -0,0 +1,172 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var langchain_tool_exports = {};
+__export(langchain_tool_exports, {
+  LangchainTool: () => LangchainTool,
+  isLangchainTool: () => isLangchainTool
+});
+module.exports = __toCommonJS(langchain_tool_exports);
+var import_schema = require("../utils/schema.js");
+var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
+var import_variant_utils = require("../utils/variant_utils.js");
+var import_function_tool = require("./function_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const LANGCHAIN_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.langchainTool");
+function isLangchainTool(obj) {
+  return typeof obj === "object" && obj !== null && LANGCHAIN_TOOL_SIGNATURE_SYMBOL in obj && obj[LANGCHAIN_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isLangchainTool, "isLangchainTool");
+function isLangchainToolConfig(value) {
+  return typeof value === "object" && value !== null && "tool" in value && typeof value.tool === "object" && value.tool !== null;
+}
+__name(isLangchainToolConfig, "isLangchainToolConfig");
+function resolveRunnerFunction(tool) {
+  if (typeof tool._run === "function") {
+    return tool._run.bind(tool);
+  }
+  if (typeof tool._call === "function") {
+    return tool._call.bind(tool);
+  }
+  if (typeof tool.invoke === "function") {
+    return tool.invoke.bind(tool);
+  }
+  if (typeof tool.run === "function") {
+    return tool.run.bind(tool);
+  }
+  throw new TypeError(
+    "LangchainTool requires a tool object with a _run, _call, invoke, or run method."
+  );
+}
+__name(resolveRunnerFunction, "resolveRunnerFunction");
+function isStructuredLangchainTool(tool) {
+  return typeof tool._run === "function" || typeof tool._call === "function" || typeof tool.invoke === "function" || tool.argsSchema !== void 0 || tool.schema !== void 0 || tool.args !== void 0;
+}
+__name(isStructuredLangchainTool, "isStructuredLangchainTool");
+function extractLangchainPropertiesMap(tool) {
+  var _a2;
+  if (tool.args && typeof tool.args === "object") {
+    return structuredClone(tool.args);
+  }
+  const schemaSource = (_a2 = tool.argsSchema) != null ? _a2 : tool.schema;
+  if (!schemaSource) {
+    return {};
+  }
+  let rawSchema;
+  if (typeof schemaSource.modelJsonSchema === "function") {
+    rawSchema = schemaSource.modelJsonSchema();
+  } else if (typeof schemaSource.jsonSchema === "function") {
+    rawSchema = schemaSource.jsonSchema();
+  } else if ((0, import_simple_zod_to_json.isZodSchema)(schemaSource)) {
+    rawSchema = structuredClone((0, import_schema.toJsonSchema)(schemaSource));
+  } else {
+    rawSchema = structuredClone(schemaSource);
+  }
+  const properties = rawSchema["properties"] && typeof rawSchema["properties"] === "object" ? structuredClone(
+    rawSchema["properties"]
+  ) : structuredClone(rawSchema);
+  const requiredSet = Array.isArray(rawSchema["required"]) ? new Set(rawSchema["required"]) : void 0;
+  for (const [key, prop] of Object.entries(properties)) {
+    if (!prop || typeof prop !== "object") {
+      continue;
+    }
+    if (Array.isArray(prop["type"])) {
+      const types = prop["type"];
+      delete prop["type"];
+      prop["anyOf"] = types.map((t) => ({ type: t }));
+    } else if (requiredSet !== void 0 && !requiredSet.has(key) && !("default" in prop) && !("anyOf" in prop) && typeof prop["type"] === "string") {
+      const propType = prop["type"];
+      delete prop["type"];
+      prop["anyOf"] = [{ type: propType }, { type: "null" }];
+    }
+  }
+  return properties;
+}
+__name(extractLangchainPropertiesMap, "extractLangchainPropertiesMap");
+const _LangchainTool = class _LangchainTool extends (_b = import_function_tool.FunctionTool, _a = LANGCHAIN_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor(toolOrConfig, options) {
+    var _a2, _b2, _c, _d;
+    const config = isLangchainToolConfig(toolOrConfig) ? toolOrConfig : {
+      tool: toolOrConfig,
+      name: options == null ? void 0 : options.name,
+      description: options == null ? void 0 : options.description
+    };
+    const runnerFn = resolveRunnerFunction(config.tool);
+    const rawFn = (_c = (_b2 = (_a2 = config.tool._run) != null ? _a2 : config.tool._call) != null ? _b2 : config.tool.invoke) != null ? _c : config.tool.run;
+    const resolvedName = config.name || config.tool.name || (rawFn == null ? void 0 : rawFn.name) || "langchain_tool";
+    const resolvedDescription = config.description || config.tool.description || "";
+    const schemaCandidate = (_d = config.tool.argsSchema) != null ? _d : config.tool.schema;
+    super({
+      name: resolvedName,
+      description: resolvedDescription,
+      parameters: (0, import_simple_zod_to_json.isZodObject)(schemaCandidate) ? schemaCandidate : void 0,
+      execute: /* @__PURE__ */ __name(async (args, toolContext) => {
+        return await runnerFn(
+          args != null ? args : {},
+          toolContext
+        );
+      }, "execute")
+    });
+    /** A unique symbol to identify ADK LangchainTool class. */
+    this[_a] = true;
+    this.tool = config.tool;
+  }
+  /**
+   * Builds the `FunctionDeclaration` for the wrapped LangChain tool.
+   */
+  _getDeclaration() {
+    var _a2, _b2, _c;
+    if (isStructuredLangchainTool(this.tool)) {
+      const propertiesMap = extractLangchainPropertiesMap(this.tool);
+      const rawFn = (_c = (_b2 = (_a2 = this.tool._run) != null ? _a2 : this.tool._call) != null ? _b2 : this.tool.invoke) != null ? _c : this.tool.run;
+      return (0, import_function_tool.buildFunctionDeclarationForLangchain)(
+        this.apiVariant === import_variant_utils.GoogleLLMVariant.VERTEX_AI,
+        this.name,
+        this.description,
+        rawFn,
+        propertiesMap
+      );
+    }
+    return (0, import_function_tool.buildFunctionDeclarationUtil)(
+      this.apiVariant === import_variant_utils.GoogleLLMVariant.VERTEX_AI,
+      this.name,
+      this.description,
+      this.tool.run,
+      { properties: extractLangchainPropertiesMap(this.tool) }
+    );
+  }
+};
+__name(_LangchainTool, "LangchainTool");
+let LangchainTool = _LangchainTool;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LangchainTool,
+  isLangchainTool
+});

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

@@ -9,6 +9,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -20,7 +24,13 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var mcp_exports = {};
+__export(mcp_exports, {
+  genaiSchemaToJsonSchema: () => import_genai_schema_to_json.genaiSchemaToJsonSchema,
+  toGeminiSchema: () => import_gemini_schema_util.toGeminiSchema
+});
 module.exports = __toCommonJS(mcp_exports);
+var import_gemini_schema_util = require("../../utils/gemini_schema_util.js");
+var import_genai_schema_to_json = require("../../utils/genai_schema_to_json.js");
 __reExport(mcp_exports, require("./load_mcp_resource_tool.js"), module.exports);
 __reExport(mcp_exports, require("./mcp_session_manager.js"), module.exports);
 __reExport(mcp_exports, require("./mcp_tool.js"), module.exports);
@@ -32,6 +42,8 @@ __reExport(mcp_exports, require("./mcp_toolset.js"), module.exports);
  */
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  genaiSchemaToJsonSchema,
+  toGeminiSchema,
   ...require("./load_mcp_resource_tool.js"),
   ...require("./mcp_session_manager.js"),
   ...require("./mcp_tool.js"),

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

@@ -67,6 +67,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: (0, import_client_labels.mergeTrackingHeaders)(callerHeaders)
+    }
+  };
+}
+__name(buildSseTransportOptions, "buildSseTransportOptions");
 const _MCPSessionManager = class _MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
@@ -105,6 +117,19 @@ const _MCPSessionManager = class _MCPSessionManager {
           await client.connect(transport);
           break;
         }
+        case "SseConnectionParams": {
+          const { SSEClientTransport } = await (0, import_optional_peer.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/cjs/tools/openapi_tool/auth/auth_helpers.js

@@ -165,12 +165,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/cjs/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js

@@ -37,14 +37,48 @@ __export(auto_auth_credential_exchanger_exports, {
 });
 module.exports = __toCommonJS(auto_auth_credential_exchanger_exports);
 var import_auth_credential = require("../../../../auth/auth_credential.js");
+var import_auth_schemes = require("../../../../auth/auth_schemes.js");
 var import_oauth2_credential_exchanger = require("../../../../auth/oauth2/oauth2_credential_exchanger.js");
 var import_experimental = require("../../../../utils/experimental.js");
+var import_oauth2_exchanger = require("./oauth2_exchanger.js");
 var import_service_account_exchanger = require("./service_account_exchanger.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+function isPendingAuthorizationCode(authScheme, authCredential) {
+  var _a, _b, _c;
+  return !!authScheme && (0, import_oauth2_credential_exchanger.determineGrantType)(authScheme) === import_auth_schemes.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 import_oauth2_credential_exchanger.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 = (0, import_oauth2_exchanger.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
@@ -52,14 +86,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(
       import_auth_credential.AuthCredentialTypes.OAUTH2,
-      new import_oauth2_credential_exchanger.OAuth2CredentialExchanger()
+      createDefaultOAuth2Exchanger()
     );
     this.exchangers.set(
       import_auth_credential.AuthCredentialTypes.OPEN_ID_CONNECT,
-      new import_oauth2_credential_exchanger.OAuth2CredentialExchanger()
+      createDefaultOAuth2Exchanger()
     );
     this.exchangers.set(
       import_auth_credential.AuthCredentialTypes.SERVICE_ACCOUNT,

package/dist/cjs/tools/openapi_tool/auth/credential_exchangers/oauth2_exchanger.js

@@ -40,6 +40,7 @@ __export(oauth2_exchanger_exports, {
 });
 module.exports = __toCommonJS(oauth2_exchanger_exports);
 var import_auth_credential = require("../../../../auth/auth_credential.js");
+var import_auth_schemes = require("../../../../auth/auth_schemes.js");
 var import_experimental = require("../../../../utils/experimental.js");
 /**
  * @license
@@ -52,7 +53,7 @@ function checkSchemeCredentialType(authScheme, authCredential) {
       "auth_credential is empty. Please create AuthCredential using OAuth2Auth."
     );
   }
-  if (authScheme.type !== "openIdConnect" && authScheme.type !== "oauth2") {
+  if (authScheme.type !== import_auth_schemes.AuthSchemeType.OPEN_ID_CONNECT && authScheme.type !== import_auth_schemes.AuthSchemeType.OAUTH2) {
     throw new Error(
       `Invalid security scheme, expect AuthSchemeType.openIdConnect or AuthSchemeType.oauth2 auth scheme, but got ${authScheme.type}`
     );

package/dist/cjs/tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.js

@@ -37,6 +37,7 @@ __export(service_account_exchanger_exports, {
 });
 module.exports = __toCommonJS(service_account_exchanger_exports);
 var import_google_auth_library = require("google-auth-library");
+var import_node_crypto = require("node:crypto");
 var import_auth_credential = require("../../../../auth/auth_credential.js");
 var import_experimental = require("../../../../utils/experimental.js");
 var import_base_auth_credential_exchanger = require("./base_auth_credential_exchanger.js");
@@ -47,6 +48,83 @@ var import_base_auth_credential_exchanger = require("./base_auth_credential_exch
  */
 const DEFAULT_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"];
 const MISSING_SERVICE_ACCOUNT_CREDENTIALS = "Service account credentials are missing. Please provide them, or set `useDefaultCredential: true` to use application default credentials in a hosted service like Cloud Run.";
+const GOOGLE_TOKEN_URI = "https://oauth2.googleapis.com/token";
+const JWT_BEARER_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:jwt-bearer";
+const ASSERTION_LIFETIME_SECONDS = 3600;
+const TOKEN_REQUEST_TIMEOUT_MS = 3e4;
+function hasCustomTokenUri(creds) {
+  return !!creds.tokenUri && creds.tokenUri !== GOOGLE_TOKEN_URI;
+}
+__name(hasCustomTokenUri, "hasCustomTokenUri");
+function base64UrlJson(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+__name(base64UrlJson, "base64UrlJson");
+function signJwtBearerAssertion(creds, scopes, issuedAt) {
+  const header = {
+    alg: "RS256",
+    typ: "JWT",
+    ...creds.privateKeyId ? { kid: creds.privateKeyId } : {}
+  };
+  const payload = {
+    iss: creds.clientEmail,
+    scope: scopes.join(" "),
+    aud: GOOGLE_TOKEN_URI,
+    iat: issuedAt,
+    exp: issuedAt + ASSERTION_LIFETIME_SECONDS
+  };
+  const signingInput = `${base64UrlJson(header)}.${base64UrlJson(payload)}`;
+  const signature = (0, import_node_crypto.createSign)("RSA-SHA256").update(signingInput).sign(creds.privateKey, "base64url");
+  return `${signingInput}.${signature}`;
+}
+__name(signJwtBearerAssertion, "signJwtBearerAssertion");
+async function readTokenErrorDetail(response) {
+  try {
+    const body = await response.json();
+    if (typeof body !== "object" || body === null) {
+      return void 0;
+    }
+    const parts = [];
+    if ("error" in body && typeof body.error === "string" && body.error.length > 0) {
+      parts.push(body.error);
+    }
+    if ("error_description" in body && typeof body.error_description === "string" && body.error_description.length > 0) {
+      parts.push(body.error_description);
+    }
+    return parts.length > 0 ? parts.join(": ") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(readTokenErrorDetail, "readTokenErrorDetail");
+async function requestJwtBearerToken(creds, scopes) {
+  const assertion = signJwtBearerAssertion(
+    creds,
+    scopes,
+    Math.floor(Date.now() / 1e3)
+  );
+  const response = await fetch(creds.tokenUri, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: JWT_BEARER_GRANT_TYPE,
+      assertion
+    }),
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    const detail = await readTokenErrorDetail(response);
+    throw new Error(
+      detail ? `Token endpoint responded with HTTP ${response.status}: ${detail}` : `Token endpoint responded with HTTP ${response.status}`
+    );
+  }
+  const body = await response.json();
+  if (typeof body === "object" && body !== null && "access_token" in body && typeof body.access_token === "string") {
+    return body.access_token;
+  }
+  return void 0;
+}
+__name(requestJwtBearerToken, "requestJwtBearerToken");
 let ServiceAccountCredentialExchanger = class {
   async exchange(params) {
     const { authCredential } = params;
@@ -87,21 +165,27 @@ let ServiceAccountCredentialExchanger = class {
     }
   }
   async exchangeForExplicitCredential(saConfig) {
+    var _a;
     const creds = saConfig.serviceAccountCredential;
     if (!creds) {
       throw new import_base_auth_credential_exchanger.AuthCredentialMissingError(MISSING_SERVICE_ACCOUNT_CREDENTIALS);
     }
     try {
-      const client = new import_google_auth_library.JWT({
-        email: creds.clientEmail,
-        key: creds.privateKey,
-        keyId: creds.privateKeyId,
-        projectId: creds.projectId,
-        universeDomain: creds.universeDomain,
-        scopes: saConfig.scopes
-      });
-      const tokens = await client.authorize();
-      const token = tokens.access_token;
+      let token;
+      if (hasCustomTokenUri(creds)) {
+        token = await requestJwtBearerToken(creds, (_a = saConfig.scopes) != null ? _a : []);
+      } else {
+        const client = new import_google_auth_library.JWT({
+          email: creds.clientEmail,
+          key: creds.privateKey,
+          keyId: creds.privateKeyId,
+          projectId: creds.projectId,
+          universeDomain: creds.universeDomain,
+          scopes: saConfig.scopes
+        });
+        const tokens = await client.authorize();
+        token = tokens.access_token;
+      }
       if (!token) {
         throw new Error("Failed to get access token from explicit credentials");
       }

package/dist/cjs/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js

@@ -50,6 +50,16 @@ var import_base_auth_credential_exchanger = require("../auth/credential_exchange
  * SPDX-License-Identifier: Apache-2.0
  */
 const DEFAULT_CREDENTIAL_KEY = "default_openapi_key";
+const INTERACTIVE_CREDENTIAL_TYPES = /* @__PURE__ */ new Set([
+  import_auth_credential.AuthCredentialTypes.OAUTH2,
+  import_auth_credential.AuthCredentialTypes.OPEN_ID_CONNECT
+]);
+function isMissingInteractiveToken(result) {
+  var _a, _b;
+  const { credential, wasExchanged } = result;
+  return !wasExchanged && INTERACTIVE_CREDENTIAL_TYPES.has(credential.authType) && !credential.http && !((_a = credential.oauth2) == null ? void 0 : _a.accessToken) && !((_b = credential.oauth2) == null ? void 0 : _b.refreshToken);
+}
+__name(isMissingInteractiveToken, "isMissingInteractiveToken");
 const _ToolContextCredentialStore = class _ToolContextCredentialStore {
   constructor(context) {
     this.context = context;
@@ -165,7 +175,8 @@ let ToolAuthHandler = class {
     };
   }
   /**
-   * Exchanges `credential`, or returns `undefined` when the exchange failed.
+   * Exchanges `credential`, or returns `undefined` when the exchange failed or
+   * produced an interactive credential that still holds no token.
    *
    * An exchange failure is transient far more often than it is fatal, so it
    * becomes a `pending` result the client can resume from rather than an
@@ -175,10 +186,11 @@ let ToolAuthHandler = class {
     var _a;
     const exchanger = (_a = this.credentialExchanger) != null ? _a : new import_auto_auth_credential_exchanger.AutoAuthCredentialExchanger();
     try {
-      return await exchanger.exchange({
+      const result = await exchanger.exchange({
         authScheme: this.authScheme,
         authCredential: credential
       });
+      return isMissingInteractiveToken(result) ? void 0 : result;
     } catch (e) {
       import_logger.logger.error(
         `Failed to exchange credential: ${e instanceof Error ? e.message : e}`

package/dist/cjs/tools/retrieval/base_retrieval_tool.js

@@ -25,7 +25,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var base_retrieval_tool_exports = {};
 __export(base_retrieval_tool_exports, {
-  BaseRetrievalTool: () => BaseRetrievalTool
+  BaseRetrievalTool: () => BaseRetrievalTool,
+  isBaseRetrievalTool: () => isBaseRetrievalTool
 });
 module.exports = __toCommonJS(base_retrieval_tool_exports);
 var import_genai = require("@google/genai");
@@ -35,7 +36,20 @@ var import_base_tool = require("../base_tool.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const _BaseRetrievalTool = class _BaseRetrievalTool extends import_base_tool.BaseTool {
+var _a, _b;
+const BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.baseRetrievalTool"
+);
+function isBaseRetrievalTool(obj) {
+  return typeof obj === "object" && obj !== null && BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isBaseRetrievalTool, "isBaseRetrievalTool");
+const _BaseRetrievalTool = class _BaseRetrievalTool extends (_b = import_base_tool.BaseTool, _a = BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor() {
+    super(...arguments);
+    /** Unique symbol to identify `BaseRetrievalTool` class. */
+    this[_a] = true;
+  }
   _getDeclaration() {
     return {
       name: this.name,
@@ -56,5 +70,6 @@ __name(_BaseRetrievalTool, "BaseRetrievalTool");
 let BaseRetrievalTool = _BaseRetrievalTool;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseRetrievalTool
+  BaseRetrievalTool,
+  isBaseRetrievalTool
 });

package/dist/cjs/tools/toolbox_tool.js

@@ -0,0 +1,108 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toolbox_tool_exports = {};
+__export(toolbox_tool_exports, {
+  ToolboxTool: () => ToolboxTool,
+  isToolboxTool: () => isToolboxTool
+});
+module.exports = __toCommonJS(toolbox_tool_exports);
+var import_langchain_tool = require("./langchain_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const TOOLBOX_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.toolboxTool");
+function isToolboxTool(obj) {
+  return typeof obj === "object" && obj !== null && TOOLBOX_TOOL_SIGNATURE_SYMBOL in obj && obj[TOOLBOX_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isToolboxTool, "isToolboxTool");
+function createUnconfiguredToolboxClient(url) {
+  const endpoint = url != null ? url : "unspecified URL";
+  const throwMissingClient = /* @__PURE__ */ __name(() => {
+    throw new Error(
+      `ToolboxTool requires a ToolboxClientLike instance (for endpoint "${endpoint}"). Pass {url, client} to the ToolboxTool constructor.`
+    );
+  }, "throwMissingClient");
+  return {
+    loadTool: throwMissingClient,
+    loadToolset: throwMissingClient
+  };
+}
+__name(createUnconfiguredToolboxClient, "createUnconfiguredToolboxClient");
+_a = TOOLBOX_TOOL_SIGNATURE_SYMBOL;
+const _ToolboxTool = class _ToolboxTool {
+  constructor(urlOrOptions) {
+    /** A unique symbol to identify ADK ToolboxTool class. */
+    this[_a] = true;
+    var _a2;
+    if (typeof urlOrOptions === "string") {
+      this.url = urlOrOptions;
+      this.toolboxClient = createUnconfiguredToolboxClient(urlOrOptions);
+    } else {
+      this.url = urlOrOptions.url;
+      this.toolboxClient = (_a2 = urlOrOptions.client) != null ? _a2 : createUnconfiguredToolboxClient(urlOrOptions.url);
+    }
+  }
+  /**
+   * Loads a single tool from the Toolbox client and wraps it in a
+   * {@link LangchainTool}.
+   */
+  getTool(toolName) {
+    var _a2, _b, _c;
+    const loader = (_c = (_a2 = this.toolboxClient.loadTool) == null ? void 0 : _a2.bind(this.toolboxClient)) != null ? _c : (_b = this.toolboxClient.load_tool) == null ? void 0 : _b.bind(this.toolboxClient);
+    if (!loader) {
+      throw new Error(
+        "ToolboxClient does not implement loadTool or load_tool."
+      );
+    }
+    const tool = loader(toolName);
+    return new import_langchain_tool.LangchainTool(tool);
+  }
+  /**
+   * Loads a toolset from the Toolbox client and wraps each tool in a
+   * {@link LangchainTool}.
+   */
+  getToolset(toolsetName) {
+    var _a2, _b, _c;
+    const loader = (_c = (_a2 = this.toolboxClient.loadToolset) == null ? void 0 : _a2.bind(this.toolboxClient)) != null ? _c : (_b = this.toolboxClient.load_toolset) == null ? void 0 : _b.bind(this.toolboxClient);
+    if (!loader) {
+      throw new Error(
+        "ToolboxClient does not implement loadToolset or load_toolset."
+      );
+    }
+    const tools = loader(toolsetName);
+    return tools.map((tool) => new import_langchain_tool.LangchainTool(tool));
+  }
+};
+__name(_ToolboxTool, "ToolboxTool");
+let ToolboxTool = _ToolboxTool;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolboxTool,
+  isToolboxTool
+});