@google/adk 2.3.0 → 2.5.0

package/dist/cjs/tools/computer_use/computer_use_tool.js

@@ -0,0 +1,244 @@
+/**
+  * @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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var computer_use_tool_exports = {};
+__export(computer_use_tool_exports, {
+  ComputerUseTool: () => ComputerUseTool,
+  isComputerUseTool: () => isComputerUseTool
+});
+module.exports = __toCommonJS(computer_use_tool_exports);
+var import_env_aware_utils = require("../../utils/env_aware_utils.js");
+var import_experimental = require("../../utils/experimental.js");
+var import_logger = require("../../utils/logger.js");
+var import_function_tool = require("../function_tool.js");
+var import_base_computer = require("./base_computer.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const DEFAULT_VIRTUAL_SCREEN_SIZE = [1e3, 1e3];
+const X_COORDINATE_FIELDS = ["x", "destination_x", "start_x", "end_x"];
+const Y_COORDINATE_FIELDS = ["y", "destination_y", "start_y", "end_y"];
+const INTEGER_STRING = /^-?\d+$/;
+const REQUIRE_CONFIRMATION = "require_confirmation";
+const COMPUTER_USE_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.computerUseTool"
+);
+function isComputerUseTool(obj) {
+  return typeof obj === "object" && obj !== null && COMPUTER_USE_TOOL_SIGNATURE_SYMBOL in obj && obj[COMPUTER_USE_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isComputerUseTool, "isComputerUseTool");
+let ComputerUseTool = class extends (_b = import_function_tool.FunctionTool, _a = COMPUTER_USE_TOOL_SIGNATURE_SYMBOL, _b) {
+  /**
+   * @param options The options for the tool.
+   * @throws {Error} If `screenSize` or `virtualScreenSize` is not a pair of
+   *     positive numbers.
+   */
+  constructor(options) {
+    var _a2;
+    (0, import_base_computer.checkComputerUseEnabled)();
+    const virtualScreenSize = (_a2 = options.virtualScreenSize) != null ? _a2 : DEFAULT_VIRTUAL_SCREEN_SIZE;
+    checkScreenSize("screenSize", options.screenSize);
+    checkScreenSize("virtualScreenSize", virtualScreenSize);
+    const func = options.execute;
+    super({
+      name: options.name,
+      description: options.description,
+      parameters: options.parameters,
+      execute: /* @__PURE__ */ __name((input, toolContext) => func(isRecord(input) ? input : {}, toolContext), "execute")
+    });
+    /** A unique symbol to identify ADK computer use tool class. */
+    this[_a] = true;
+    this.func = func;
+    this.screenSize = options.screenSize;
+    this.virtualScreenSize = virtualScreenSize;
+  }
+  /**
+   * Runs the computer control function with scaled coordinates.
+   *
+   * @param request The tool request containing arguments and tool context.
+   * @returns The function's result, with a {@link ComputerState} converted to
+   *     a response carrying the base64-encoded screenshot.
+   * @throws {Error} If a coordinate is not numeric, or the function returns a
+   *     state with no screenshot.
+   */
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    const confirmation = toolContext.toolConfirmation;
+    if (!confirmation) {
+      const safetyDecision = getSafetyDecision(args);
+      if ((safetyDecision == null ? void 0 : safetyDecision.decision) === REQUIRE_CONFIRMATION) {
+        toolContext.requestConfirmation({
+          hint: typeof safetyDecision.explanation === "string" && safetyDecision.explanation ? safetyDecision.explanation : "This computer use action requires safety confirmation."
+        });
+        toolContext.actions.skipSummarization = true;
+        return {
+          error: "This tool call requires confirmation, please approve or reject."
+        };
+      }
+    } else if (!confirmation.confirmed) {
+      return { error: "This tool call is rejected." };
+    }
+    const scaledArgs = this.scaleCoordinates(args);
+    const result = await super.runAsync({ args: scaledArgs, toolContext });
+    let response = result;
+    if (isComputerState(result)) {
+      if (!result.screenshot) {
+        throw new Error(
+          "A computer action returned a state with no screenshot"
+        );
+      }
+      response = {
+        image: { mimetype: "image/png", data: (0, import_env_aware_utils.base64Encode)(result.screenshot) },
+        url: result.url
+      };
+    }
+    if (confirmation == null ? void 0 : confirmation.confirmed) {
+      const acknowledged = isRecord(response) ? response : { result: response };
+      acknowledged["safety_acknowledgement"] = "true";
+      return acknowledged;
+    }
+    return response;
+  }
+  /**
+   * Whether this call needs user confirmation: when the model marked it with
+   * a `safety_decision` of `require_confirmation`, or when the base tool says
+   * so.
+   *
+   * @param args The arguments the tool would run with.
+   * @param toolContext The context of the call, when there is one.
+   * @returns Whether the call requires confirmation.
+   */
+  async checkRequireConfirmation(args, toolContext) {
+    var _a2;
+    if (((_a2 = getSafetyDecision(args)) == null ? void 0 : _a2.decision) === REQUIRE_CONFIRMATION) {
+      return true;
+    }
+    return super.checkRequireConfirmation(args, toolContext);
+  }
+  /**
+   * Adds nothing to the request: {@link ComputerUseToolset} adds the single
+   * computer use configuration and registers its tools by name.
+   */
+  async processLlmRequest(_request) {
+  }
+  /** Returns a copy of `args` with every coordinate scaled to the screen. */
+  scaleCoordinates(args) {
+    const scaled = { ...args };
+    delete scaled["safety_decision"];
+    for (const field of X_COORDINATE_FIELDS) {
+      if (field in scaled) {
+        scaled[field] = scaleCoordinate({
+          field,
+          value: scaled[field],
+          virtual: this.virtualScreenSize[0],
+          actual: this.screenSize[0]
+        });
+      }
+    }
+    for (const field of Y_COORDINATE_FIELDS) {
+      if (field in scaled) {
+        scaled[field] = scaleCoordinate({
+          field,
+          value: scaled[field],
+          virtual: this.virtualScreenSize[1],
+          actual: this.screenSize[1]
+        });
+      }
+    }
+    return scaled;
+  }
+};
+__name(ComputerUseTool, "ComputerUseTool");
+ComputerUseTool = __decorateClass([
+  import_experimental.experimental
+], ComputerUseTool);
+function scaleCoordinate({
+  field,
+  value,
+  virtual,
+  actual
+}) {
+  const numeric = typeof value === "string" && INTEGER_STRING.test(value) ? Number(value) : value;
+  if (typeof numeric !== "number" || !Number.isFinite(numeric)) {
+    throw new Error(
+      `${field} coordinate must be numeric, got ${typeof value} ${JSON.stringify(value)}`
+    );
+  }
+  const scaled = Math.max(
+    0,
+    Math.min(Math.trunc(numeric / virtual * actual), actual - 1)
+  );
+  import_logger.logger.debug(`Normalized ${field}: ${numeric} -> ${scaled}`);
+  return scaled;
+}
+__name(scaleCoordinate, "scaleCoordinate");
+function checkScreenSize(name, size) {
+  if (!Array.isArray(size) || size.length !== 2) {
+    throw new Error(`${name} must be a pair of (width, height)`);
+  }
+  if (!size.every((dimension) => Number.isFinite(dimension) && dimension > 0)) {
+    throw new Error(`${name} dimensions must be positive`);
+  }
+}
+__name(checkScreenSize, "checkScreenSize");
+function getSafetyDecision(args) {
+  const decision = args["safety_decision"];
+  return isRecord(decision) ? decision : void 0;
+}
+__name(getSafetyDecision, "getSafetyDecision");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function isComputerState(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 0 || keys.some((k) => k !== "screenshot" && k !== "url")) {
+    return false;
+  }
+  const { screenshot, url } = value;
+  return (screenshot === void 0 || screenshot instanceof Uint8Array) && (url === void 0 || typeof url === "string");
+}
+__name(isComputerState, "isComputerState");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComputerUseTool,
+  isComputerUseTool
+});

package/dist/cjs/tools/computer_use/computer_use_toolset.js

@@ -0,0 +1,360 @@
+/**
+  * @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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var computer_use_toolset_exports = {};
+__export(computer_use_toolset_exports, {
+  ComputerUseToolset: () => ComputerUseToolset,
+  adaptComputerUseTool: () => adaptComputerUseTool,
+  isComputerUseToolset: () => isComputerUseToolset
+});
+module.exports = __toCommonJS(computer_use_toolset_exports);
+var import_genai = require("@google/genai");
+var import_experimental = require("../../utils/experimental.js");
+var import_logger = require("../../utils/logger.js");
+var import_model_name = require("../../utils/model_name.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_base_computer = require("./base_computer.js");
+var import_computer_use_actions = require("./computer_use_actions.js");
+var import_computer_use_tool = require("./computer_use_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const DIRECT_EXCLUSION_MAP = Object.freeze({
+  // Legacy -> modern.
+  click_at: ["click"],
+  hover_at: ["move"],
+  type_text_at: ["type"],
+  type_text: ["type"],
+  scroll_at: ["scroll"],
+  // Whole-page scroll has no modern counterpart.
+  scroll_document: [],
+  current_state: ["take_screenshot"],
+  key_combination: ["press_key", "hotkey"],
+  wait_5_seconds: ["wait"],
+  // Modern -> legacy.
+  click: ["click_at"],
+  move: ["hover_at"],
+  type: ["type_text_at"],
+  // Does not drop scroll_document.
+  scroll: ["scroll_at"],
+  take_screenshot: ["current_state"],
+  // key_combination is dropped only when both of these are excluded.
+  press_key: [],
+  hotkey: [],
+  wait: ["wait_5_seconds"]
+});
+const LEGACY_EXCLUSION_NAMES = /* @__PURE__ */ new Set([
+  "click_at",
+  "hover_at",
+  "type_text_at",
+  "type_text",
+  "scroll_at",
+  "scroll_document",
+  "current_state",
+  "key_combination",
+  "wait_5_seconds"
+]);
+const MODERN_EXCLUSION_NAMES = /* @__PURE__ */ new Set([
+  "click",
+  "move",
+  "type",
+  "scroll",
+  "take_screenshot",
+  "press_key",
+  "hotkey",
+  "wait",
+  ...import_computer_use_actions.OPTIONAL_MOUSE_ACTIONS,
+  ...import_computer_use_actions.OPTIONAL_KEY_ACTIONS
+]);
+const TYPING_ACTIONS = ["type", "type_text_at", "type_text"];
+const computerQueues = /* @__PURE__ */ new WeakMap();
+function expandLocalExclusions(excludedNames) {
+  var _a2;
+  const expanded = new Set(excludedNames);
+  for (const name of excludedNames) {
+    for (const counterpart of (_a2 = DIRECT_EXCLUSION_MAP[name]) != null ? _a2 : []) {
+      expanded.add(counterpart);
+    }
+  }
+  if (TYPING_ACTIONS.some((name) => expanded.has(name))) {
+    TYPING_ACTIONS.forEach((name) => expanded.add(name));
+  }
+  if (expanded.has("press_key") && expanded.has("hotkey")) {
+    expanded.add("key_combination");
+  }
+  return expanded;
+}
+__name(expandLocalExclusions, "expandLocalExclusions");
+function resolveExcludedPredefinedFunctions({
+  excludedNames,
+  model,
+  unimplementedActions
+}) {
+  var _a2;
+  const major = (0, import_model_name.getGeminiMajorVersion)(model);
+  if (major !== void 0 && major < 3) {
+    if (excludedNames === void 0) {
+      return void 0;
+    }
+    const bothModernKeys = excludedNames.includes("press_key") && excludedNames.includes("hotkey");
+    const resolved2 = [];
+    for (const name of excludedNames) {
+      if (name === "press_key" || name === "hotkey") {
+        if (bothModernKeys) {
+          resolved2.push("key_combination");
+        }
+      } else if (name === "type_text") {
+        resolved2.push("type_text_at");
+      } else if (MODERN_EXCLUSION_NAMES.has(name)) {
+        resolved2.push(...(_a2 = DIRECT_EXCLUSION_MAP[name]) != null ? _a2 : []);
+      } else {
+        resolved2.push(name);
+      }
+    }
+    return [...new Set(resolved2)];
+  }
+  const resolved = [];
+  for (const name of excludedNames != null ? excludedNames : []) {
+    if (LEGACY_EXCLUSION_NAMES.has(name)) {
+      resolved.push(...DIRECT_EXCLUSION_MAP[name]);
+    } else {
+      resolved.push(name);
+    }
+  }
+  if (major !== void 0 && major >= 3) {
+    resolved.push(...unimplementedActions);
+  }
+  const deduped = [...new Set(resolved)];
+  if (deduped.length === 0 && excludedNames === void 0) {
+    return void 0;
+  }
+  return deduped;
+}
+__name(resolveExcludedPredefinedFunctions, "resolveExcludedPredefinedFunctions");
+async function runExclusive(computer, action) {
+  var _a2;
+  const previous = (_a2 = computerQueues.get(computer)) != null ? _a2 : Promise.resolve();
+  const result = previous.then(action);
+  computerQueues.set(
+    computer,
+    result.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return result;
+}
+__name(runExclusive, "runExclusive");
+function toGenaiEnvironment(environment) {
+  switch (environment) {
+    case import_base_computer.ComputerEnvironment.ENVIRONMENT_UNSPECIFIED:
+      return import_genai.Environment.ENVIRONMENT_UNSPECIFIED;
+    case import_base_computer.ComputerEnvironment.ENVIRONMENT_BROWSER:
+      return import_genai.Environment.ENVIRONMENT_BROWSER;
+    default: {
+      const exhaustive = environment;
+      throw new Error(`Unknown computer environment: ${exhaustive}`);
+    }
+  }
+}
+__name(toGenaiEnvironment, "toGenaiEnvironment");
+function isComputerUseConfig(tool) {
+  return "computerUse" in tool && tool.computerUse !== void 0;
+}
+__name(isComputerUseConfig, "isComputerUseConfig");
+async function adaptComputerUseTool({
+  methodName,
+  adapter,
+  llmRequest
+}) {
+  if (!import_computer_use_actions.LEGACY_ACTION_NAMES.includes(methodName)) {
+    import_logger.logger.warn(`Method ${methodName} is not a valid BaseComputer method`);
+    return;
+  }
+  const original = Object.hasOwn(llmRequest.toolsDict, methodName) ? llmRequest.toolsDict[methodName] : void 0;
+  if (!(0, import_computer_use_tool.isComputerUseTool)(original)) {
+    import_logger.logger.warn(`Method ${methodName} not found in toolsDict`);
+    return;
+  }
+  const adapted = await adapter(original.func);
+  llmRequest.toolsDict[adapted.name] = new import_computer_use_tool.ComputerUseTool({
+    ...adapted,
+    screenSize: original.screenSize,
+    virtualScreenSize: original.virtualScreenSize
+  });
+  if (adapted.name !== methodName) {
+    delete llmRequest.toolsDict[methodName];
+  }
+  import_logger.logger.debug(`Adapted tool ${methodName} to ${adapted.name}`);
+}
+__name(adaptComputerUseTool, "adaptComputerUseTool");
+const COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.computerUseToolset"
+);
+function isComputerUseToolset(obj) {
+  return typeof obj === "object" && obj !== null && COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isComputerUseToolset, "isComputerUseToolset");
+let ComputerUseToolset = class extends (_b = import_base_toolset.BaseToolset, _a = COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  /**
+   * @param options The computer and its configuration.
+   */
+  constructor(options) {
+    var _a2;
+    (0, import_base_computer.checkComputerUseEnabled)();
+    super([]);
+    /** A unique symbol to identify ADK computer use toolset class. */
+    this[_a] = true;
+    this.closed = false;
+    this.computer = options.computer;
+    this.excludedPredefinedFunctions = options.excludedPredefinedFunctions;
+    this.allowPrivateNetworkAccess = (_a2 = options.allowPrivateNetworkAccess) != null ? _a2 : false;
+  }
+  /**
+   * Returns a tool for every action the computer supports, except the
+   * excluded ones. The computer is initialized on the first call, and the
+   * tools are cached until {@link close}.
+   */
+  async getTools() {
+    var _a2;
+    (_a2 = this.loadingTools) != null ? _a2 : this.loadingTools = this.loadTools();
+    try {
+      return await this.loadingTools;
+    } catch (error) {
+      this.loadingTools = void 0;
+      throw error;
+    }
+  }
+  /**
+   * Closes the computer and drops the cached tools. The next call to
+   * {@link getTools} initializes the computer again.
+   */
+  async close() {
+    if (!this.closed) {
+      await this.computer.close();
+      this.closed = true;
+    }
+    this.initializing = void 0;
+    this.loadingTools = void 0;
+  }
+  /**
+   * Registers the computer use tools in the request and adds the computer use
+   * configuration, unless the request already has one.
+   *
+   * @param _toolContext The context of the tool.
+   * @param llmRequest The outgoing request.
+   */
+  async processLlmRequest(_toolContext, llmRequest) {
+    var _a2, _b2, _c;
+    for (const tool of await this.getTools()) {
+      llmRequest.toolsDict[tool.name] = tool;
+    }
+    (_a2 = llmRequest.config) != null ? _a2 : llmRequest.config = {};
+    (_c = (_b2 = llmRequest.config).tools) != null ? _c : _b2.tools = [];
+    if (llmRequest.config.tools.some(isComputerUseConfig)) {
+      import_logger.logger.debug("Computer use already configured in LLM request");
+      return;
+    }
+    const environment = toGenaiEnvironment(await this.computer.environment());
+    const excludedPredefinedFunctions = resolveExcludedPredefinedFunctions({
+      excludedNames: this.excludedPredefinedFunctions,
+      model: llmRequest.model,
+      unimplementedActions: (0, import_computer_use_actions.unimplementedOptionalActions)(this.computer)
+    });
+    llmRequest.config.tools.push({
+      computerUse: excludedPredefinedFunctions === void 0 ? { environment } : { environment, excludedPredefinedFunctions }
+    });
+    import_logger.logger.debug(
+      `Added computer use tool with environment: ${environment}, excluded functions: ${excludedPredefinedFunctions}`
+    );
+  }
+  ensureInitialized() {
+    var _a2;
+    (_a2 = this.initializing) != null ? _a2 : this.initializing = this.computer.initialize().then(
+      () => {
+        this.closed = false;
+      },
+      (error) => {
+        this.initializing = void 0;
+        throw error;
+      }
+    );
+    return this.initializing;
+  }
+  async loadTools() {
+    var _a2;
+    await this.ensureInitialized();
+    const screenSize = await this.computer.screenSize();
+    const excluded = expandLocalExclusions(
+      (_a2 = this.excludedPredefinedFunctions) != null ? _a2 : []
+    );
+    return (0, import_computer_use_actions.createComputerActions)({
+      computer: this.computer,
+      allowPrivateNetworkAccess: this.allowPrivateNetworkAccess
+    }).filter((action) => !excluded.has(action.name)).map(
+      (action) => new import_computer_use_tool.ComputerUseTool({
+        name: action.name,
+        description: action.description,
+        parameters: action.parameters,
+        execute: this.bindToComputer(action),
+        screenSize
+      })
+    );
+  }
+  /**
+   * Wraps an action so it runs exclusively on the computer, after the
+   * computer has prepared for the calling session.
+   */
+  bindToComputer(action) {
+    const computer = this.computer;
+    return (args, toolContext) => runExclusive(computer, async () => {
+      if (toolContext) {
+        await computer.prepare(toolContext);
+      }
+      return action.execute(args);
+    });
+  }
+};
+__name(ComputerUseToolset, "ComputerUseToolset");
+ComputerUseToolset = __decorateClass([
+  import_experimental.experimental
+], ComputerUseToolset);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComputerUseToolset,
+  adaptComputerUseTool,
+  isComputerUseToolset
+});

package/dist/cjs/tools/function_tool.js

@@ -59,9 +59,10 @@ function toResponseSchema(response) {
     return (0, import_simple_zod_to_json.zodObjectToSchema)(response);
   }
   if (typeof response === "object" && response !== null && "safeParse" in response && typeof response.safeParse === "function") {
-    return (_a2 = (0, import_gemini_schema_util.toGeminiSchema)(
-      (0, import_schema.toJsonSchema)(response)
-    )) != null ? _a2 : { type: import_genai.Type.TYPE_UNSPECIFIED };
+    const jsonSchema = (0, import_schema.toJsonSchema)(response);
+    return (_a2 = (0, import_gemini_schema_util.toGeminiSchema)(jsonSchema)) != null ? _a2 : {
+      type: import_genai.Type.TYPE_UNSPECIFIED
+    };
   }
   return response;
 }
@@ -281,6 +282,11 @@ function annotateNullableFields(schema) {
     if (!isPlainRecord(propertySchema)) {
       continue;
     }
+    const propType = propertySchema["type"];
+    if (propType === null || propType === "null" || propType === import_genai.Type.NULL) {
+      propertySchema["type"] = import_genai.Type.OBJECT;
+      propertySchema["nullable"] = true;
+    }
     const anyOf = propertySchema["anyOf"];
     if (!Array.isArray(anyOf)) {
       continue;
@@ -383,8 +389,12 @@ function processParameterSchema(vertexai, schema) {
 __name(processParameterSchema, "processParameterSchema");
 function mapPropertySchemaType(propertySchema) {
   var _a2, _b2;
-  if (typeof propertySchema["type"] === "string") {
-    propertySchema["type"] = (_a2 = SCHEMA_TYPE_MAP[propertySchema["type"]]) != null ? _a2 : import_genai.Type.TYPE_UNSPECIFIED;
+  const rawType = propertySchema["type"];
+  if (rawType === null || rawType === "null" || rawType === import_genai.Type.NULL) {
+    propertySchema["type"] = import_genai.Type.OBJECT;
+    propertySchema["nullable"] = true;
+  } else if (typeof rawType === "string") {
+    propertySchema["type"] = (_a2 = SCHEMA_TYPE_MAP[rawType]) != null ? _a2 : import_genai.Type.TYPE_UNSPECIFIED;
     if (propertySchema["type"] === import_genai.Type.ARRAY && isPlainRecord(propertySchema["items"])) {
       mapPropertySchemaType(propertySchema["items"]);
     }

package/dist/cjs/tools/google_api_tool/google_api_tool.js

@@ -52,7 +52,7 @@ function isGoogleApiTool(obj) {
 }
 __name(isGoogleApiTool, "isGoogleApiTool");
 let GoogleApiTool = class extends (_b = import_base_tool.BaseTool, _a = GOOGLE_API_TOOL_SIGNATURE_SYMBOL, _b) {
-  constructor(restApiTool) {
+  constructor(restApiTool, options = {}) {
     super({
       name: restApiTool.name,
       description: restApiTool.description,
@@ -60,6 +60,9 @@ let GoogleApiTool = class extends (_b = import_base_tool.BaseTool, _a = GOOGLE_A
     });
     this[_a] = true;
     this.restApiTool = restApiTool;
+    if (options.clientId !== void 0 || options.clientSecret !== void 0) {
+      this.configureAuth(options.clientId, options.clientSecret);
+    }
   }
   _getDeclaration() {
     return this.restApiTool._getDeclaration();