@google/adk 1.6.0 → 2.1.0

package/dist/esm/utils/env_aware_utils.js

@@ -1,14 +1,20 @@
 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 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { randomUUID as nodeRandomUUID } from "node:crypto";
+import { logger } from "./logger.js";
+const ENTERPRISE_MODE_ENV_VAR = "GOOGLE_GENAI_USE_ENTERPRISE";
+const DEPRECATED_ENTERPRISE_MODE_ENV_VAR = "GOOGLE_GENAI_USE_VERTEXAI";
 function isBrowser() {
   return typeof window !== "undefined";
 }
+__name(isBrowser, "isBrowser");
 function randomUUID() {
   var _a, _b;
   if ((_a = globalThis.crypto) == null ? void 0 : _a.randomUUID) {
@@ -29,6 +35,7 @@ function randomUUID() {
   }
   return nodeRandomUUID();
 }
+__name(randomUUID, "randomUUID");
 function base64Encode(data) {
   if (isBrowser()) {
     let strData = "";
@@ -44,12 +51,14 @@ function base64Encode(data) {
   }
   return Buffer.from(data).toString("base64");
 }
+__name(base64Encode, "base64Encode");
 function base64Decode(data) {
   if (isBrowser()) {
     return window.atob(data);
   }
   return Buffer.from(data, "base64").toString();
 }
+__name(base64Decode, "base64Decode");
 function isBase64Encoded(data) {
   try {
     return base64Encode(base64Decode(data)) === data;
@@ -57,6 +66,7 @@ function isBase64Encoded(data) {
     return false;
   }
 }
+__name(isBase64Encoded, "isBase64Encoded");
 function getBooleanEnvVar(envVar) {
   if (!process.env) {
     return false;
@@ -64,11 +74,42 @@ function getBooleanEnvVar(envVar) {
   const envVarValue = (process.env[envVar] || "").toLowerCase();
   return ["true", "1"].includes(envVarValue);
 }
+__name(getBooleanEnvVar, "getBooleanEnvVar");
+let warnedDeprecatedEnterpriseModeEnvVar = false;
+function warnDeprecatedEnterpriseModeEnvVar(message) {
+  if (warnedDeprecatedEnterpriseModeEnvVar) {
+    return;
+  }
+  warnedDeprecatedEnterpriseModeEnvVar = true;
+  logger.warn(message);
+}
+__name(warnDeprecatedEnterpriseModeEnvVar, "warnDeprecatedEnterpriseModeEnvVar");
+function isEnterpriseModeEnabled() {
+  var _a, _b;
+  const deprecatedIsSet = ((_a = process.env) == null ? void 0 : _a[DEPRECATED_ENTERPRISE_MODE_ENV_VAR]) !== void 0;
+  if (((_b = process.env) == null ? void 0 : _b[ENTERPRISE_MODE_ENV_VAR]) !== void 0) {
+    if (deprecatedIsSet) {
+      warnDeprecatedEnterpriseModeEnvVar(
+        `${DEPRECATED_ENTERPRISE_MODE_ENV_VAR} is set but ignored because ${ENTERPRISE_MODE_ENV_VAR} takes precedence. ${DEPRECATED_ENTERPRISE_MODE_ENV_VAR} is deprecated, please use ${ENTERPRISE_MODE_ENV_VAR} instead.`
+      );
+    }
+    return getBooleanEnvVar(ENTERPRISE_MODE_ENV_VAR);
+  }
+  if (deprecatedIsSet) {
+    warnDeprecatedEnterpriseModeEnvVar(
+      `${DEPRECATED_ENTERPRISE_MODE_ENV_VAR} is deprecated, please use ${ENTERPRISE_MODE_ENV_VAR} instead`
+    );
+    return getBooleanEnvVar(DEPRECATED_ENTERPRISE_MODE_ENV_VAR);
+  }
+  return false;
+}
+__name(isEnterpriseModeEnabled, "isEnterpriseModeEnabled");
 export {
   base64Decode,
   base64Encode,
   getBooleanEnvVar,
   isBase64Encoded,
   isBrowser,
+  isEnterpriseModeEnabled,
   randomUUID
 };

package/dist/esm/utils/error_utils.js

@@ -1,5 +1,7 @@
 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
@@ -13,6 +15,7 @@ const MAX_HTTP_STATUS = 599;
 function asRecord(value) {
   return value !== null && typeof value === "object" ? value : void 0;
 }
+__name(asRecord, "asRecord");
 function firstString(...values) {
   for (const value of values) {
     if (typeof value === "string") {
@@ -21,9 +24,11 @@ function firstString(...values) {
   }
   return void 0;
 }
+__name(firstString, "firstString");
 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;
@@ -33,6 +38,7 @@ function baseMessage(err) {
   }
   return String(err);
 }
+__name(baseMessage, "baseMessage");
 function extractHttpDetails(err) {
   var _a, _b;
   const record = asRecord(err);
@@ -57,6 +63,7 @@ function extractHttpDetails(err) {
   const head = status === void 0 ? "HTTP error" : `HTTP ${status}${statusText === void 0 ? "" : ` ${statusText}`}`;
   return body === void 0 ? head : `${head}: ${truncateBody(body)}`;
 }
+__name(extractHttpDetails, "extractHttpDetails");
 function formatErrorRecursive(err, seen) {
   var _a;
   if (err === null || err === void 0) {
@@ -84,9 +91,11 @@ function formatErrorRecursive(err, seen) {
   }
   return message;
 }
+__name(formatErrorRecursive, "formatErrorRecursive");
 function formatError(err) {
   return formatErrorRecursive(err, /* @__PURE__ */ new Set());
 }
+__name(formatError, "formatError");
 export {
   formatError
 };

package/dist/esm/utils/experimental.js

@@ -1,5 +1,7 @@
 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
@@ -8,9 +10,10 @@ const require = topLevelCreateRequire(import.meta.url);
 import { logger } from "./logger.js";
 const warnedItems = /* @__PURE__ */ new Set();
 function experimental(target, propertyKey, descriptor) {
+  var _a;
   if (propertyKey === void 0) {
     const className = target.name;
-    const newConstructor = class extends target {
+    const newConstructor = (_a = class extends target {
       constructor(...args) {
         if (!warnedItems.has(className)) {
           logger.warn(
@@ -20,7 +23,11 @@ function experimental(target, propertyKey, descriptor) {
         }
         super(...args);
       }
-    };
+    }, __name(_a, "newConstructor"), _a);
+    Object.defineProperty(newConstructor, "name", {
+      value: className,
+      configurable: true
+    });
     return newConstructor;
   }
   if (propertyKey !== void 0 && descriptor !== void 0) {
@@ -41,6 +48,7 @@ function experimental(target, propertyKey, descriptor) {
   }
   throw new Error("Invalid decorator usage");
 }
+__name(experimental, "experimental");
 export {
   experimental
 };

package/dist/esm/utils/failover_utils.js

@@ -1,5 +1,7 @@
 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
@@ -57,9 +59,11 @@ async function* runWithRouting(items, context, router, runFn) {
     }
   }
 }
+__name(runWithRouting, "runWithRouting");
 function isAsyncGenerator(obj) {
   return typeof obj === "object" && typeof obj[Symbol.asyncIterator] === "function";
 }
+__name(isAsyncGenerator, "isAsyncGenerator");
 export {
   runWithRouting
 };

package/dist/esm/utils/file_extension_utils.js

@@ -1,5 +1,7 @@
 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
@@ -42,9 +44,11 @@ function getMimeTypeAndEncoding(ext) {
     encoding: FileContentEncoding.BASE64
   };
 }
+__name(getMimeTypeAndEncoding, "getMimeTypeAndEncoding");
 function getScriptLanguageByExtension(ext) {
   return EXTENSION_TO_LANGUAGE[ext.toLowerCase()] || CodeExecutionLanguage.UNSPECIFIED;
 }
+__name(getScriptLanguageByExtension, "getScriptLanguageByExtension");
 export {
   getMimeTypeAndEncoding,
   getScriptLanguageByExtension

package/dist/esm/utils/file_utils.js

@@ -1,5 +1,7 @@
 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
@@ -10,7 +12,8 @@ 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()) {
+__name(isInsideDir, "isInsideDir");
+async function materializeFiles(files, dir) {
   const resolvedBaseDir = path.resolve(dir);
   const createdFiles = [];
   for (const file of files) {
@@ -45,7 +48,8 @@ async function materializeFiles(files, dir = process.cwd()) {
     await fs.mkdir(path.dirname(finalPath), { recursive: true });
     await fs.writeFile(
       finalPath,
-      Buffer.from(file.content, file.contentEncoding)
+      Buffer.from(file.content, file.contentEncoding),
+      { flag: "wx" }
     );
     createdFiles.push({
       ...file,
@@ -54,6 +58,7 @@ async function materializeFiles(files, dir = process.cwd()) {
   }
   return createdFiles;
 }
+__name(materializeFiles, "materializeFiles");
 const EXTENSION_TO_MIME_TYPE = {
   "pdf": "application/pdf",
   "jpg": "image/jpeg",
@@ -78,6 +83,7 @@ function guessMimeType(filePath) {
   const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
   return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
 }
+__name(guessMimeType, "guessMimeType");
 export {
   EXTENSION_TO_MIME_TYPE,
   guessMimeType,

package/dist/esm/utils/gemini_schema_util.js

@@ -1,17 +1,13 @@
 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 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Type } from "@google/genai";
-import { z } from "zod";
-const MCPToolSchemaObject = z.object({
-  type: z.literal("object"),
-  properties: z.record(z.string(), z.unknown()).optional(),
-  required: z.string().array().optional()
-});
 function toGeminiType(mcpType) {
   if (!mcpType) return Type.TYPE_UNSPECIFIED;
   switch (mcpType.toLowerCase()) {
@@ -34,13 +30,14 @@ function toGeminiType(mcpType) {
       return Type.TYPE_UNSPECIFIED;
   }
 }
-const getTypeFromArrayItem = (mcpType) => {
+__name(toGeminiType, "toGeminiType");
+const getTypeFromArrayItem = /* @__PURE__ */ __name((mcpType) => {
   var _a, _b;
   if (typeof mcpType === "string") {
     return mcpType.toLowerCase();
   }
   return (_b = (_a = mcpType == null ? void 0 : mcpType.type) == null ? void 0 : _a.toLowerCase) == null ? void 0 : _b.call(_a);
-};
+}, "getTypeFromArrayItem");
 function toGeminiSchema(mcpSchema) {
   if (!mcpSchema) {
     return void 0;
@@ -135,8 +132,10 @@ function toGeminiSchema(mcpSchema) {
     }
     return geminiSchema;
   }
+  __name(recursiveConvert, "recursiveConvert");
   return recursiveConvert(mcpSchema);
 }
+__name(toGeminiSchema, "toGeminiSchema");
 export {
   toGeminiSchema
 };

package/dist/esm/utils/genai_schema_to_json.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
+ */
+const NUMERIC_STRING_KEYS = [
+  "minItems",
+  "maxItems",
+  "minLength",
+  "maxLength",
+  "minProperties",
+  "maxProperties"
+];
+const NON_JSON_SCHEMA_KEYS = /* @__PURE__ */ new Set(["propertyOrdering", "example"]);
+const TYPE_NAMES = {
+  STRING: "string",
+  NUMBER: "number",
+  INTEGER: "integer",
+  BOOLEAN: "boolean",
+  ARRAY: "array",
+  OBJECT: "object",
+  NULL: "null"
+};
+function genaiSchemaToJsonSchema(schema) {
+  const source = schema;
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0 || NON_JSON_SCHEMA_KEYS.has(key)) {
+      continue;
+    }
+    switch (key) {
+      case "type":
+      case "nullable":
+        break;
+      case "items":
+        out["items"] = genaiSchemaToJsonSchema(value);
+        break;
+      case "properties": {
+        const properties = {};
+        for (const [name, property] of Object.entries(
+          value
+        )) {
+          properties[name] = genaiSchemaToJsonSchema(property);
+        }
+        out["properties"] = properties;
+        break;
+      }
+      case "anyOf":
+        out["anyOf"] = value.map(genaiSchemaToJsonSchema);
+        break;
+      case "format":
+        if (value !== "enum") {
+          out["format"] = value;
+        }
+        break;
+      default:
+        out[key] = NUMERIC_STRING_KEYS.includes(
+          key
+        ) ? Number(value) : value;
+    }
+  }
+  const typeName = typeof schema.type === "string" ? TYPE_NAMES[schema.type] : void 0;
+  if (typeName) {
+    out["type"] = schema.nullable ? [typeName, "null"] : typeName;
+  }
+  if (Array.isArray(out["enum"]) && (typeName === "integer" || typeName === "number")) {
+    out["enum"] = out["enum"].map(
+      (member) => typeof member === "string" && member.trim() !== "" && !isNaN(Number(member)) ? Number(member) : member
+    );
+  }
+  return out;
+}
+__name(genaiSchemaToJsonSchema, "genaiSchemaToJsonSchema");
+export {
+  genaiSchemaToJsonSchema
+};

package/dist/esm/utils/live_connection_utils.js

@@ -1,12 +1,14 @@
 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
  */
 import { isGemini3xFlashLive } from "./model_name.js";
-class LiveResponseAggregator {
+const _LiveResponseAggregator = class _LiveResponseAggregator {
   constructor(modelVersion) {
     this.modelVersion = modelVersion;
     this.text = "";
@@ -250,7 +252,9 @@ class LiveResponseAggregator {
     }
     return response;
   }
-}
+};
+__name(_LiveResponseAggregator, "LiveResponseAggregator");
+let LiveResponseAggregator = _LiveResponseAggregator;
 export {
   LiveResponseAggregator
 };

package/dist/esm/utils/logger.js

@@ -1,11 +1,12 @@
 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 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as winston from "winston";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
   LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
@@ -13,31 +14,15 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
-class SimpleLogger {
+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;
@@ -46,34 +31,26 @@ 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);
   }
-}
-class NoOpLogger {
+};
+__name(_SimpleLogger, "SimpleLogger");
+let SimpleLogger = _SimpleLogger;
+const _NoOpLogger = class _NoOpLogger {
   setLogLevel(_level) {
   }
   log(_level, ..._args) {
@@ -86,20 +63,26 @@ class NoOpLogger {
   }
   error(..._args) {
   }
-}
+};
+__name(_NoOpLogger, "NoOpLogger");
+let NoOpLogger = _NoOpLogger;
 let currentLogger = new SimpleLogger();
 function setLogger(customLogger) {
   currentLogger = customLogger != null ? customLogger : new NoOpLogger();
 }
+__name(setLogger, "setLogger");
 function getLogger() {
   return currentLogger;
 }
+__name(getLogger, "getLogger");
 function resetLogger() {
   currentLogger = new SimpleLogger();
 }
+__name(resetLogger, "resetLogger");
 function setLogLevel(level) {
   logger.setLogLevel(level);
 }
+__name(setLogLevel, "setLogLevel");
 const logger = {
   setLogLevel(level) {
     currentLogger.setLogLevel(level);
@@ -121,6 +104,7 @@ const logger = {
   }
 };
 export {
+  CONSOLE_METHOD,
   LogLevel,
   getLogger,
   logger,

package/dist/esm/utils/logger_browser.js

@@ -0,0 +1,58 @@
+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
+ */
+import { CONSOLE_METHOD, LogLevel, setLogger } from "./logger.js";
+const LEVEL_COLOR = {
+  [LogLevel.DEBUG]: "blue",
+  [LogLevel.INFO]: "green",
+  [LogLevel.WARN]: "orange",
+  [LogLevel.ERROR]: "red"
+};
+const _BrowserLogger = class _BrowserLogger {
+  constructor() {
+    this.logLevel = 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[CONSOLE_METHOD[level]](
+      `%c${LogLevel[level]}%c${rest}`,
+      `color: ${LEVEL_COLOR[level]}`,
+      "color: inherit"
+    );
+  }
+  debug(...messages) {
+    this.log(LogLevel.DEBUG, ...messages);
+  }
+  info(...messages) {
+    this.log(LogLevel.INFO, ...messages);
+  }
+  warn(...messages) {
+    this.log(LogLevel.WARN, ...messages);
+  }
+  error(...messages) {
+    this.log(LogLevel.ERROR, ...messages);
+  }
+};
+__name(_BrowserLogger, "BrowserLogger");
+let BrowserLogger = _BrowserLogger;
+function installBrowserLogger() {
+  setLogger(new BrowserLogger());
+}
+__name(installBrowserLogger, "installBrowserLogger");
+export {
+  BrowserLogger,
+  installBrowserLogger
+};