@google/adk 2.2.1 → 2.3.0

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js

@@ -19,9 +19,46 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   AuthCredentialTypes
 } from "../../../../auth/auth_credential.js";
-import { OAuth2CredentialExchanger } from "../../../../auth/oauth2/oauth2_credential_exchanger.js";
+import { OAuthGrantType } from "../../../../auth/auth_schemes.js";
+import {
+  determineGrantType,
+  OAuth2CredentialExchanger
+} from "../../../../auth/oauth2/oauth2_credential_exchanger.js";
 import { experimental } from "../../../../utils/experimental.js";
+import { generateAuthToken } from "./oauth2_exchanger.js";
 import { ServiceAccountCredentialExchanger } from "./service_account_exchanger.js";
+function isPendingAuthorizationCode(authScheme, authCredential) {
+  var _a, _b, _c;
+  return !!authScheme && determineGrantType(authScheme) === 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 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 = 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
@@ -29,14 +66,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(
       AuthCredentialTypes.OAUTH2,
-      new OAuth2CredentialExchanger()
+      createDefaultOAuth2Exchanger()
     );
     this.exchangers.set(
       AuthCredentialTypes.OPEN_ID_CONNECT,
-      new OAuth2CredentialExchanger()
+      createDefaultOAuth2Exchanger()
     );
     this.exchangers.set(
       AuthCredentialTypes.SERVICE_ACCOUNT,

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

@@ -19,6 +19,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   AuthCredentialTypes
 } from "../../../../auth/auth_credential.js";
+import { AuthSchemeType } from "../../../../auth/auth_schemes.js";
 import { experimental } from "../../../../utils/experimental.js";
 function checkSchemeCredentialType(authScheme, authCredential) {
   if (!authCredential) {
@@ -26,7 +27,7 @@ function checkSchemeCredentialType(authScheme, authCredential) {
       "auth_credential is empty. Please create AuthCredential using OAuth2Auth."
     );
   }
-  if (authScheme.type !== "openIdConnect" && authScheme.type !== "oauth2") {
+  if (authScheme.type !== AuthSchemeType.OPEN_ID_CONNECT && authScheme.type !== AuthSchemeType.OAUTH2) {
     throw new Error(
       `Invalid security scheme, expect AuthSchemeType.openIdConnect or AuthSchemeType.oauth2 auth scheme, but got ${authScheme.type}`
     );

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

@@ -17,6 +17,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  * SPDX-License-Identifier: Apache-2.0
  */
 import { GoogleAuth, JWT } from "google-auth-library";
+import { createSign } from "node:crypto";
 import {
   AuthCredentialTypes
 } from "../../../../auth/auth_credential.js";
@@ -24,6 +25,83 @@ import { experimental } from "../../../../utils/experimental.js";
 import { AuthCredentialMissingError } from "./base_auth_credential_exchanger.js";
 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 = 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;
@@ -64,21 +142,27 @@ let ServiceAccountCredentialExchanger = class {
     }
   }
   async exchangeForExplicitCredential(saConfig) {
+    var _a;
     const creds = saConfig.serviceAccountCredential;
     if (!creds) {
       throw new AuthCredentialMissingError(MISSING_SERVICE_ACCOUNT_CREDENTIALS);
     }
     try {
-      const client = new 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 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/esm/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  */
 import { cloneDeep } from "lodash-es";
 import {
+  AuthCredentialTypes,
   isAuthCredential
 } from "../../../auth/auth_credential.js";
 import { experimental } from "../../../utils/experimental.js";
@@ -26,6 +27,16 @@ import { logger } from "../../../utils/logger.js";
 import { AutoAuthCredentialExchanger } from "../auth/credential_exchangers/auto_auth_credential_exchanger.js";
 import { AuthCredentialMissingError } from "../auth/credential_exchangers/base_auth_credential_exchanger.js";
 const DEFAULT_CREDENTIAL_KEY = "default_openapi_key";
+const INTERACTIVE_CREDENTIAL_TYPES = /* @__PURE__ */ new Set([
+  AuthCredentialTypes.OAUTH2,
+  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;
@@ -141,7 +152,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
@@ -151,10 +163,11 @@ let ToolAuthHandler = class {
     var _a;
     const exchanger = (_a = this.credentialExchanger) != null ? _a : new AutoAuthCredentialExchanger();
     try {
-      return await exchanger.exchange({
+      const result = await exchanger.exchange({
         authScheme: this.authScheme,
         authCredential: credential
       });
+      return isMissingInteractiveToken(result) ? void 0 : result;
     } catch (e) {
       logger.error(
         `Failed to exchange credential: ${e instanceof Error ? e.message : e}`

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

@@ -7,9 +7,22 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 import { Type } from "@google/genai";
 import { BaseTool } from "../base_tool.js";
-const _BaseRetrievalTool = class _BaseRetrievalTool extends BaseTool {
+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 = 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,
@@ -29,5 +42,6 @@ const _BaseRetrievalTool = class _BaseRetrievalTool extends BaseTool {
 __name(_BaseRetrievalTool, "BaseRetrievalTool");
 let BaseRetrievalTool = _BaseRetrievalTool;
 export {
-  BaseRetrievalTool
+  BaseRetrievalTool,
+  isBaseRetrievalTool
 };

package/dist/esm/tools/toolbox_tool.js

@@ -0,0 +1,80 @@
+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
+ */
+var _a;
+import { LangchainTool } from "./langchain_tool.js";
+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 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 LangchainTool(tool));
+  }
+};
+__name(_ToolboxTool, "ToolboxTool");
+let ToolboxTool = _ToolboxTool;
+export {
+  ToolboxTool,
+  isToolboxTool
+};

package/dist/esm/utils/env_aware_utils.js

@@ -38,14 +38,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);
   }
@@ -54,7 +50,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/esm/utils/error_utils.js

@@ -29,16 +29,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);
@@ -71,7 +69,7 @@ function formatErrorRecursive(err, seen) {
   }
   if (typeof err === "object") {
     if (seen.has(err)) {
-      return baseMessage(err);
+      return getErrorMessage(err);
     }
     seen.add(err);
   }
@@ -79,7 +77,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;
@@ -97,5 +95,6 @@ function formatError(err) {
 }
 __name(formatError, "formatError");
 export {
-  formatError
+  formatError,
+  getErrorMessage
 };

package/dist/esm/utils/file_extension_utils.js

@@ -13,7 +13,17 @@ import {
 } from "../code_executors/code_execution_utils.js";
 const MIME_TYPE_MAP = {
   ".js": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".cjs": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".mjs": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".ts": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".cts": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
+  ".mts": { mimeType: "text/javascript", encoding: FileContentEncoding.UTF8 },
   ".py": { mimeType: "text/x-python", encoding: FileContentEncoding.UTF8 },
+  ".sh": { mimeType: "text/x-shellscript", encoding: FileContentEncoding.UTF8 },
+  ".bash": {
+    mimeType: "text/x-shellscript",
+    encoding: FileContentEncoding.UTF8
+  },
   ".md": { mimeType: "text/markdown", encoding: FileContentEncoding.UTF8 },
   ".txt": { mimeType: "text/plain", encoding: FileContentEncoding.UTF8 },
   ".html": { mimeType: "text/html", encoding: FileContentEncoding.UTF8 },
@@ -27,6 +37,7 @@ const MIME_TYPE_MAP = {
   ".png": { mimeType: "image/png", encoding: FileContentEncoding.BASE64 },
   ".jpg": { mimeType: "image/jpeg", encoding: FileContentEncoding.BASE64 },
   ".jpeg": { mimeType: "image/jpeg", encoding: FileContentEncoding.BASE64 },
+  ".gif": { mimeType: "image/gif", encoding: FileContentEncoding.BASE64 },
   ".pdf": { mimeType: "application/pdf", encoding: FileContentEncoding.BASE64 }
 };
 const EXTENSION_TO_LANGUAGE = {

package/dist/esm/utils/file_utils.js

@@ -9,6 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { getMimeTypeAndEncoding } from "./file_extension_utils.js";
 function isInsideDir(resolvedPath, resolvedBaseDir) {
   return resolvedPath === resolvedBaseDir || resolvedPath.startsWith(resolvedBaseDir + path.sep);
 }
@@ -59,33 +60,11 @@ 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 getMimeTypeAndEncoding(path.extname(filePath)).mimeType;
 }
 __name(guessMimeType, "guessMimeType");
 export {
-  EXTENSION_TO_MIME_TYPE,
   guessMimeType,
   materializeFiles
 };

package/dist/esm/utils/gemini_schema_util.js

@@ -45,6 +45,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;
@@ -135,7 +138,7 @@ function toGeminiSchema(mcpSchema) {
         geminiSchema.required = mcp.required;
       }
     } else if (geminiType === Type.ARRAY) {
-      if (mcp.items) {
+      if (mcp.items || mcp.items === false) {
         geminiSchema.items = recursiveConvert(mcp.items);
       }
     }

package/dist/esm/utils/json_utils.js

@@ -0,0 +1,21 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isJsonObject, "isJsonObject");
+function toJsonObject(value) {
+  return isJsonObject(value) ? value : {};
+}
+__name(toJsonObject, "toJsonObject");
+export {
+  isJsonObject,
+  toJsonObject
+};

package/dist/esm/utils/live_connection_utils.js

@@ -178,12 +178,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/esm/utils/logger_node.js

@@ -9,6 +9,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import * as winston from "winston";
 import { LogLevel, setLogger } from "./logger.js";
+const WINSTON_LEVEL_NAMES = {
+  [LogLevel.DEBUG]: "debug",
+  [LogLevel.INFO]: "info",
+  [LogLevel.WARN]: "warn",
+  [LogLevel.ERROR]: "error"
+};
 const _WinstonLogger = class _WinstonLogger {
   constructor() {
     this.logLevel = LogLevel.INFO;
@@ -42,7 +48,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 > LogLevel.DEBUG) {

package/dist/esm/utils/object_notation_utils.js

@@ -19,7 +19,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(
@@ -50,5 +51,6 @@ function toNotation(obj, converter, parentKey = "", preserveKeys = []) {
 __name(toNotation, "toNotation");
 export {
   toCamelCase,
-  toSnakeCase
+  toSnakeCase,
+  toSnakeCaseKey
 };