@google/adk 2.1.0 → 2.2.0

package/dist/esm/tools/openapi_tool/rest_api_tool.js

@@ -17,15 +17,37 @@ var __decorateClass = (decorators, target, key, kind) => {
  * SPDX-License-Identifier: Apache-2.0
  */
 import { experimental } from "../../utils/experimental.js";
+import { openApiSchemaToGeminiSchema } from "../../utils/gemini_schema_util.js";
 import { BaseTool } from "../base_tool.js";
 import { applyCredential } from "./auth/auth_helpers.js";
 import {
   OperationParser
 } from "./openapi_spec_parser/operation_parser.js";
 import { ToolAuthHandler } from "./openapi_spec_parser/tool_auth_handler.js";
+const MAX_TOOL_NAME_LENGTH = 60;
+const SECURITY_SCHEME_TYPES = [
+  "apiKey",
+  "http",
+  "oauth2",
+  "openIdConnect"
+];
+function readSchemeType(value) {
+  return typeof value === "object" && value !== null && "type" in value ? value.type : void 0;
+}
+__name(readSchemeType, "readSchemeType");
+function isSecurityScheme(value) {
+  const type = readSchemeType(value);
+  return typeof type === "string" && SECURITY_SCHEME_TYPES.includes(type);
+}
+__name(isSecurityScheme, "isSecurityScheme");
+function serializeCookieHeader(cookies) {
+  return Object.entries(cookies).map(([name, value]) => `${name}=${encodeURIComponent(value)}`).join("; ");
+}
+__name(serializeCookieHeader, "serializeCookieHeader");
 let RestApiTool = class extends BaseTool {
   constructor(name, description, endpoint, operation, authScheme, authCredential, options = {}) {
-    super({ name, description });
+    var _a;
+    super({ name: name.slice(0, MAX_TOOL_NAME_LENGTH), description });
     this.endpoint = endpoint;
     this.operation = operation;
     this.authScheme = authScheme;
@@ -34,7 +56,7 @@ let RestApiTool = class extends BaseTool {
     this.authCredential = authCredential;
     this.headerProvider = options.headerProvider;
     this.credentialKey = options.credentialKey;
-    this.operationParser = new OperationParser(operation, options);
+    this.operationParser = (_a = options.operationParser) != null ? _a : new OperationParser(operation, options);
   }
   configureAuthScheme(authScheme) {
     this.authScheme = authScheme;
@@ -46,14 +68,16 @@ let RestApiTool = class extends BaseTool {
     this.credentialKey = credentialKey;
   }
   _getDeclaration() {
-    const schema = this.operationParser.getJsonSchema();
     return {
       name: this.name,
       description: this.description,
-      parameters: schema
+      parameters: openApiSchemaToGeminiSchema(
+        this.operationParser.getJsonSchema()
+      )
     };
   }
   async runAsync(request) {
+    var _a;
     const context = request.toolContext;
     const args = request.args;
     const authHandler = ToolAuthHandler.fromToolContext(
@@ -75,7 +99,8 @@ let RestApiTool = class extends BaseTool {
       url: initialUrl,
       headers,
       body: parsedBody,
-      bodyData
+      bodyData,
+      cookies
     } = prepareRequestParams(
       this.endpoint,
       this.operationParser.getParameters(),
@@ -91,30 +116,36 @@ let RestApiTool = class extends BaseTool {
       initialUrl,
       headers,
       credential,
-      this.authScheme
+      (_a = authResult.authScheme) != null ? _a : this.authScheme
     );
     if (this.headerProvider) {
       const providerHeaders = this.headerProvider(context);
       Object.assign(headers, providerHeaders);
     }
-    try {
-      const response = await globalThis.fetch(url, {
-        method,
-        headers,
-        // eslint-disable-next-line no-undef
-        body
-      });
-      const contentType = response.headers.get("content-type");
-      if (contentType && contentType.includes("application/json")) {
-        return await response.json();
-      } else {
-        return await response.text();
-      }
-    } catch (error) {
+    const hasCookieHeader = Object.keys(headers).some(
+      (header) => header.toLowerCase() === "cookie"
+    );
+    if (Object.keys(cookies).length > 0 && !hasCookieHeader) {
+      headers["Cookie"] = serializeCookieHeader(cookies);
+    }
+    const response = await globalThis.fetch(url, {
+      method,
+      headers,
+      // eslint-disable-next-line no-undef
+      body
+    });
+    if (response.status >= 400) {
+      const errorDetails = await response.text();
       return {
-        error: `Failed to execute API call: ${error.message}`
+        error: `Tool ${this.name} execution failed. Analyze this execution error and your inputs. Retry with adjustments if applicable. But make sure don't retry more than 3 times. Execution Error: ${errorDetails}`
       };
     }
+    const text = await response.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { text };
+    }
   }
 };
 __name(RestApiTool, "RestApiTool");
@@ -148,6 +179,7 @@ __name(encodePathParamValue, "encodePathParamValue");
 function prepareRequestParams(endpoint, parameters, args) {
   const headers = {};
   const queryParams = new URLSearchParams();
+  const cookies = {};
   let body = void 0;
   const paramsMap = new Map(parameters.map((p) => [p.name, p]));
   const pathParams = {};
@@ -163,9 +195,13 @@ function prepareRequestParams(endpoint, parameters, args) {
         String(argValue)
       );
     } else if (location === "query") {
-      queryParams.append(originalName, String(argValue));
+      if (argValue !== void 0 && argValue !== null && argValue !== "") {
+        queryParams.append(originalName, String(argValue));
+      }
     } else if (location === "header") {
       headers[originalName] = String(argValue);
+    } else if (location === "cookie") {
+      cookies[originalName] = String(argValue);
     } else if (location === "body") {
       if (originalName === "body" || originalName === "array" || originalName === "") {
         body = argValue;
@@ -178,7 +214,8 @@ function prepareRequestParams(endpoint, parameters, args) {
     /\{([^{}]+)\}/g,
     (placeholder, name) => Object.hasOwn(pathParams, name) ? pathParams[name] : placeholder
   );
-  let url = `${endpoint.baseUrl}${resolvedPath}`;
+  const baseUrl = endpoint.baseUrl.endsWith("/") ? endpoint.baseUrl.slice(0, -1) : endpoint.baseUrl;
+  let url = `${baseUrl}${resolvedPath}`;
   const urlParts = url.split("?");
   if (urlParts.length > 1) {
     const pathQueryParams = new URLSearchParams(urlParts[1]);
@@ -191,9 +228,13 @@ function prepareRequestParams(endpoint, parameters, args) {
   if (queryString) {
     url += `?${queryString}`;
   }
-  return { url, headers, body, bodyData };
+  return { url, headers, body, bodyData, cookies };
 }
 __name(prepareRequestParams, "prepareRequestParams");
+function isRawBody(value) {
+  return typeof value === "string" || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Blob;
+}
+__name(isRawBody, "isRawBody");
 function prepareRequestBody(requestBody, body, bodyData, headers) {
   const finalData = body !== void 0 ? body : Object.keys(bodyData).length > 0 ? bodyData : void 0;
   if (requestBody && "content" in requestBody) {
@@ -213,6 +254,9 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
           }
         }
         return formData;
+      } else if (mimeType === "application/octet-stream") {
+        headers["Content-Type"] = mimeType;
+        return isRawBody(finalData) ? finalData : String(finalData);
       } else if (mimeType === "text/plain") {
         headers["Content-Type"] = mimeType;
         return String(finalData);
@@ -226,20 +270,37 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
 }
 __name(prepareRequestBody, "prepareRequestBody");
 function createRestApiTool(parsed, options = {}) {
+  var _a, _b;
+  const operationParser = parsed.parameters ? OperationParser.load(
+    parsed.operation,
+    parsed.parameters,
+    parsed.returnValue
+  ) : new OperationParser(parsed.operation, options);
   return new RestApiTool(
-    parsed.name,
-    parsed.description,
+    (_a = parsed.name) != null ? _a : operationParser.getFunctionName(),
+    (_b = parsed.description) != null ? _b : operationParser.getDescription(),
     parsed.endpoint,
     parsed.operation,
     parsed.authScheme,
-    void 0,
-    options
+    parsed.authCredential,
+    { ...options, operationParser }
   );
 }
 __name(createRestApiTool, "createRestApiTool");
+function createRestApiToolFromJson(parsedOperationJson) {
+  const parsed = JSON.parse(parsedOperationJson);
+  if (parsed.authScheme && !isSecurityScheme(parsed.authScheme)) {
+    throw new Error(
+      `Unsupported security scheme type: ${JSON.stringify(readSchemeType(parsed.authScheme))}. Expected one of: ${SECURITY_SCHEME_TYPES.join(", ")}.`
+    );
+  }
+  return createRestApiTool(parsed);
+}
+__name(createRestApiToolFromJson, "createRestApiToolFromJson");
 export {
   RestApiTool,
   createRestApiTool,
+  createRestApiToolFromJson,
   prepareRequestBody,
   prepareRequestParams
 };

package/dist/esm/tools/skill/skill_toolset.js

@@ -74,7 +74,9 @@ let SkillToolset = class extends BaseToolset {
     return [...this.tools, ...dynamicTools];
   }
   async close() {
+    var _a, _b;
     this.fetchedSkillCache.clear();
+    await ((_b = (_a = this.registry) == null ? void 0 : _a.close) == null ? void 0 : _b.call(_a));
   }
   getSkill(name) {
     return this.skills[name];

package/dist/esm/tools/tool_context.js

@@ -0,0 +1,15 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  Context,
+  Context as Context2
+} from "../agents/context.js";
+export {
+  Context as CallbackContext,
+  Context2 as ToolContext
+};

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

@@ -0,0 +1,10 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./webmcp_tool.js";
+export * from "./webmcp_toolset.js";
+export * from "./webmcp_types.js";

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

@@ -0,0 +1,131 @@
+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 { Type } from "@google/genai";
+import { toGeminiSchema } from "../../utils/gemini_schema_util.js";
+import { logger } from "../../utils/logger.js";
+import { BaseTool } from "../base_tool.js";
+import {
+  getModelContext
+} from "./webmcp_types.js";
+const argEncodingByContext = /* @__PURE__ */ new WeakMap();
+function isArgParseFailure(value) {
+  var _a, _b;
+  let text = "";
+  if (typeof value === "string") {
+    text = value;
+  } else if (value && typeof value === "object") {
+    const candidate = value;
+    text = String((_b = (_a = candidate.error) != null ? _a : candidate.message) != null ? _b : "");
+  }
+  return /failed to parse input arguments|could not parse .*arguments/i.test(
+    text
+  );
+}
+__name(isArgParseFailure, "isArgParseFailure");
+const _WebMCPTool = class _WebMCPTool extends BaseTool {
+  constructor(params) {
+    var _a, _b;
+    super({
+      name: (_a = params.name) != null ? _a : params.tool.name,
+      description: (_b = params.tool.description) != null ? _b : ""
+    });
+    this.webmcpTool = params.tool;
+    this.doc = params.document;
+  }
+  /**
+   * The tool's JSON Schema as an object.
+   *
+   * `inputSchema` is specified as an object, but a browser handing back a JSON
+   * string would otherwise convert to a parameterless declaration, leaving the
+   * model no argument names to fill in — it then calls the tool with `{}`.
+   */
+  resolveInputSchema() {
+    const raw = this.webmcpTool.inputSchema;
+    if (raw == null) return void 0;
+    if (typeof raw === "string") {
+      try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+      } catch {
+        logger.warn(
+          `WebMCP tool '${this.webmcpTool.name}' has an inputSchema string that is not valid JSON; exposing it with no parameters.`
+        );
+        return void 0;
+      }
+    }
+    if (typeof raw === "object") return raw;
+    return void 0;
+  }
+  _getDeclaration() {
+    var _a;
+    const schema = this.resolveInputSchema();
+    const parameters = schema ? (_a = toGeminiSchema(schema)) != null ? _a : { type: Type.OBJECT, properties: {} } : { type: Type.OBJECT, properties: {} };
+    if (schema && !parameters.properties) {
+      logger.warn(
+        `WebMCP tool '${this.webmcpTool.name}' declared an inputSchema that produced no parameters; the model will be unable to pass arguments.`
+      );
+    }
+    return {
+      name: this.name,
+      description: this.description,
+      parameters
+    };
+  }
+  async checkRequireConfirmation() {
+    var _a;
+    return !!((_a = this.webmcpTool.annotations) == null ? void 0 : _a.consequentialHint);
+  }
+  async runAsync(request) {
+    var _a, _b;
+    const modelContext = getModelContext(this.doc);
+    if (!modelContext) {
+      throw new Error(
+        "document.modelContext is unavailable, so WebMCP tools cannot be executed. WebMCP requires a browser with the API enabled."
+      );
+    }
+    const args = (_a = request.args) != null ? _a : {};
+    const signal = (_b = request.toolContext) == null ? void 0 : _b.abortSignal;
+    const options = signal ? { signal } : void 0;
+    const invoke = /* @__PURE__ */ __name((encoding) => modelContext.executeTool(
+      this.webmcpTool,
+      encoding === "json-string" ? JSON.stringify(args) : args,
+      options
+    ), "invoke");
+    const known = argEncodingByContext.get(modelContext);
+    if (known) {
+      return await invoke(known);
+    }
+    let firstResult;
+    try {
+      firstResult = await invoke("object");
+      if (!isArgParseFailure(firstResult)) {
+        argEncodingByContext.set(modelContext, "object");
+        return firstResult;
+      }
+    } catch (err) {
+      if (!isArgParseFailure(err)) throw err;
+      firstResult = err;
+    }
+    const retried = await invoke("json-string");
+    if (isArgParseFailure(retried)) {
+      return firstResult;
+    }
+    argEncodingByContext.set(modelContext, "json-string");
+    logger.debug(
+      "This browser expects JSON-string WebMCP tool arguments; using that encoding."
+    );
+    return retried;
+  }
+};
+__name(_WebMCPTool, "WebMCPTool");
+let WebMCPTool = _WebMCPTool;
+export {
+  WebMCPTool
+};

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/esm/tools/webmcp/webmcp_types.js

@@ -0,0 +1,22 @@
+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 getModelContext(doc) {
+  const target = doc != null ? doc : globalThis.document;
+  return target == null ? void 0 : target.modelContext;
+}
+__name(getModelContext, "getModelContext");
+function isWebMCPSupported(doc) {
+  return !!getModelContext(doc);
+}
+__name(isWebMCPSupported, "isWebMCPSupported");
+export {
+  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
 };