@google/adk 2.3.0 → 2.5.0

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

@@ -0,0 +1,149 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
+import { BaseTool } from "../base_tool.js";
+import { ToolAuthHandler } from "../openapi_tool/openapi_spec_parser/tool_auth_handler.js";
+const DYNAMIC_AUTH_CONFIG_FIELD = "dynamicAuthConfig";
+let IntegrationConnectorTool = class extends 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 = 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
+      };
+    }
+    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([
+  experimental
+], IntegrationConnectorTool.prototype, "_getDeclaration", 1);
+__decorateClass([
+  experimental
+], IntegrationConnectorTool.prototype, "runAsync", 1);
+IntegrationConnectorTool = __decorateClass([
+  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");
+export {
+  IntegrationConnectorTool
+};

package/dist/esm/tools/base_toolset.js

@@ -15,7 +15,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/esm/tools/computer_use/base_computer.js

@@ -0,0 +1,99 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+import {
+  FeatureName,
+  isFeatureEnabled
+} from "../../features/feature_registry.js";
+import { experimental } from "../../utils/experimental.js";
+var ComputerEnvironment = /* @__PURE__ */ ((ComputerEnvironment2) => {
+  ComputerEnvironment2["ENVIRONMENT_UNSPECIFIED"] = "ENVIRONMENT_UNSPECIFIED";
+  ComputerEnvironment2["ENVIRONMENT_BROWSER"] = "ENVIRONMENT_BROWSER";
+  return ComputerEnvironment2;
+})(ComputerEnvironment || {});
+function checkComputerUseEnabled() {
+  if (!isFeatureEnabled(FeatureName.COMPUTER_USE)) {
+    throw new Error(`Feature ${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([
+  experimental
+], BaseComputer);
+export {
+  BaseComputer,
+  ComputerEnvironment,
+  checkComputerUseEnabled,
+  isBaseComputer
+};