@google/adk 2.0.0 → 2.2.0

package/dist/cjs/utils/gemini_schema_util.js

@@ -25,21 +25,17 @@ 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, {
+  openApiSchemaToGeminiSchema: () => openApiSchemaToGeminiSchema,
   toGeminiSchema: () => toGeminiSchema
 });
 module.exports = __toCommonJS(gemini_schema_util_exports);
 var import_genai = require("@google/genai");
-var import_zod = require("zod");
+var import_case_utils = require("./case_utils.js");
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const MCPToolSchemaObject = import_zod.z.object({
-  type: import_zod.z.literal("object"),
-  properties: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-  required: import_zod.z.string().array().optional()
-});
 function toGeminiType(mcpType) {
   if (!mcpType) return import_genai.Type.TYPE_UNSPECIFIED;
   switch (mcpType.toLowerCase()) {
@@ -80,10 +76,18 @@ function toGeminiSchema(mcpSchema) {
     let isNullable = false;
     let nonNullTypes;
     if (Array.isArray(sourceType)) {
-      nonNullTypes = sourceType.filter(
+      const fromAnyOf = Boolean(mcp.anyOf);
+      const branches = sourceType.map(
+        (branch) => {
+          if (typeof branch !== "boolean") return branch;
+          return fromAnyOf ? { type: "object" } : "object";
+        }
+      );
+      mcp = fromAnyOf ? { ...mcp, anyOf: branches } : { ...mcp, type: branches };
+      nonNullTypes = branches.filter(
         (t) => getTypeFromArrayItem(t) !== "null"
       );
-      isNullable = sourceType.some(
+      isNullable = branches.some(
         (t) => getTypeFromArrayItem(t) === "null"
       );
       if (nonNullTypes.length === 1) {
@@ -140,7 +144,7 @@ function toGeminiSchema(mcpSchema) {
       geminiSchema.description = mcp.description;
     }
     if (mcp.enum) {
-      geminiSchema.enum = mcp.enum.map(String);
+      geminiSchema.enum = mcp.enum.filter((v) => v != null).map(String);
     }
     if (isNullable && mcp.type !== "null") {
       geminiSchema.nullable = true;
@@ -168,7 +172,97 @@ function toGeminiSchema(mcpSchema) {
   return recursiveConvert(mcpSchema);
 }
 __name(toGeminiSchema, "toGeminiSchema");
+const GEMINI_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "anyOf",
+  "default",
+  "description",
+  "enum",
+  "example",
+  "format",
+  "items",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "maximum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "minimum",
+  "nullable",
+  "pattern",
+  "properties",
+  "propertyOrdering",
+  "required",
+  "title",
+  "type"
+]);
+const GEMINI_REJECTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "title",
+  "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,
+    (_match, letter) => letter.toUpperCase()
+  );
+}
+__name(toGeminiSchemaField, "toGeminiSchemaField");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function convertSchemaField(field, value) {
+  if (field === "type") {
+    return toGeminiType(typeof value === "string" ? value : void 0);
+  }
+  if (field === "properties" && isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([name, property]) => [
+        name,
+        openApiSchemaToGeminiSchema(property)
+      ])
+    );
+  }
+  if (field === "items" && isPlainObject(value)) {
+    return openApiSchemaToGeminiSchema(value);
+  }
+  if (field === "anyOf" && Array.isArray(value)) {
+    return value.map((item) => openApiSchemaToGeminiSchema(item));
+  }
+  return value;
+}
+__name(convertSchemaField, "convertSchemaField");
+function openApiSchemaToGeminiSchema(openApiSchema) {
+  if (openApiSchema === void 0 || openApiSchema === null) {
+    return void 0;
+  }
+  if (!isPlainObject(openApiSchema)) {
+    throw new TypeError("openapi_schema must be a dictionary");
+  }
+  const source = { ...openApiSchema };
+  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);
+    if (!GEMINI_SCHEMA_FIELDS.has(field) || GEMINI_REJECTED_SCHEMA_FIELDS.has(field)) {
+      continue;
+    }
+    converted[field] = convertSchemaField(field, value);
+  }
+  return converted;
+}
+__name(openApiSchemaToGeminiSchema, "openApiSchemaToGeminiSchema");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  openApiSchemaToGeminiSchema,
   toGeminiSchema
 });

package/dist/cjs/utils/hash_utils.js

@@ -0,0 +1,73 @@
+/**
+  * @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 hash_utils_exports = {};
+__export(hash_utils_exports, {
+  stableHash: () => stableHash,
+  stableStringify: () => stableStringify
+});
+module.exports = __toCommonJS(hash_utils_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+function stableStringify(value) {
+  var _a;
+  return (_a = JSON.stringify(sortKeysDeep(value))) != null ? _a : "undefined";
+}
+__name(stableStringify, "stableStringify");
+function stableHash(value) {
+  const text = stableStringify(value);
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return (hash >>> 0).toString(16);
+}
+__name(stableHash, "stableHash");
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const source = value;
+  const sorted = {};
+  for (const key of Object.keys(source).sort()) {
+    sorted[key] = sortKeysDeep(source[key]);
+  }
+  return sorted;
+}
+__name(sortKeysDeep, "sortKeysDeep");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stableHash,
+  stableStringify
+});

package/dist/cjs/utils/live_connection_utils.js

@@ -95,18 +95,19 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
         yield llmResponse;
       }
       if (serverContent.inputTranscription) {
-        if (serverContent.inputTranscription.text) {
-          this.inputTranscriptionText += serverContent.inputTranscription.text;
+        const isGemini3x = (0, import_model_name.isGemini3xLive)(this.modelVersion);
+        const { text, finished } = serverContent.inputTranscription;
+        if (text) {
+          if (!isGemini3x) {
+            this.inputTranscriptionText += text;
+          }
           yield {
-            inputTranscription: {
-              text: serverContent.inputTranscription.text,
-              finished: false
-            },
-            partial: true,
+            inputTranscription: { text, finished: isGemini3x },
+            partial: !isGemini3x,
             ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
           };
         }
-        if (serverContent.inputTranscription.finished) {
+        if (finished && !isGemini3x) {
           yield {
             inputTranscription: {
               text: this.inputTranscriptionText,
@@ -224,7 +225,7 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
           }))
         );
       }
-      const isGemini3x = (0, import_model_name.isGemini3xFlashLive)(this.modelVersion);
+      const isGemini3x = (0, import_model_name.isGemini3xLive)(this.modelVersion);
       if (isGemini3x && this.toolCallParts.length > 0) {
         yield {
           content: { role: "model", parts: this.toolCallParts },

package/dist/cjs/utils/logger.js

@@ -5,11 +5,9 @@
   */
 
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -24,17 +22,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var logger_exports = {};
 __export(logger_exports, {
+  CONSOLE_METHOD: () => CONSOLE_METHOD,
   LogLevel: () => LogLevel,
   getLogger: () => getLogger,
   logger: () => logger,
@@ -43,7 +34,6 @@ __export(logger_exports, {
   setLogger: () => setLogger
 });
 module.exports = __toCommonJS(logger_exports);
-var winston = __toESM(require("winston"), 1);
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -56,31 +46,15 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
+const CONSOLE_METHOD = {
+  [0 /* DEBUG */]: "debug",
+  [1 /* INFO */]: "info",
+  [2 /* WARN */]: "warn",
+  [3 /* ERROR */]: "error"
+};
 const _SimpleLogger = class _SimpleLogger {
   constructor() {
     this.logLevel = 1 /* INFO */;
-    this.logger = winston.createLogger({
-      levels: {
-        "debug": 0 /* DEBUG */,
-        "info": 1 /* INFO */,
-        "warn": 2 /* WARN */,
-        "error": 3 /* ERROR */
-      },
-      level: "error",
-      format: winston.format.combine(
-        winston.format.label({ label: "ADK" }),
-        winston.format((info) => {
-          info.level = info.level.toUpperCase();
-          return info;
-        })(),
-        winston.format.colorize(),
-        winston.format.timestamp(),
-        winston.format.printf((info) => {
-          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
-        })
-      ),
-      transports: [new winston.transports.Console()]
-    });
   }
   setLogLevel(level) {
     this.logLevel = level;
@@ -89,31 +63,21 @@ const _SimpleLogger = class _SimpleLogger {
     if (this.logLevel > level) {
       return;
     }
-    this.logger.log(level.toString(), messages.join(" "));
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `${LogLevel[level]}: [ADK] ${timestamp} ${messages.join(" ")}`;
+    console[CONSOLE_METHOD[level]](line);
   }
   debug(...messages) {
-    if (this.logLevel > 0 /* DEBUG */) {
-      return;
-    }
-    this.logger.debug(messages.join(" "));
+    this.log(0 /* DEBUG */, ...messages);
   }
   info(...messages) {
-    if (this.logLevel > 1 /* INFO */) {
-      return;
-    }
-    this.logger.info(messages.join(" "));
+    this.log(1 /* INFO */, ...messages);
   }
   warn(...messages) {
-    if (this.logLevel > 2 /* WARN */) {
-      return;
-    }
-    this.logger.warn(messages.join(" "));
+    this.log(2 /* WARN */, ...messages);
   }
   error(...messages) {
-    if (this.logLevel > 3 /* ERROR */) {
-      return;
-    }
-    this.logger.error(messages.join(" "));
+    this.log(3 /* ERROR */, ...messages);
   }
 };
 __name(_SimpleLogger, "SimpleLogger");
@@ -173,6 +137,7 @@ const logger = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CONSOLE_METHOD,
   LogLevel,
   getLogger,
   logger,

package/dist/cjs/utils/logger_browser.js

@@ -0,0 +1,86 @@
+/**
+  * @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 logger_browser_exports = {};
+__export(logger_browser_exports, {
+  BrowserLogger: () => BrowserLogger,
+  installBrowserLogger: () => installBrowserLogger
+});
+module.exports = __toCommonJS(logger_browser_exports);
+var import_logger = require("./logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const LEVEL_COLOR = {
+  [import_logger.LogLevel.DEBUG]: "blue",
+  [import_logger.LogLevel.INFO]: "green",
+  [import_logger.LogLevel.WARN]: "orange",
+  [import_logger.LogLevel.ERROR]: "red"
+};
+const _BrowserLogger = class _BrowserLogger {
+  constructor() {
+    this.logLevel = import_logger.LogLevel.INFO;
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const rest = `: [ADK] ${timestamp} ${messages.join(" ")}`;
+    console[import_logger.CONSOLE_METHOD[level]](
+      `%c${import_logger.LogLevel[level]}%c${rest}`,
+      `color: ${LEVEL_COLOR[level]}`,
+      "color: inherit"
+    );
+  }
+  debug(...messages) {
+    this.log(import_logger.LogLevel.DEBUG, ...messages);
+  }
+  info(...messages) {
+    this.log(import_logger.LogLevel.INFO, ...messages);
+  }
+  warn(...messages) {
+    this.log(import_logger.LogLevel.WARN, ...messages);
+  }
+  error(...messages) {
+    this.log(import_logger.LogLevel.ERROR, ...messages);
+  }
+};
+__name(_BrowserLogger, "BrowserLogger");
+let BrowserLogger = _BrowserLogger;
+function installBrowserLogger() {
+  (0, import_logger.setLogger)(new BrowserLogger());
+}
+__name(installBrowserLogger, "installBrowserLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserLogger,
+  installBrowserLogger
+});

package/dist/cjs/utils/logger_node.js

@@ -0,0 +1,119 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_node_exports = {};
+__export(logger_node_exports, {
+  WinstonLogger: () => WinstonLogger,
+  installNodeLogger: () => installNodeLogger
+});
+module.exports = __toCommonJS(logger_node_exports);
+var winston = __toESM(require("winston"), 1);
+var import_logger = require("./logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _WinstonLogger = class _WinstonLogger {
+  constructor() {
+    this.logLevel = import_logger.LogLevel.INFO;
+    this.logger = winston.createLogger({
+      levels: {
+        "debug": import_logger.LogLevel.DEBUG,
+        "info": import_logger.LogLevel.INFO,
+        "warn": import_logger.LogLevel.WARN,
+        "error": import_logger.LogLevel.ERROR
+      },
+      level: "error",
+      format: winston.format.combine(
+        winston.format.label({ label: "ADK" }),
+        winston.format((info) => {
+          info.level = info.level.toUpperCase();
+          return info;
+        })(),
+        winston.format.colorize(),
+        winston.format.timestamp(),
+        winston.format.printf((info) => {
+          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
+        })
+      ),
+      transports: [new winston.transports.Console()]
+    });
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
+      return;
+    }
+    this.logger.log(level.toString(), messages.join(" "));
+  }
+  debug(...messages) {
+    if (this.logLevel > import_logger.LogLevel.DEBUG) {
+      return;
+    }
+    this.logger.debug(messages.join(" "));
+  }
+  info(...messages) {
+    if (this.logLevel > import_logger.LogLevel.INFO) {
+      return;
+    }
+    this.logger.info(messages.join(" "));
+  }
+  warn(...messages) {
+    if (this.logLevel > import_logger.LogLevel.WARN) {
+      return;
+    }
+    this.logger.warn(messages.join(" "));
+  }
+  error(...messages) {
+    if (this.logLevel > import_logger.LogLevel.ERROR) {
+      return;
+    }
+    this.logger.error(messages.join(" "));
+  }
+};
+__name(_WinstonLogger, "WinstonLogger");
+let WinstonLogger = _WinstonLogger;
+function installNodeLogger() {
+  (0, import_logger.setLogger)(new WinstonLogger());
+}
+__name(installNodeLogger, "installNodeLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WinstonLogger,
+  installNodeLogger
+});

package/dist/cjs/utils/model_name.js

@@ -28,7 +28,9 @@ __export(model_name_exports, {
   extractModelName: () => extractModelName,
   isGemini1Model: () => isGemini1Model,
   isGemini2OrAbove: () => isGemini2OrAbove,
+  isGemini35LiveTranslate: () => isGemini35LiveTranslate,
   isGemini3xFlashLive: () => isGemini3xFlashLive,
+  isGemini3xLive: () => isGemini3xLive,
   isGeminiModel: () => isGeminiModel,
   isGeminiModelIdCheckDisabled: () => isGeminiModelIdCheckDisabled
 });
@@ -84,12 +86,23 @@ function isGemini2OrAbove(modelString) {
   return parsedVersion.valid && parsedVersion.major >= 2;
 }
 __name(isGemini2OrAbove, "isGemini2OrAbove");
-function isGemini3xFlashLive(modelString) {
+function isGemini3xLive(modelString) {
   if (!modelString) {
     return false;
   }
   const modelName = extractModelName(modelString);
-  return modelName.startsWith("gemini-3.") && modelName.includes("-flash-live");
+  return modelName.startsWith("gemini-3.") && modelName.includes("-live") && !isGemini35LiveTranslate(modelString);
+}
+__name(isGemini3xLive, "isGemini3xLive");
+function isGemini35LiveTranslate(modelString) {
+  if (!modelString) {
+    return false;
+  }
+  return extractModelName(modelString).startsWith("gemini-3.5-live-translate");
+}
+__name(isGemini35LiveTranslate, "isGemini35LiveTranslate");
+function isGemini3xFlashLive(modelString) {
+  return isGemini3xLive(modelString);
 }
 __name(isGemini3xFlashLive, "isGemini3xFlashLive");
 function isGeminiModelIdCheckDisabled() {
@@ -101,7 +114,9 @@ __name(isGeminiModelIdCheckDisabled, "isGeminiModelIdCheckDisabled");
   extractModelName,
   isGemini1Model,
   isGemini2OrAbove,
+  isGemini35LiveTranslate,
   isGemini3xFlashLive,
+  isGemini3xLive,
   isGeminiModel,
   isGeminiModelIdCheckDisabled
 });

package/dist/cjs/utils/redact_inline_data.js

@@ -0,0 +1,46 @@
+/**
+  * @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 redact_inline_data_exports = {};
+__export(redact_inline_data_exports, {
+  stringifyWithRedactedInlineData: () => stringifyWithRedactedInlineData
+});
+module.exports = __toCommonJS(redact_inline_data_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function stringifyWithRedactedInlineData(value) {
+  return JSON.stringify(
+    value,
+    (key, val) => key === "inlineData" && typeof val === "object" && val !== null && "data" in val && typeof val.data === "string" ? { ...val, data: `<redacted ${val.data.length} chars>` } : val
+  );
+}
+__name(stringifyWithRedactedInlineData, "stringifyWithRedactedInlineData");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stringifyWithRedactedInlineData
+});