@google/adk 2.2.1 → 2.3.0

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

@@ -0,0 +1,185 @@
+/**
+  * @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 application_integration_toolset_exports = {};
+__export(application_integration_toolset_exports, {
+  ApplicationIntegrationToolset: () => ApplicationIntegrationToolset
+});
+module.exports = __toCommonJS(application_integration_toolset_exports);
+var import_auth_credential = require("../../auth/auth_credential.js");
+var import_experimental = require("../../utils/experimental.js");
+var import_json_utils = require("../../utils/json_utils.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_auth_helpers = require("../openapi_tool/auth/auth_helpers.js");
+var import_openapi_toolset = require("../openapi_tool/openapi_toolset.js");
+var import_cloud_request = require("./clients/cloud_request.js");
+var import_connections_client = require("./clients/connections_client.js");
+var import_integration_client = require("./clients/integration_client.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const AUTH_SCHEME = {
+  type: "http",
+  scheme: "bearer",
+  bearerFormat: "JWT"
+};
+let ApplicationIntegrationToolset = class extends import_base_toolset.BaseToolset {
+  /**
+   * @throws Error Unless the options name either an integration and a trigger,
+   *   or a connection with at least one entity operation or action.
+   */
+  constructor(options) {
+    var _a, _b;
+    super([]);
+    const hasIntegration = Boolean(options.integration && options.trigger);
+    const hasConnection = Boolean(
+      options.connection && (Object.keys((_a = options.entityOperations) != null ? _a : {}).length > 0 || ((_b = options.actions) != null ? _b : []).length > 0)
+    );
+    if (!hasIntegration && !hasConnection) {
+      throw new Error(
+        "Either (integration and trigger) or (connection and (entityOperations or actions)) should be provided."
+      );
+    }
+    this.options = options;
+  }
+  /**
+   * Returns the generated tools.
+   *
+   * The first call fetches the spec and builds the tools. Concurrent calls
+   * share that load. When it fails, the next call tries again.
+   */
+  async getTools() {
+    if (!this.toolsPromise) {
+      this.toolsPromise = this.loadTools();
+    }
+    try {
+      return await this.toolsPromise;
+    } catch (e) {
+      this.toolsPromise = void 0;
+      throw e;
+    }
+  }
+  async close() {
+  }
+  async loadTools() {
+    var _a;
+    const {
+      project,
+      location,
+      integration,
+      trigger,
+      connection,
+      entityOperations,
+      actions,
+      toolName = "",
+      toolInstructions = "",
+      serviceAccountJson
+    } = this.options;
+    const integrationClient = new import_integration_client.IntegrationClient({
+      project,
+      location,
+      integration,
+      trigger,
+      connection,
+      entityOperations,
+      actions,
+      serviceAccountJson
+    });
+    let specDict;
+    if (integration && trigger) {
+      specDict = await integrationClient.getOpenApiSpecForIntegration();
+    } else {
+      const connectionName = connection != null ? connection : "";
+      const { serviceName, host } = await new import_connections_client.ConnectionsClient({
+        project,
+        location,
+        connection: connectionName,
+        serviceAccountJson
+      }).getConnectionDetails();
+      const instructions = `${toolInstructions}ALWAYS use serviceName = ${serviceName}, host = ${host} and the connection name = projects/${project}/locations/${location}/connections/${connectionName} when using this tool. DO NOT ask the user for these values as you already have those.`;
+      specDict = await integrationClient.getOpenApiSpecForConnection(
+        toolName,
+        instructions
+      );
+    }
+    const spec = specDict;
+    const authCredential = buildAuthCredential(serviceAccountJson);
+    const toolsByName = /* @__PURE__ */ new Map();
+    for (const [path, pathItem] of Object.entries((_a = spec.paths) != null ? _a : {})) {
+      const tools = await new import_openapi_toolset.OpenAPIToolset({
+        specDict: { ...spec, paths: { [removeFragment(path)]: pathItem } },
+        authCredential,
+        authScheme: AUTH_SCHEME
+      }).getTools();
+      for (const tool of tools) {
+        toolsByName.set(tool.name, tool);
+      }
+    }
+    return [...toolsByName.values()];
+  }
+};
+__name(ApplicationIntegrationToolset, "ApplicationIntegrationToolset");
+ApplicationIntegrationToolset = __decorateClass([
+  import_experimental.experimental
+], ApplicationIntegrationToolset);
+function buildAuthCredential(serviceAccountJson) {
+  if (!serviceAccountJson) {
+    return {
+      authType: import_auth_credential.AuthCredentialTypes.SERVICE_ACCOUNT,
+      serviceAccount: {
+        useDefaultCredential: true,
+        scopes: [import_cloud_request.CLOUD_PLATFORM_SCOPE]
+      }
+    };
+  }
+  const key = JSON.parse(serviceAccountJson);
+  if (!(0, import_json_utils.isJsonObject)(key)) {
+    throw new Error("serviceAccountJson must hold a JSON object.");
+  }
+  const [, authCredential] = (0, import_auth_helpers.serviceAccountDictToSchemeCredential)(key, [
+    import_cloud_request.CLOUD_PLATFORM_SCOPE
+  ]);
+  return authCredential;
+}
+__name(buildAuthCredential, "buildAuthCredential");
+function removeFragment(path) {
+  const fragmentStart = path.indexOf("#");
+  return fragmentStart === -1 ? path : path.slice(0, fragmentStart);
+}
+__name(removeFragment, "removeFragment");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationIntegrationToolset
+});

package/dist/cjs/tools/application_integration_tool/clients/cloud_request.js

@@ -0,0 +1,133 @@
+/**
+  * @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 cloud_request_exports = {};
+__export(cloud_request_exports, {
+  CLOUD_PLATFORM_SCOPE: () => CLOUD_PLATFORM_SCOPE,
+  CloudPlatformTokenSource: () => CloudPlatformTokenSource,
+  sendCloudRequest: () => sendCloudRequest,
+  unexpectedError: () => unexpectedError
+});
+module.exports = __toCommonJS(cloud_request_exports);
+var import_google_auth_library = require("google-auth-library");
+var import_error_utils = require("../../../utils/error_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+const MISSING_CREDENTIALS_MESSAGE = "Please provide a service account that has the required permissions to access the connection.";
+function unexpectedError(e) {
+  return new Error(`An unexpected error occurred: ${(0, import_error_utils.getErrorMessage)(e)}`, {
+    cause: e
+  });
+}
+__name(unexpectedError, "unexpectedError");
+const _CloudPlatformTokenSource = class _CloudPlatformTokenSource {
+  constructor(serviceAccountJson) {
+    this.serviceAccountJson = serviceAccountJson;
+  }
+  /**
+   * Returns an access token.
+   *
+   * @throws Error When no key is given and Application Default Credentials are
+   *   unavailable, or when no token is issued.
+   */
+  async getAccessToken() {
+    let token;
+    try {
+      token = await this.getAuth().getAccessToken();
+    } catch (e) {
+      if (this.serviceAccountJson) {
+        throw e;
+      }
+      throw new Error(MISSING_CREDENTIALS_MESSAGE, { cause: e });
+    }
+    if (!token) {
+      throw new Error(MISSING_CREDENTIALS_MESSAGE);
+    }
+    return token;
+  }
+  getAuth() {
+    if (!this.auth) {
+      if (this.serviceAccountJson) {
+        const credentials = JSON.parse(this.serviceAccountJson);
+        this.auth = new import_google_auth_library.GoogleAuth({
+          scopes: [CLOUD_PLATFORM_SCOPE],
+          credentials
+        });
+      } else {
+        this.auth = new import_google_auth_library.GoogleAuth({ scopes: [CLOUD_PLATFORM_SCOPE] });
+      }
+    }
+    return this.auth;
+  }
+};
+__name(_CloudPlatformTokenSource, "CloudPlatformTokenSource");
+let CloudPlatformTokenSource = _CloudPlatformTokenSource;
+async function sendCloudRequest(options) {
+  const { url, method, body, tokenSource, invalidRequestMessage } = options;
+  let token;
+  try {
+    token = await tokenSource.getAccessToken();
+  } catch (e) {
+    throw unexpectedError(e);
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+  } catch (e) {
+    throw new Error(`Request error: ${(0, import_error_utils.getErrorMessage)(e)}`, { cause: e });
+  }
+  if (response.status === 400 || response.status === 404) {
+    throw new Error(invalidRequestMessage);
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Request error: HTTP ${response.status} ${response.statusText} for url: ${url}`
+    );
+  }
+  try {
+    return await response.json();
+  } catch (e) {
+    throw unexpectedError(e);
+  }
+}
+__name(sendCloudRequest, "sendCloudRequest");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLOUD_PLATFORM_SCOPE,
+  CloudPlatformTokenSource,
+  sendCloudRequest,
+  unexpectedError
+});