@google/adk 2.0.0 → 2.2.0

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

@@ -0,0 +1,89 @@
+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 { logger } from "../../utils/logger.js";
+import { BaseToolset } from "../base_toolset.js";
+import { WebMCPTool } from "./webmcp_tool.js";
+import { getModelContext } from "./webmcp_types.js";
+const _WebMCPToolset = class _WebMCPToolset extends BaseToolset {
+  constructor(options = {}) {
+    var _a;
+    super((_a = options.toolFilter) != null ? _a : [], options.prefix);
+    this.changeListeners = /* @__PURE__ */ new Set();
+    this.doc = options.document;
+    this.fromOrigins = options.fromOrigins;
+  }
+  /** Whether this document exposes WebMCP. */
+  isSupported() {
+    return !!getModelContext(this.doc);
+  }
+  async getTools(context) {
+    const modelContext = getModelContext(this.doc);
+    if (!modelContext) {
+      logger.debug(
+        "document.modelContext is unavailable; WebMCPToolset is exposing no tools."
+      );
+      return [];
+    }
+    const registered = await modelContext.getTools(
+      this.fromOrigins ? { fromOrigins: this.fromOrigins } : void 0
+    );
+    const tools = registered.map(
+      (tool) => new WebMCPTool({
+        tool,
+        name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name,
+        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));
+    }
+    logger.warn(
+      "WebMCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
+    );
+    return tools;
+  }
+  /**
+   * Subscribes to the WebMCP `toolchange` event, which fires when the page
+   * registers or removes tools. Returns an unsubscribe function.
+   */
+  onToolChange(listener) {
+    const modelContext = getModelContext(this.doc);
+    if (!modelContext) return () => {
+    };
+    const handler = /* @__PURE__ */ __name(() => listener(), "handler");
+    this.changeListeners.add(handler);
+    modelContext.addEventListener("toolchange", handler);
+    return () => {
+      modelContext.removeEventListener("toolchange", handler);
+      this.changeListeners.delete(handler);
+    };
+  }
+  async close() {
+    const modelContext = getModelContext(this.doc);
+    if (modelContext) {
+      for (const handler of this.changeListeners) {
+        modelContext.removeEventListener("toolchange", handler);
+      }
+    }
+    this.changeListeners.clear();
+  }
+};
+__name(_WebMCPToolset, "WebMCPToolset");
+let WebMCPToolset = _WebMCPToolset;
+export {
+  WebMCPToolset
+};

package/dist/{web/utils/crypto_shim.js → esm/tools/webmcp/webmcp_types.js}

@@ -7,12 +7,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-function randomUUID() {
-  throw new Error(
-    "randomUUID: no cryptographically secure source of randomness is available. Neither crypto.randomUUID() nor crypto.getRandomValues() is present in this environment."
-  );
+function getModelContext(doc) {
+  const target = doc != null ? doc : globalThis.document;
+  return target == null ? void 0 : target.modelContext;
 }
-__name(randomUUID, "randomUUID");
+__name(getModelContext, "getModelContext");
+function isWebMCPSupported(doc) {
+  return !!getModelContext(doc);
+}
+__name(isWebMCPSupported, "isWebMCPSupported");
 export {
-  randomUUID
+  getModelContext,
+  isWebMCPSupported
 };

package/dist/esm/utils/case_utils.js

@@ -23,6 +23,54 @@ function camelCaseKeys(val) {
   return val;
 }
 __name(camelCaseKeys, "camelCaseKeys");
+const PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
+  "False",
+  "None",
+  "True",
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+const DEFAULT_RESERVED_WORD_PREFIX = "param_";
+function toSnakeCaseName(text) {
+  return text.replace(/[^a-zA-Z0-9]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+__name(toSnakeCaseName, "toSnakeCaseName");
+function renameReservedKeywords(s, prefix = DEFAULT_RESERVED_WORD_PREFIX) {
+  return PYTHON_KEYWORDS.has(s) ? prefix + s : s;
+}
+__name(renameReservedKeywords, "renameReservedKeywords");
 export {
-  camelCaseKeys
+  camelCaseKeys,
+  renameReservedKeywords,
+  toSnakeCaseName
 };

package/dist/esm/utils/client_labels.js

@@ -14,6 +14,7 @@ const ADK_LABEL = "google-adk";
 const LANGUAGE_LABEL = "gl-typescript";
 const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
 const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
+const TRACKING_HEADER_NAMES = ["x-goog-api-client", "user-agent"];
 const clientLabelLocalStorage = new AsyncLocalStorage();
 const USER_AGENT_PATTERNS = [
   ["Edge", /(?:Edg|Edge|EdgA)\/([0-9.]+)/i],
@@ -63,8 +64,72 @@ function getClientLabels() {
   return labels;
 }
 __name(getClientLabels, "getClientLabels");
+function getTrackingHeaders() {
+  const headerValue = getClientLabels().join(" ");
+  return {
+    "x-goog-api-client": headerValue,
+    "user-agent": headerValue
+  };
+}
+__name(getTrackingHeaders, "getTrackingHeaders");
+function isTrackingHeaderName(name) {
+  return TRACKING_HEADER_NAMES.some((trackingName) => trackingName === name);
+}
+__name(isTrackingHeaderName, "isTrackingHeaderName");
+function isHeaders(headers) {
+  return typeof headers.forEach === "function";
+}
+__name(isHeaders, "isHeaders");
+function headerEntries(headers) {
+  if (!headers) {
+    return [];
+  }
+  if (Array.isArray(headers)) {
+    return headers.map(([name, value]) => [name, value]);
+  }
+  if (isHeaders(headers)) {
+    const entries = [];
+    headers.forEach((value, name) => {
+      entries.push([name, value]);
+    });
+    return entries;
+  }
+  return Object.entries(headers);
+}
+__name(headerEntries, "headerEntries");
+function mergeTrackingHeaders(headers) {
+  var _a, _b;
+  const merged = {};
+  const callerValues = /* @__PURE__ */ new Map();
+  for (const [name, value] of headerEntries(headers)) {
+    const lowerName = name.toLowerCase();
+    if (isTrackingHeaderName(lowerName)) {
+      callerValues.set(lowerName, [
+        ...(_a = callerValues.get(lowerName)) != null ? _a : [],
+        value
+      ]);
+    } else {
+      merged[name] = value;
+    }
+  }
+  for (const [name, trackingValue] of Object.entries(getTrackingHeaders())) {
+    const tokens = trackingValue.split(" ");
+    for (const value of (_b = callerValues.get(name)) != null ? _b : []) {
+      for (const token of value.split(/\s+/)) {
+        if (token && !tokens.includes(token)) {
+          tokens.push(token);
+        }
+      }
+    }
+    merged[name] = tokens.join(" ");
+  }
+  return merged;
+}
+__name(mergeTrackingHeaders, "mergeTrackingHeaders");
 export {
   getClientLabels,
+  getTrackingHeaders,
+  mergeTrackingHeaders,
   parseUserAgent,
   runWithClientLabel
 };

package/dist/esm/utils/crypto_shim.js

@@ -13,6 +13,20 @@ function randomUUID() {
   );
 }
 __name(randomUUID, "randomUUID");
+function createHash(_algorithm) {
+  throw new Error(
+    "createHash: PKCE code challenges require a synchronous SHA-256, which the Web Crypto API does not provide (crypto.subtle.digest is async)."
+  );
+}
+__name(createHash, "createHash");
+function randomBytes(_size) {
+  throw new Error(
+    "randomBytes: no cryptographically secure source of randomness is available in this environment."
+  );
+}
+__name(randomBytes, "randomBytes");
 export {
+  createHash,
+  randomBytes,
   randomUUID
 };

package/dist/esm/utils/gemini_schema_util.js

@@ -8,12 +8,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * 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()
-});
+import { toSnakeCaseName } from "./case_utils.js";
 function toGeminiType(mcpType) {
   if (!mcpType) return Type.TYPE_UNSPECIFIED;
   switch (mcpType.toLowerCase()) {
@@ -54,10 +49,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) {
@@ -114,7 +117,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;
@@ -142,6 +145,96 @@ 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 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");
 export {
+  openApiSchemaToGeminiSchema,
   toGeminiSchema
 };

package/dist/esm/utils/hash_utils.js

@@ -0,0 +1,45 @@
+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 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");
+export {
+  stableHash,
+  stableStringify
+};

package/dist/esm/utils/live_connection_utils.js

@@ -7,7 +7,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { isGemini3xFlashLive } from "./model_name.js";
+import { isGemini3xLive } from "./model_name.js";
 const _LiveResponseAggregator = class _LiveResponseAggregator {
   constructor(modelVersion) {
     this.modelVersion = modelVersion;
@@ -69,18 +69,19 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
         yield llmResponse;
       }
       if (serverContent.inputTranscription) {
-        if (serverContent.inputTranscription.text) {
-          this.inputTranscriptionText += serverContent.inputTranscription.text;
+        const isGemini3x = 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,
@@ -198,7 +199,7 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
           }))
         );
       }
-      const isGemini3x = isGemini3xFlashLive(this.modelVersion);
+      const isGemini3x = isGemini3xLive(this.modelVersion);
       if (isGemini3x && this.toolCallParts.length > 0) {
         yield {
           content: { role: "model", parts: this.toolCallParts },

package/dist/esm/utils/logger.js

@@ -7,7 +7,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * 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";
@@ -15,31 +14,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;
@@ -48,31 +31,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");
@@ -131,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
+};