@google/adk 1.4.0 → 1.6.0

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

@@ -0,0 +1,114 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../../models/llm_request.js";
+import { logger } from "../../utils/logger.js";
+import {
+  BaseTool
+} from "../base_tool.js";
+class LoadMcpResourceTool extends BaseTool {
+  constructor(mcpToolset) {
+    super({
+      name: "load_mcp_resource",
+      description: `Loads resources from the MCP server.
+
+NOTE: Call when you need access to resources.`
+    });
+    this.mcpToolset = mcpToolset;
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          resource_names: {
+            type: Type.ARRAY,
+            items: {
+              type: Type.STRING
+            },
+            description: "The names of the MCP resources to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const resourceNames = args["resource_names"] || [];
+    return {
+      resource_names: resourceNames,
+      status: "resource contents temporarily inserted and removed. to access these resources, call load_mcp_resource tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendResourcesToLlmRequest(request.llmRequest);
+  }
+  async appendResourcesToLlmRequest(llmRequest) {
+    var _a, _b;
+    try {
+      const availableResourceNames = await this.mcpToolset.listResources();
+      if (availableResourceNames.length > 0) {
+        appendInstructions(llmRequest, [
+          `You have a list of MCP resources:
+${JSON.stringify(
+            availableResourceNames
+          )}
+
+When the user asks questions about any of the resources, you should call the
+\`load_mcp_resource\` function to load the resource. Always call load_mcp_resource
+before answering questions related to the resources.`
+        ]);
+      }
+    } catch (e) {
+      logger.warn(`Failed to list MCP resources: ${e}`);
+    }
+    const lastContent = llmRequest.contents.at(-1);
+    const functionResponse = (_b = (_a = lastContent == null ? void 0 : lastContent.parts) == null ? void 0 : _a[0]) == null ? void 0 : _b.functionResponse;
+    if (!functionResponse || functionResponse.name !== this.name) {
+      return;
+    }
+    const response = functionResponse.response || {};
+    const requestedResourceNames = response["resource_names"] || [];
+    for (const resourceName of requestedResourceNames) {
+      try {
+        const resourceContents = await this.mcpToolset.readResource(resourceName);
+        for (const content of resourceContents) {
+          llmRequest.contents.push({
+            role: "user",
+            parts: [
+              { text: `Resource ${resourceName} is:` },
+              this.mcpContentToPart(content, resourceName)
+            ]
+          });
+        }
+      } catch (e) {
+        logger.warn(`Failed to read MCP resource '${resourceName}': ${e}`);
+      }
+    }
+  }
+  mcpContentToPart(content, resourceName) {
+    var _a;
+    if ("text" in content) {
+      return { text: content.text };
+    }
+    if ("blob" in content) {
+      return {
+        inlineData: {
+          data: content.blob,
+          mimeType: (_a = content.mimeType) != null ? _a : "application/octet-stream"
+        }
+      };
+    }
+    return { text: `[Unknown content type for ${resourceName}]` };
+  }
+}
+export {
+  LoadMcpResourceTool
+};

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

@@ -12,6 +12,11 @@ import {
 import {
   StreamableHTTPClientTransport
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { formatError } from "../../utils/error_utils.js";
+import { logger } from "../../utils/logger.js";
+function logTransportError(err) {
+  logger.error("MCP transport error: " + formatError(err));
+}
 class MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
@@ -20,31 +25,40 @@ class MCPSessionManager {
   async createSession() {
     var _a;
     const client = new Client({ name: "MCPClient", version: "1.0.0" });
-    switch (this.connectionParams.type) {
-      case "StdioConnectionParams":
-        await client.connect(
-          new StdioClientTransport(this.connectionParams.serverParams)
-        );
-        break;
-      case "StreamableHTTPConnectionParams": {
-        const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
-        if (!options.requestInit && this.connectionParams.header !== void 0) {
-          options.requestInit = {
-            headers: this.connectionParams.header
-          };
+    try {
+      switch (this.connectionParams.type) {
+        case "StdioConnectionParams": {
+          const transport = new StdioClientTransport(
+            this.connectionParams.serverParams
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
         }
-        await client.connect(
-          new StreamableHTTPClientTransport(
+        case "StreamableHTTPConnectionParams": {
+          const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
+          if (!options.requestInit && this.connectionParams.header !== void 0) {
+            options.requestInit = {
+              headers: this.connectionParams.header
+            };
+          }
+          const transport = new StreamableHTTPClientTransport(
             new URL(this.connectionParams.url),
             options
-          )
-        );
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = this.connectionParams;
-        break;
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
+        }
+        default: {
+          const _exhaustiveCheck = this.connectionParams;
+          break;
+        }
       }
+    } catch (err) {
+      throw new Error("Failed to create MCP session: " + formatError(err), {
+        cause: err
+      });
     }
     this.activeSessions.add(client);
     return client;

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

@@ -48,6 +48,69 @@ class MCPToolset extends BaseToolset {
     );
     return tools;
   }
+  /**
+   * Lists the names of the resources advertised by the MCP server.
+   *
+   * @return The resource names available on the server.
+   */
+  async listResources() {
+    const session = await this.mcpSessionManager.createSession();
+    try {
+      const result = await session.listResources();
+      return result.resources.map((resource) => resource.name);
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
+  }
+  /**
+   * Returns metadata for the resource whose name matches `name`.
+   *
+   * @param name The advertised name of the resource.
+   * @return The matching MCP `Resource`.
+   * @throws If no resource with the given name is advertised by the server.
+   */
+  async getResourceInfo(name) {
+    const session = await this.mcpSessionManager.createSession();
+    let result;
+    try {
+      result = await session.listResources();
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
+    const resource = result.resources.find(
+      (candidate) => candidate.name === name
+    );
+    if (!resource) {
+      throw new Error(`Resource with name '${name}' not found.`);
+    }
+    return resource;
+  }
+  /**
+   * Reads the contents of the named resource from the MCP server.
+   *
+   * The resource name is resolved to a URI via {@link getResourceInfo} before
+   * reading. Binary contents are returned base64-encoded, exactly as provided
+   * by the server (never decoded and re-encoded).
+   *
+   * @param name The advertised name of the resource to read.
+   * @return The resource contents (text and/or base64-encoded binary).
+   * @throws If the resource is unknown or has no URI.
+   */
+  async readResource(name) {
+    const resourceInfo = await this.getResourceInfo(name);
+    if (!resourceInfo.uri) {
+      throw new Error(`Resource '${name}' has no URI.`);
+    }
+    const session = await this.mcpSessionManager.createSession();
+    try {
+      const result = await session.readResource({
+        uri: resourceInfo.uri
+      });
+      return result.contents;
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
+  }
   async close() {
     const sessions = this.mcpSessionManager.getActiveSessions();
     await Promise.allSettled(

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

@@ -62,19 +62,22 @@ let ToolAuthHandler = class {
       rawAuthCredential: this.authCredential,
       credentialKey: this.credentialKey || "default_openapi_key"
     };
-    const credential = this.context.getAuthResponse(authConfig);
-    if (credential) {
-      const exchanger = new AutoAuthCredentialExchanger();
-      const result = await exchanger.exchange({
-        authScheme: this.authScheme,
-        authCredential: credential
-      });
+    const authResponseCredential = this.context.getAuthResponse(authConfig);
+    const credential = authResponseCredential != null ? authResponseCredential : this.authCredential;
+    if (!credential) {
+      this.context.requestCredential(authConfig);
+      return { state: "pending" };
+    }
+    const exchanger = new AutoAuthCredentialExchanger();
+    const result = await exchanger.exchange({
+      authScheme: this.authScheme,
+      authCredential: credential
+    });
+    if (authResponseCredential || result.wasExchanged) {
       const key = store.getCredentialKey(this.authScheme);
       store.storeCredential(key, result.credential);
-      return { state: "done", authCredential: result.credential };
     }
-    this.context.requestCredential(authConfig);
-    return { state: "pending" };
+    return { state: "done", authCredential: result.credential };
   }
 };
 __decorateClass([

package/dist/esm/tools/request_input_tool.js

@@ -0,0 +1,26 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+import { LongRunningFunctionTool } from "./long_running_tool.js";
+const requestInputTool = new LongRunningFunctionTool({
+  name: "adk_request_input",
+  description: "Presents a custom message to the user and awaits unstructured or structured input.",
+  parameters: z.object({
+    message: z.string().describe("The prompt for the user."),
+    responseSchema: z.record(z.string(), z.unknown()).optional().describe("Expected schema of the response.")
+  }),
+  execute: async (input, context) => {
+    if (context) {
+      context.actions.skipSummarization = true;
+    }
+    return null;
+  }
+});
+export {
+  requestInputTool
+};

package/dist/esm/tools/skill/run_skill_inline_script_tool.js

@@ -21,6 +21,15 @@ import { CodeExecutionLanguage } from "../../code_executors/code_execution_utils
 import { experimental } from "../../utils/experimental.js";
 import { materializeFiles } from "../../utils/file_utils.js";
 import { BaseTool } from "../base_tool.js";
+var RunSkillInlineScriptErrorCode = /* @__PURE__ */ ((RunSkillInlineScriptErrorCode2) => {
+  RunSkillInlineScriptErrorCode2["MISSING_SCRIPT_CONTENT"] = "MISSING_SCRIPT_CONTENT";
+  RunSkillInlineScriptErrorCode2["MISSING_LANGUAGE"] = "MISSING_LANGUAGE";
+  RunSkillInlineScriptErrorCode2["NO_CODE_EXECUTOR"] = "NO_CODE_EXECUTOR";
+  RunSkillInlineScriptErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
+  RunSkillInlineScriptErrorCode2["CONFIRMATION_REJECTED"] = "CONFIRMATION_REJECTED";
+  return RunSkillInlineScriptErrorCode2;
+})(RunSkillInlineScriptErrorCode || {});
+const REQUIRE_CONFIRMATION_MESSAGE = "This tool call needs external confirmation before completion.";
 let RunSkillInlineScriptTool = class extends BaseTool {
   constructor(toolset) {
     super({
@@ -70,13 +79,13 @@ let RunSkillInlineScriptTool = class extends BaseTool {
     if (!inlineScriptContent) {
       return {
         error: "Script content is required.",
-        errorCode: "MISSING_SCRIPT_CONTENT"
+        errorCode: "MISSING_SCRIPT_CONTENT" /* MISSING_SCRIPT_CONTENT */
       };
     }
     if (!language) {
       return {
         error: "Language is required.",
-        errorCode: "MISSING_LANGUAGE"
+        errorCode: "MISSING_LANGUAGE" /* MISSING_LANGUAGE */
       };
     }
     let codeExecutor = (_a = this.toolset) == null ? void 0 : _a.codeExecutor;
@@ -89,9 +98,17 @@ let RunSkillInlineScriptTool = class extends BaseTool {
     if (!codeExecutor) {
       return {
         error: "No code executor configured.",
-        errorCode: "NO_CODE_EXECUTOR"
+        errorCode: "NO_CODE_EXECUTOR" /* NO_CODE_EXECUTOR */
       };
     }
+    const confirmationResult = this.enforceConfirmation(
+      toolContext,
+      inlineScriptContent,
+      language
+    );
+    if (confirmationResult) {
+      return confirmationResult;
+    }
     try {
       const result = await codeExecutor.executeCode({
         invocationContext: toolContext.invocationContext,
@@ -107,14 +124,46 @@ let RunSkillInlineScriptTool = class extends BaseTool {
     } catch (e) {
       return {
         error: `Failed to execute inline script: ${e.message}`,
-        errorCode: "EXECUTION_ERROR"
+        errorCode: "EXECUTION_ERROR" /* EXECUTION_ERROR */
+      };
+    }
+  }
+  /**
+   * Enforces a human-in-the-loop confirmation gate before executing an inline
+   * script, using the repo's standard tool-confirmation mechanism.
+   *
+   * - When no confirmation has been provided yet, a confirmation is requested
+   *   (surfacing the language and script that would run) and an intermediate
+   *   result is returned so the tool call pauses until the client responds.
+   * - When a confirmation exists but was not confirmed, a rejection error is
+   *   returned and execution is refused.
+   * - When the confirmation is confirmed, `undefined` is returned to allow the
+   *   caller to proceed with execution.
+   */
+  enforceConfirmation(toolContext, scriptContent, language) {
+    const confirmation = toolContext.toolConfirmation;
+    if (!confirmation) {
+      toolContext.requestConfirmation({
+        hint: `Confirmation is required before executing an inline skill script. The agent requested to run the following ${language} script in the code executor. Only approve if you trust its contents:
+
+` + scriptContent,
+        payload: { language, scriptContent }
+      });
+      return { partial: REQUIRE_CONFIRMATION_MESSAGE };
+    }
+    if (!confirmation.confirmed) {
+      return {
+        error: "Inline script execution was not confirmed and was rejected.",
+        errorCode: "CONFIRMATION_REJECTED" /* CONFIRMATION_REJECTED */
       };
     }
+    return void 0;
   }
 };
 RunSkillInlineScriptTool = __decorateClass([
   experimental
 ], RunSkillInlineScriptTool);
 export {
+  RunSkillInlineScriptErrorCode,
   RunSkillInlineScriptTool
 };

package/dist/esm/tools/skill/skill_toolset.js

@@ -55,9 +55,11 @@ let SkillToolset = class extends BaseToolset {
       new ListSkillsTool(this),
       new LoadSkillTool(this),
       new LoadSkillResourceTool(this),
-      new RunSkillScriptTool(this),
-      new RunSkillInlineScriptTool(this)
+      new RunSkillScriptTool(this)
     ];
+    if (options.allowInlineScripts) {
+      this.tools.push(new RunSkillInlineScriptTool(this));
+    }
     if (this.registry) {
       this.tools.push(new SearchSkillsTool(this));
     }

package/dist/esm/utils/branch_trie.js

@@ -0,0 +1,13 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isSegmentPrefix(currentBranch, targetBranch) {
+  return !targetBranch || targetBranch === currentBranch || !!currentBranch && currentBranch.startsWith(`${targetBranch}.`);
+}
+export {
+  isSegmentPrefix
+};

package/dist/esm/utils/crypto_shim.js

@@ -0,0 +1,15 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function randomUUID() {
+  throw new Error(
+    "randomUUID: no cryptographically secure source of randomness is available. Neither crypto.randomUUID() nor crypto.getRandomValues() is present in this environment."
+  );
+}
+export {
+  randomUUID
+};

package/dist/esm/utils/env_aware_utils.js

@@ -5,27 +5,29 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { randomUUID as nodeRandomUUID } from "node:crypto";
 function isBrowser() {
   return typeof window !== "undefined";
 }
-const UUID_MASK = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
 function randomUUID() {
-  var _a;
+  var _a, _b;
   if ((_a = globalThis.crypto) == null ? void 0 : _a.randomUUID) {
     return globalThis.crypto.randomUUID();
   }
-  let uuid = "";
-  for (let i = 0; i < UUID_MASK.length; i++) {
-    const randomValue = Math.random() * 16 | 0;
-    if (UUID_MASK[i] === "x") {
-      uuid += randomValue.toString(16);
-    } else if (UUID_MASK[i] === "y") {
-      uuid += (randomValue & 3 | 8).toString(16);
-    } else {
-      uuid += UUID_MASK[i];
-    }
+  if ((_b = globalThis.crypto) == null ? void 0 : _b.getRandomValues) {
+    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+    return [
+      hex.slice(0, 4),
+      hex.slice(4, 6),
+      hex.slice(6, 8),
+      hex.slice(8, 10),
+      hex.slice(10, 16)
+    ].map((group) => group.join("")).join("-");
   }
-  return uuid;
+  return nodeRandomUUID();
 }
 function base64Encode(data) {
   if (isBrowser()) {

package/dist/esm/utils/error_utils.js

@@ -0,0 +1,92 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MAX_RESPONSE_BODY_LENGTH = 1e3;
+const TRUNCATION_MARKER = "... [truncated]";
+const UNKNOWN_ERROR = "Unknown error";
+const MIN_HTTP_STATUS = 100;
+const MAX_HTTP_STATUS = 599;
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function truncateBody(body) {
+  return body.length > MAX_RESPONSE_BODY_LENGTH ? body.slice(0, MAX_RESPONSE_BODY_LENGTH) + TRUNCATION_MARKER : body;
+}
+function baseMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return String(err);
+}
+function extractHttpDetails(err) {
+  var _a, _b;
+  const record = asRecord(err);
+  if (record === void 0) {
+    return void 0;
+  }
+  const response = asRecord(record["response"]);
+  const rawStatus = (_b = (_a = record["status"]) != null ? _a : record["code"]) != null ? _b : response == null ? void 0 : response["status"];
+  const status = typeof rawStatus === "number" && rawStatus >= MIN_HTTP_STATUS && rawStatus <= MAX_HTTP_STATUS ? rawStatus : void 0;
+  const statusText = firstString(
+    record["statusText"],
+    response == null ? void 0 : response["statusText"]
+  );
+  const body = firstString(
+    response == null ? void 0 : response["data"],
+    response == null ? void 0 : response["body"],
+    response == null ? void 0 : response["text"]
+  );
+  if (status === void 0 && body === void 0) {
+    return void 0;
+  }
+  const head = status === void 0 ? "HTTP error" : `HTTP ${status}${statusText === void 0 ? "" : ` ${statusText}`}`;
+  return body === void 0 ? head : `${head}: ${truncateBody(body)}`;
+}
+function formatErrorRecursive(err, seen) {
+  var _a;
+  if (err === null || err === void 0) {
+    return UNKNOWN_ERROR;
+  }
+  if (typeof err === "object") {
+    if (seen.has(err)) {
+      return baseMessage(err);
+    }
+    seen.add(err);
+  }
+  if (err instanceof AggregateError && err.errors.length > 0) {
+    return err.errors.map((sub) => formatErrorRecursive(sub, seen)).join(" | ");
+  }
+  const http = extractHttpDetails(err);
+  const base = baseMessage(err);
+  const cause = (_a = asRecord(err)) == null ? void 0 : _a["cause"];
+  const causeMessage = cause !== void 0 ? formatErrorRecursive(cause, seen) : void 0;
+  let message = base.length > 0 ? base : UNKNOWN_ERROR;
+  if (http !== void 0) {
+    message = `${message} (${http})`;
+  }
+  if (causeMessage !== void 0 && http === void 0 && !message.includes(causeMessage)) {
+    message = `${message}: ${causeMessage}`;
+  }
+  return message;
+}
+function formatError(err) {
+  return formatErrorRecursive(err, /* @__PURE__ */ new Set());
+}
+export {
+  formatError
+};

package/dist/esm/utils/file_utils.js

@@ -7,12 +7,15 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+function isInsideDir(resolvedPath, resolvedBaseDir) {
+  return resolvedPath === resolvedBaseDir || resolvedPath.startsWith(resolvedBaseDir + path.sep);
+}
 async function materializeFiles(files, dir = process.cwd()) {
   const resolvedBaseDir = path.resolve(dir);
   const createdFiles = [];
   for (const file of files) {
     const fullPath = path.resolve(dir, file.name);
-    if (!fullPath.startsWith(resolvedBaseDir)) {
+    if (!isInsideDir(fullPath, resolvedBaseDir)) {
       throw new Error(
         `Path traversal detected: ${file.name} resolves outside of ${dir}`
       );
@@ -34,7 +37,7 @@ async function materializeFiles(files, dir = process.cwd()) {
         break;
       }
     }
-    if (!finalPath.startsWith(resolvedBaseDir)) {
+    if (!isInsideDir(finalPath, resolvedBaseDir)) {
       throw new Error(
         `Path traversal detected: ${file.name} resolves outside of ${dir}`
       );

package/dist/esm/utils/output_schema_utils.js

@@ -0,0 +1,15 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isGemini2OrAbove } from "./model_name.js";
+import { getGoogleLlmVariant, GoogleLLMVariant } from "./variant_utils.js";
+function canUseOutputSchemaWithTools(modelString) {
+  return getGoogleLlmVariant() === GoogleLLMVariant.VERTEX_AI && isGemini2OrAbove(modelString);
+}
+export {
+  canUseOutputSchemaWithTools
+};

package/dist/esm/utils/streaming_utils.js

@@ -9,7 +9,7 @@ import {
   FinishReason
 } from "@google/genai";
 import { JSONPath } from "jsonpath-plus";
-import { generateClientFunctionCallId } from "../agents/functions.js";
+import { generateClientFunctionCallId } from "../events/event.js";
 import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
 import { createLlmResponse } from "../models/llm_response.js";
 const UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);

package/dist/esm/utils/vertex_ai_utils.js

@@ -6,6 +6,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * SPDX-License-Identifier: Apache-2.0
  */
 import { getBooleanEnvVar } from "./env_aware_utils.js";
+const EXPRESS_MODE_UNSUPPORTED_MESSAGE = "Vertex AI Express Mode (expressModeApiKey / GOOGLE_API_KEY) is not supported: the @google-cloud/vertexai Agent Engine client cannot send an API key. Provide projectId and location (with Application Default Credentials), or inject a preconfigured client.";
 function getExpressModeApiKey(project, location, expressModeApiKey) {
   if ((project || location) && expressModeApiKey) {
     throw new Error(
@@ -18,5 +19,6 @@ function getExpressModeApiKey(project, location, expressModeApiKey) {
   return void 0;
 }
 export {
+  EXPRESS_MODE_UNSUPPORTED_MESSAGE,
   getExpressModeApiKey
 };

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "1.4.0";
+const version = "1.6.0";
 export {
   version
 };