@google/adk 2.3.0 → 2.5.0

package/dist/cjs/tools/application_integration_tool/integration_connector_tool.js

@@ -0,0 +1,175 @@
+/**
+  * @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 integration_connector_tool_exports = {};
+__export(integration_connector_tool_exports, {
+  IntegrationConnectorTool: () => IntegrationConnectorTool
+});
+module.exports = __toCommonJS(integration_connector_tool_exports);
+var import_experimental = require("../../utils/experimental.js");
+var import_logger = require("../../utils/logger.js");
+var import_base_tool = require("../base_tool.js");
+var import_tool_auth_handler = require("../openapi_tool/openapi_spec_parser/tool_auth_handler.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DYNAMIC_AUTH_CONFIG_FIELD = "dynamicAuthConfig";
+let IntegrationConnectorTool = class extends import_base_tool.BaseTool {
+  constructor(options) {
+    var _a, _b, _c;
+    super(options);
+    this.connectionName = options.connectionName;
+    this.connectionHost = options.connectionHost;
+    this.connectionServiceName = options.connectionServiceName;
+    this.entity = (_a = options.entity) != null ? _a : "";
+    this.operation = (_b = options.operation) != null ? _b : "";
+    this.action = (_c = options.action) != null ? _c : "";
+    this.restApiTool = options.restApiTool;
+    this.authScheme = options.authScheme;
+    this.authCredential = options.authCredential;
+  }
+  _getDeclaration() {
+    const declaration = this.restApiTool._getDeclaration();
+    const rawParameters = declaration == null ? void 0 : declaration.parameters;
+    let parameters;
+    if (rawParameters) {
+      parameters = { ...rawParameters };
+      if (rawParameters.properties) {
+        const properties = { ...rawParameters.properties };
+        for (const field of IntegrationConnectorTool.EXCLUDE_FIELDS) {
+          delete properties[field];
+        }
+        delete properties[DYNAMIC_AUTH_CONFIG_FIELD];
+        parameters.properties = properties;
+      }
+      if (rawParameters.required) {
+        parameters.required = rawParameters.required.filter(
+          (field) => !IntegrationConnectorTool.EXCLUDE_FIELDS.includes(field) && field !== DYNAMIC_AUTH_CONFIG_FIELD && !IntegrationConnectorTool.OPTIONAL_FIELDS.includes(field)
+        );
+      }
+    }
+    return {
+      name: this.name,
+      description: this.description,
+      parameters
+    };
+  }
+  async runAsync(request) {
+    const toolAuthHandler = import_tool_auth_handler.ToolAuthHandler.fromToolContext(
+      request.toolContext,
+      this.authScheme,
+      this.authCredential
+    );
+    const authResult = await toolAuthHandler.prepareAuthCredentials();
+    if (authResult.state === "pending") {
+      return {
+        pending: true,
+        message: "Needs your authorization to access your data."
+      };
+    }
+    const updatedArgs = {
+      ...request.args,
+      connectionName: this.connectionName,
+      serviceName: this.connectionServiceName,
+      host: this.connectionHost
+    };
+    if (this.entity) {
+      updatedArgs["entity"] = this.entity;
+    }
+    if (this.operation) {
+      updatedArgs["operation"] = this.operation;
+    }
+    if (this.action) {
+      updatedArgs["action"] = this.action;
+    }
+    if (authResult.authCredential) {
+      const token = prepareDynamicEuc(authResult.authCredential);
+      if (!token) {
+        return {
+          error: "The resolved end-user credential has no access token."
+        };
+      }
+      updatedArgs[DYNAMIC_AUTH_CONFIG_FIELD] = {
+        "oauth2_auth_code_flow.access_token": token
+      };
+    }
+    import_logger.logger.debug(`Running tool: ${this.name}`);
+    return this.restApiTool.runAsync({
+      args: updatedArgs,
+      toolContext: request.toolContext
+    });
+  }
+};
+__name(IntegrationConnectorTool, "IntegrationConnectorTool");
+/**
+ * Request fields that {@link IntegrationConnectorTool} injects at runtime and
+ * excludes from the function declaration shown to the model.
+ */
+IntegrationConnectorTool.EXCLUDE_FIELDS = Object.freeze([
+  "connectionName",
+  "serviceName",
+  "host",
+  "entity",
+  "operation",
+  "action"
+]);
+/**
+ * Request fields that {@link IntegrationConnectorTool} removes from the
+ * `required` list in the function declaration shown to the model.
+ */
+IntegrationConnectorTool.OPTIONAL_FIELDS = Object.freeze([
+  "pageSize",
+  "pageToken",
+  "filterClause",
+  "sortByColumns"
+]);
+__decorateClass([
+  import_experimental.experimental
+], IntegrationConnectorTool.prototype, "_getDeclaration", 1);
+__decorateClass([
+  import_experimental.experimental
+], IntegrationConnectorTool.prototype, "runAsync", 1);
+IntegrationConnectorTool = __decorateClass([
+  import_experimental.experimental
+], IntegrationConnectorTool);
+function prepareDynamicEuc(authCredential) {
+  var _a, _b;
+  return (_b = (_a = authCredential.http) == null ? void 0 : _a.credentials) == null ? void 0 : _b.token;
+}
+__name(prepareDynamicEuc, "prepareDynamicEuc");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IntegrationConnectorTool
+});

package/dist/cjs/tools/base_toolset.js

@@ -42,7 +42,7 @@ function isBaseToolset(obj) {
 __name(isBaseToolset, "isBaseToolset");
 _a = BASE_TOOLSET_SIGNATURE_SYMBOL;
 const _BaseToolset = class _BaseToolset {
-  constructor(toolFilter, prefix) {
+  constructor(toolFilter = [], prefix) {
     this.toolFilter = toolFilter;
     this.prefix = prefix;
     this[_a] = true;

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

@@ -0,0 +1,125 @@
+/**
+  * @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 base_computer_exports = {};
+__export(base_computer_exports, {
+  BaseComputer: () => BaseComputer,
+  ComputerEnvironment: () => ComputerEnvironment,
+  checkComputerUseEnabled: () => checkComputerUseEnabled,
+  isBaseComputer: () => isBaseComputer
+});
+module.exports = __toCommonJS(base_computer_exports);
+var import_feature_registry = require("../../features/feature_registry.js");
+var import_experimental = require("../../utils/experimental.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+var ComputerEnvironment = /* @__PURE__ */ ((ComputerEnvironment2) => {
+  ComputerEnvironment2["ENVIRONMENT_UNSPECIFIED"] = "ENVIRONMENT_UNSPECIFIED";
+  ComputerEnvironment2["ENVIRONMENT_BROWSER"] = "ENVIRONMENT_BROWSER";
+  return ComputerEnvironment2;
+})(ComputerEnvironment || {});
+function checkComputerUseEnabled() {
+  if (!(0, import_feature_registry.isFeatureEnabled)(import_feature_registry.FeatureName.COMPUTER_USE)) {
+    throw new Error(`Feature ${import_feature_registry.FeatureName.COMPUTER_USE} is not enabled.`);
+  }
+}
+__name(checkComputerUseEnabled, "checkComputerUseEnabled");
+const BASE_COMPUTER_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseComputer");
+function isBaseComputer(obj) {
+  return typeof obj === "object" && obj !== null && BASE_COMPUTER_SIGNATURE_SYMBOL in obj && obj[BASE_COMPUTER_SIGNATURE_SYMBOL] === true;
+}
+__name(isBaseComputer, "isBaseComputer");
+_a = BASE_COMPUTER_SIGNATURE_SYMBOL;
+let BaseComputer = class {
+  constructor() {
+    /** A unique symbol to identify ADK base computer class. */
+    this[_a] = true;
+    checkComputerUseEnabled();
+  }
+  /** Initializes the computer. */
+  async initialize() {
+  }
+  /** Cleans up the resources of the computer. */
+  async close() {
+  }
+  /**
+   * Called before each tool invocation to prepare resources.
+   *
+   * Override this to set up session-level resources (a sandbox, tokens, and so
+   * on), using the state of `toolContext` for persistence across invocations.
+   *
+   * @param _toolContext The tool context with session state access.
+   */
+  async prepare(_toolContext) {
+  }
+  /**
+   * Types text into the currently focused element.
+   *
+   * By default, this calls {@link keyCombination} once per character in `text`
+   * (and once for `"Enter"` when `pressEnter` is true). Because
+   * `keyCombination` is designed for key names and typically captures a new
+   * screenshot on every call, this fallback costs one round trip and screenshot
+   * per character, and relies on the backend accepting single characters in
+   * `keyCombination`. Subclasses should override this method to use native
+   * bulk text input.
+   *
+   * @param text The text to type.
+   * @param pressEnter Whether to press ENTER after typing.
+   * @returns The current state after typing.
+   */
+  async typeText(text, pressEnter = false) {
+    let state;
+    for (const char of text) {
+      state = await this.keyCombination([char]);
+    }
+    if (pressEnter) {
+      state = await this.keyCombination(["Enter"]);
+    }
+    return state != null ? state : this.currentState();
+  }
+};
+__name(BaseComputer, "BaseComputer");
+BaseComputer = __decorateClass([
+  import_experimental.experimental
+], BaseComputer);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseComputer,
+  ComputerEnvironment,
+  checkComputerUseEnabled,
+  isBaseComputer
+});