@google/adk 2.2.1 → 2.4.0

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_toolset.js

@@ -0,0 +1,174 @@
+/**
+  * @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_toolset_exports = {};
+__export(toolbox_toolset_exports, {
+  ToolboxToolset: () => ToolboxToolset,
+  isToolboxToolset: () => isToolboxToolset
+});
+module.exports = __toCommonJS(toolbox_toolset_exports);
+var import_base_tool = require("./base_tool.js");
+var import_base_toolset = require("./base_toolset.js");
+var import_function_tool = require("./function_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const TOOLBOX_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.toolboxToolset"
+);
+function isToolboxToolset(obj) {
+  return typeof obj === "object" && obj !== null && TOOLBOX_TOOLSET_SIGNATURE_SYMBOL in obj && obj[TOOLBOX_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isToolboxToolset, "isToolboxToolset");
+function createUnconfiguredToolboxToolsetClient(serverUrl) {
+  const throwMissingClient = /* @__PURE__ */ __name(() => {
+    throw new Error(
+      `ToolboxToolset requires a ToolboxToolsetClientLike instance (for endpoint "${serverUrl}"). Pass {serverUrl, client} to the ToolboxToolset constructor.`
+    );
+  }, "throwMissingClient");
+  return {
+    loadTool: throwMissingClient,
+    loadToolset: throwMissingClient,
+    close: /* @__PURE__ */ __name(() => {
+    }, "close")
+  };
+}
+__name(createUnconfiguredToolboxToolsetClient, "createUnconfiguredToolboxToolsetClient");
+function isToolOptionsObject(value) {
+  return typeof value === "object" && value !== null && "execute" in value && typeof value.execute === "function";
+}
+__name(isToolOptionsObject, "isToolOptionsObject");
+function wrapLoadedTool(rawTool, prefix) {
+  var _a2;
+  if ((0, import_base_tool.isBaseTool)(rawTool)) {
+    if (!prefix) {
+      return rawTool;
+    }
+    return Object.assign(
+      Object.create(Object.getPrototypeOf(rawTool)),
+      rawTool,
+      { name: `${prefix}_${rawTool.name}` }
+    );
+  }
+  if (typeof rawTool === "function") {
+    const fn = rawTool;
+    const baseName = fn.name || "toolbox_tool";
+    const name = prefix ? `${prefix}_${baseName}` : baseName;
+    const description = (_a2 = fn.description) != null ? _a2 : "";
+    return new import_function_tool.FunctionTool({
+      name,
+      description,
+      execute: fn
+    });
+  }
+  if (isToolOptionsObject(rawTool)) {
+    const baseTool = new import_function_tool.FunctionTool(rawTool);
+    if (!prefix) {
+      return baseTool;
+    }
+    return new import_function_tool.FunctionTool({
+      ...rawTool,
+      name: `${prefix}_${baseTool.name}`
+    });
+  }
+  throw new TypeError(
+    "Unsupported Toolbox tool shape: expected a BaseTool, ToolOptions object, or function."
+  );
+}
+__name(wrapLoadedTool, "wrapLoadedTool");
+const _ToolboxToolset = class _ToolboxToolset extends (_b = import_base_toolset.BaseToolset, _a = TOOLBOX_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  constructor(serverUrlOrOptions, extraOptions) {
+    var _a2, _b2, _c, _d;
+    const options = typeof serverUrlOrOptions === "string" ? { serverUrl: serverUrlOrOptions, ...extraOptions } : serverUrlOrOptions;
+    if ((!options.toolNames || options.toolNames.length === 0) && !options.toolsetName) {
+      throw new Error("toolNames and toolsetName cannot both be undefined.");
+    }
+    super((_a2 = options.toolFilter) != null ? _a2 : [], options.prefix);
+    /** A unique symbol to identify ADK ToolboxToolset class. */
+    this[_a] = true;
+    this.serverUrl = options.serverUrl;
+    this.toolsetName = options.toolsetName;
+    this.toolNames = options.toolNames;
+    this.authTokenGetters = (_b2 = options.authTokenGetters) != null ? _b2 : {};
+    this.boundParams = (_c = options.boundParams) != null ? _c : {};
+    this.toolboxClient = (_d = options.client) != null ? _d : createUnconfiguredToolboxToolsetClient(this.serverUrl);
+  }
+  /**
+   * Loads the configured toolset and/or individual tools from the Toolbox
+   * client and returns the selected {@link BaseTool} instances.
+   */
+  async getTools(context) {
+    var _a2, _b2, _c, _d, _e, _f;
+    const loadOptions = {
+      authTokenGetters: this.authTokenGetters,
+      boundParams: this.boundParams
+    };
+    const tools = [];
+    if (this.toolsetName) {
+      const loader = (_c = (_a2 = this.toolboxClient.loadToolset) == null ? void 0 : _a2.bind(this.toolboxClient)) != null ? _c : (_b2 = this.toolboxClient.load_toolset) == null ? void 0 : _b2.bind(this.toolboxClient);
+      if (!loader) {
+        throw new Error(
+          "ToolboxClient does not implement loadToolset or load_toolset."
+        );
+      }
+      const loadedToolset = await loader(this.toolsetName, loadOptions);
+      for (const rawTool of loadedToolset) {
+        tools.push(wrapLoadedTool(rawTool, this.prefix));
+      }
+    }
+    if (this.toolNames && this.toolNames.length > 0) {
+      const loader = (_f = (_d = this.toolboxClient.loadTool) == null ? void 0 : _d.bind(this.toolboxClient)) != null ? _f : (_e = this.toolboxClient.load_tool) == null ? void 0 : _e.bind(this.toolboxClient);
+      if (!loader) {
+        throw new Error(
+          "ToolboxClient does not implement loadTool or load_tool."
+        );
+      }
+      const loadedSingleTools = await Promise.all(
+        this.toolNames.map((toolName) => loader(toolName, loadOptions))
+      );
+      for (const rawTool of loadedSingleTools) {
+        tools.push(wrapLoadedTool(rawTool, this.prefix));
+      }
+    }
+    return tools.filter((tool) => this.isToolSelected(tool, context));
+  }
+  /**
+   * Closes the underlying Toolbox client.
+   */
+  async close() {
+    var _a2, _b2;
+    await ((_b2 = (_a2 = this.toolboxClient).close) == null ? void 0 : _b2.call(_a2));
+  }
+};
+__name(_ToolboxToolset, "ToolboxToolset");
+let ToolboxToolset = _ToolboxToolset;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolboxToolset,
+  isToolboxToolset
+});

package/dist/cjs/tools/webmcp/webmcp_toolset.js

@@ -67,20 +67,7 @@ const _WebMCPToolset = class _WebMCPToolset extends import_base_toolset.BaseTool
         document: this.doc
       })
     );
-    const filter = this.toolFilter;
-    if (!filter || Array.isArray(filter) && filter.length === 0) {
-      return tools;
-    }
-    if (Array.isArray(filter)) {
-      return tools.filter((tool) => filter.includes(tool.name));
-    }
-    if (context) {
-      return tools.filter((tool) => filter(tool, context));
-    }
-    import_logger.logger.warn(
-      "WebMCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
-    );
-    return tools;
+    return tools.filter((tool) => this.isToolSelected(tool, context));
   }
   /**
    * Subscribes to the WebMCP `toolchange` event, which fires when the page

package/dist/cjs/utils/client_labels.js

@@ -129,7 +129,8 @@ function headerEntries(headers) {
 __name(headerEntries, "headerEntries");
 function mergeTrackingHeaders(headers) {
   var _a, _b;
-  const merged = {};
+  const otherHeaders = new Headers();
+  const originalNames = /* @__PURE__ */ new Map();
   const callerValues = /* @__PURE__ */ new Map();
   for (const [name, value] of headerEntries(headers)) {
     const lowerName = name.toLowerCase();
@@ -139,9 +140,25 @@ function mergeTrackingHeaders(headers) {
         value
       ]);
     } else {
-      merged[name] = value;
+      if (!originalNames.has(lowerName)) {
+        originalNames.set(lowerName, name);
+      }
+      otherHeaders.append(name, value);
     }
   }
+  const normalizedEntries = [];
+  otherHeaders.forEach((value, name) => {
+    normalizedEntries.push([name, value]);
+  });
+  const merged = Object.fromEntries(
+    normalizedEntries.map(([name, value]) => {
+      var _a2;
+      return [
+        (_a2 = originalNames.get(name)) != null ? _a2 : name,
+        value
+      ];
+    })
+  );
   for (const [name, trackingValue] of Object.entries(getTrackingHeaders())) {
     const tokens = trackingValue.split(" ");
     for (const value of (_b = callerValues.get(name)) != null ? _b : []) {

package/dist/cjs/utils/env_aware_utils.js

@@ -70,14 +70,10 @@ function randomUUID() {
 __name(randomUUID, "randomUUID");
 function base64Encode(data) {
   if (isBrowser()) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
     let strData = "";
-    if (typeof data === "string") {
-      strData = data;
-    } else {
-      const len = data.byteLength;
-      for (let i = 0; i < len; i++) {
-        strData += String.fromCharCode(data[i]);
-      }
+    for (let i = 0; i < bytes.length; i++) {
+      strData += String.fromCharCode(bytes[i]);
     }
     return window.btoa(strData);
   }
@@ -86,7 +82,9 @@ function base64Encode(data) {
 __name(base64Encode, "base64Encode");
 function base64Decode(data) {
   if (isBrowser()) {
-    return window.atob(data);
+    const binary = window.atob(data);
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    return new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes);
   }
   return Buffer.from(data, "base64").toString();
 }

package/dist/cjs/utils/error_utils.js

@@ -25,7 +25,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var error_utils_exports = {};
 __export(error_utils_exports, {
-  formatError: () => formatError
+  formatError: () => formatError,
+  getErrorMessage: () => getErrorMessage
 });
 module.exports = __toCommonJS(error_utils_exports);
 /**
@@ -55,16 +56,14 @@ function truncateBody(body) {
   return body.length > MAX_RESPONSE_BODY_LENGTH ? body.slice(0, MAX_RESPONSE_BODY_LENGTH) + TRUNCATION_MARKER : body;
 }
 __name(truncateBody, "truncateBody");
-function baseMessage(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  if (typeof err === "string") {
-    return err;
+function getErrorMessage(err) {
+  const record = asRecord(err);
+  if (record !== void 0 && typeof record["message"] === "string") {
+    return record["message"];
   }
   return String(err);
 }
-__name(baseMessage, "baseMessage");
+__name(getErrorMessage, "getErrorMessage");
 function extractHttpDetails(err) {
   var _a, _b;
   const record = asRecord(err);
@@ -97,7 +96,7 @@ function formatErrorRecursive(err, seen) {
   }
   if (typeof err === "object") {
     if (seen.has(err)) {
-      return baseMessage(err);
+      return getErrorMessage(err);
     }
     seen.add(err);
   }
@@ -105,7 +104,7 @@ function formatErrorRecursive(err, seen) {
     return err.errors.map((sub) => formatErrorRecursive(sub, seen)).join(" | ");
   }
   const http = extractHttpDetails(err);
-  const base = baseMessage(err);
+  const base = getErrorMessage(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;
@@ -124,5 +123,6 @@ function formatError(err) {
 __name(formatError, "formatError");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  formatError
+  formatError,
+  getErrorMessage
 });

package/dist/cjs/utils/failover_utils.js

@@ -47,9 +47,9 @@ async function* runWithRouting(items, context, router, runFn) {
   }
   const triedKeys = /* @__PURE__ */ new Set([selectedKey]);
   while (true) {
-    const generatorOrPromise = runFn(selectedItem);
     let firstYielded = false;
     try {
+      const generatorOrPromise = runFn(selectedItem);
       if (isAsyncGenerator(generatorOrPromise)) {
         for await (const result2 of generatorOrPromise) {
           yield result2;

package/dist/cjs/utils/file_extension_utils.js

@@ -37,7 +37,17 @@ var import_code_execution_utils = require("../code_executors/code_execution_util
  */
 const MIME_TYPE_MAP = {
   ".js": { mimeType: "text/javascript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".cjs": { mimeType: "text/javascript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".mjs": { mimeType: "text/javascript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".ts": { mimeType: "text/javascript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".cts": { mimeType: "text/javascript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".mts": { mimeType: "text/javascript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
   ".py": { mimeType: "text/x-python", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".sh": { mimeType: "text/x-shellscript", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
+  ".bash": {
+    mimeType: "text/x-shellscript",
+    encoding: import_code_execution_utils.FileContentEncoding.UTF8
+  },
   ".md": { mimeType: "text/markdown", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
   ".txt": { mimeType: "text/plain", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
   ".html": { mimeType: "text/html", encoding: import_code_execution_utils.FileContentEncoding.UTF8 },
@@ -51,6 +61,7 @@ const MIME_TYPE_MAP = {
   ".png": { mimeType: "image/png", encoding: import_code_execution_utils.FileContentEncoding.BASE64 },
   ".jpg": { mimeType: "image/jpeg", encoding: import_code_execution_utils.FileContentEncoding.BASE64 },
   ".jpeg": { mimeType: "image/jpeg", encoding: import_code_execution_utils.FileContentEncoding.BASE64 },
+  ".gif": { mimeType: "image/gif", encoding: import_code_execution_utils.FileContentEncoding.BASE64 },
   ".pdf": { mimeType: "application/pdf", encoding: import_code_execution_utils.FileContentEncoding.BASE64 }
 };
 const EXTENSION_TO_LANGUAGE = {

package/dist/cjs/utils/file_utils.js

@@ -35,13 +35,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var file_utils_exports = {};
 __export(file_utils_exports, {
-  EXTENSION_TO_MIME_TYPE: () => EXTENSION_TO_MIME_TYPE,
   guessMimeType: () => guessMimeType,
   materializeFiles: () => materializeFiles
 });
 module.exports = __toCommonJS(file_utils_exports);
 var fs = __toESM(require("node:fs/promises"), 1);
 var path = __toESM(require("node:path"), 1);
+var import_file_extension_utils = require("./file_extension_utils.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -97,34 +97,12 @@ async function materializeFiles(files, dir) {
   return createdFiles;
 }
 __name(materializeFiles, "materializeFiles");
-const EXTENSION_TO_MIME_TYPE = {
-  "pdf": "application/pdf",
-  "jpg": "image/jpeg",
-  "jpeg": "image/jpeg",
-  "png": "image/png",
-  "gif": "image/gif",
-  "csv": "text/csv",
-  "json": "application/json",
-  "xml": "application/xml",
-  "sh": "text/x-shellscript",
-  "bash": "text/x-shellscript",
-  "py": "text/x-python",
-  "js": "text/javascript",
-  "cjs": "text/javascript",
-  "mjs": "text/javascript",
-  "ts": "text/javascript",
-  "cts": "text/javascript",
-  "mts": "text/javascript"
-};
 function guessMimeType(filePath) {
-  var _a;
-  const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
-  return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
+  return (0, import_file_extension_utils.getMimeTypeAndEncoding)(path.extname(filePath)).mimeType;
 }
 __name(guessMimeType, "guessMimeType");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  EXTENSION_TO_MIME_TYPE,
   guessMimeType,
   materializeFiles
 });

package/dist/cjs/utils/gemini_schema_util.js

@@ -25,6 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var gemini_schema_util_exports = {};
 __export(gemini_schema_util_exports, {
+  normalizeJsonSchemaType: () => normalizeJsonSchemaType,
   openApiSchemaToGeminiSchema: () => openApiSchemaToGeminiSchema,
   toGeminiSchema: () => toGeminiSchema
 });
@@ -72,6 +73,9 @@ function toGeminiSchema(mcpSchema) {
   }
   function recursiveConvert(mcp) {
     var _a;
+    if (typeof mcp === "boolean") {
+      mcp = { type: "object" };
+    }
     const sourceType = (_a = mcp.anyOf) != null ? _a : mcp.type;
     let isNullable = false;
     let nonNullTypes;
@@ -162,7 +166,7 @@ function toGeminiSchema(mcpSchema) {
         geminiSchema.required = mcp.required;
       }
     } else if (geminiType === import_genai.Type.ARRAY) {
-      if (mcp.items) {
+      if (mcp.items || mcp.items === false) {
         geminiSchema.items = recursiveConvert(mcp.items);
       }
     }
@@ -201,7 +205,6 @@ const GEMINI_REJECTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
   "default",
   "format"
 ]);
-const EMPTY_OBJECT_PLACEHOLDER = "dummy_DO_NOT_GENERATE";
 function toGeminiSchemaField(key) {
   return (0, import_case_utils.toSnakeCaseName)(key).replace(
     /_([a-z0-9])/g,
@@ -213,6 +216,23 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isPlainObject, "isPlainObject");
+function normalizeJsonSchemaType(jsonSchemaType) {
+  if (typeof jsonSchemaType === "string") {
+    if (jsonSchemaType === "null") {
+      return [void 0, true];
+    }
+    return [jsonSchemaType, false];
+  }
+  if (Array.isArray(jsonSchemaType)) {
+    const nullable = jsonSchemaType.includes("null");
+    const nonNullTypes = jsonSchemaType.filter(
+      (t) => typeof t === "string" && t !== "null"
+    );
+    return [nonNullTypes[0], nullable];
+  }
+  return [void 0, false];
+}
+__name(normalizeJsonSchemaType, "normalizeJsonSchemaType");
 function convertSchemaField(field, value) {
   if (field === "type") {
     return toGeminiType(typeof value === "string" ? value : void 0);
@@ -242,14 +262,14 @@ function openApiSchemaToGeminiSchema(openApiSchema) {
     throw new TypeError("openapi_schema must be a dictionary");
   }
   const source = { ...openApiSchema };
+  const [schemaType, nullable] = normalizeJsonSchemaType(source["type"]);
+  source["type"] = schemaType;
+  if (nullable) {
+    source["nullable"] = true;
+  }
   if (!source["type"]) {
     source["type"] = "object";
   }
-  const properties = source["properties"];
-  const hasProperties = isPlainObject(properties) && Object.keys(properties).length > 0;
-  if (source["type"] === "object" && !hasProperties) {
-    source["properties"] = { [EMPTY_OBJECT_PLACEHOLDER]: { type: "string" } };
-  }
   const converted = {};
   for (const [key, value] of Object.entries(source)) {
     const field = toGeminiSchemaField(key);
@@ -263,6 +283,7 @@ function openApiSchemaToGeminiSchema(openApiSchema) {
 __name(openApiSchemaToGeminiSchema, "openApiSchemaToGeminiSchema");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  normalizeJsonSchemaType,
   openApiSchemaToGeminiSchema,
   toGeminiSchema
 });

package/dist/cjs/utils/json_utils.js

@@ -0,0 +1,49 @@
+/**
+  * @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 json_utils_exports = {};
+__export(json_utils_exports, {
+  isJsonObject: () => isJsonObject,
+  toJsonObject: () => toJsonObject
+});
+module.exports = __toCommonJS(json_utils_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isJsonObject, "isJsonObject");
+function toJsonObject(value) {
+  return isJsonObject(value) ? value : {};
+}
+__name(toJsonObject, "toJsonObject");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isJsonObject,
+  toJsonObject
+});

package/dist/cjs/utils/live_connection_utils.js

@@ -204,12 +204,11 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
           yield this.buildFullTextResponse(this.text, this.isThought);
           this.text = "";
           this.isThought = false;
-        } else {
-          yield {
-            interrupted: serverContent.interrupted,
-            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
-          };
         }
+        yield {
+          interrupted: serverContent.interrupted,
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
       }
     }
     if (message.toolCall) {

package/dist/cjs/utils/logger_node.js

@@ -46,6 +46,12 @@ var import_logger = require("./logger.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const WINSTON_LEVEL_NAMES = {
+  [import_logger.LogLevel.DEBUG]: "debug",
+  [import_logger.LogLevel.INFO]: "info",
+  [import_logger.LogLevel.WARN]: "warn",
+  [import_logger.LogLevel.ERROR]: "error"
+};
 const _WinstonLogger = class _WinstonLogger {
   constructor() {
     this.logLevel = import_logger.LogLevel.INFO;
@@ -56,6 +62,10 @@ const _WinstonLogger = class _WinstonLogger {
         "warn": import_logger.LogLevel.WARN,
         "error": import_logger.LogLevel.ERROR
       },
+      // `levels` above inverts winston's npm ordering, so `error` (3) is the
+      // most permissive and leaves winston pass-through. Every method already
+      // gates on `this.logLevel`; a lower value here would double-gate and
+      // drop records.
       level: "error",
       format: winston.format.combine(
         winston.format.label({ label: "ADK" }),
@@ -79,7 +89,7 @@ const _WinstonLogger = class _WinstonLogger {
     if (this.logLevel > level) {
       return;
     }
-    this.logger.log(level.toString(), messages.join(" "));
+    this.logger.log(WINSTON_LEVEL_NAMES[level], messages.join(" "));
   }
   debug(...messages) {
     if (this.logLevel > import_logger.LogLevel.DEBUG) {

package/dist/cjs/utils/object_notation_utils.js

@@ -26,7 +26,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var object_notation_utils_exports = {};
 __export(object_notation_utils_exports, {
   toCamelCase: () => toCamelCase,
-  toSnakeCase: () => toSnakeCase
+  toSnakeCase: () => toSnakeCase,
+  toSnakeCaseKey: () => toSnakeCaseKey
 });
 module.exports = __toCommonJS(object_notation_utils_exports);
 /**
@@ -46,7 +47,8 @@ const toCamelCaseKey = /* @__PURE__ */ __name((key) => key.replace(
   /_([a-z])/g,
   (_match, letter) => letter.toUpperCase()
 ), "toCamelCaseKey");
-const toSnakeCaseKey = /* @__PURE__ */ __name((key) => key.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase()), "toSnakeCaseKey");
+const CAMEL_BOUNDARY = /(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g;
+const toSnakeCaseKey = /* @__PURE__ */ __name((key) => key.replace(CAMEL_BOUNDARY, "_").toLowerCase().replace(/-/g, "_"), "toSnakeCaseKey");
 function toNotation(obj, converter, parentKey = "", preserveKeys = []) {
   if (Array.isArray(obj)) {
     return obj.map(
@@ -78,5 +80,6 @@ __name(toNotation, "toNotation");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   toCamelCase,
-  toSnakeCase
+  toSnakeCase,
+  toSnakeCaseKey
 });