@google/adk 2.2.1 → 2.4.0

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

@@ -0,0 +1,263 @@
+/**
+  * @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,
+  IntegrationConnectorTool: () => import_integration_connector_tool.IntegrationConnectorTool
+});
+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_logger = require("../../utils/logger.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_auth_helpers = require("../openapi_tool/auth/auth_helpers.js");
+var import_openapi_spec_parser = require("../openapi_tool/openapi_spec_parser/openapi_spec_parser.js");
+var import_openapi_toolset = require("../openapi_tool/openapi_toolset.js");
+var import_rest_api_tool = require("../openapi_tool/rest_api_tool.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");
+var import_integration_connector_tool = require("./integration_connector_tool.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, or a
+   *   connection with at least one entity operation or action.
+   */
+  constructor(options) {
+    var _a, _b, _c;
+    super((_a = options.toolFilter) != null ? _a : []);
+    this.openApiToolsets = [];
+    const hasIntegration = Boolean(options.integration);
+    const hasConnection = Boolean(
+      options.connection && (Object.keys((_b = options.entityOperations) != null ? _b : {}).length > 0 || ((_c = options.actions) != null ? _c : []).length > 0)
+    );
+    if (!hasIntegration && !hasConnection) {
+      throw new Error(
+        "Either integration 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(context) {
+    if (!this.toolsPromise) {
+      this.toolsPromise = this.loadTools();
+    }
+    try {
+      const tools = await this.toolsPromise;
+      return tools.filter((tool) => this.isToolSelected(tool, context));
+    } catch (e) {
+      this.toolsPromise = void 0;
+      throw e;
+    }
+  }
+  async close() {
+    for (const openApiToolset of this.openApiToolsets) {
+      await openApiToolset.close();
+    }
+  }
+  async loadTools() {
+    var _a, _b;
+    const {
+      project,
+      location,
+      integration,
+      triggers,
+      connection,
+      entityOperations,
+      actions,
+      toolNamePrefix,
+      toolInstructions = "",
+      serviceAccountJson,
+      authScheme,
+      authCredential: dynamicAuthCredential
+    } = this.options;
+    const resolvedToolName = toolNamePrefix != null ? toolNamePrefix : "";
+    this.openApiToolsets = [];
+    const integrationClient = new import_integration_client.IntegrationClient({
+      project,
+      location,
+      integration,
+      triggers,
+      connection,
+      entityOperations,
+      actions,
+      serviceAccountJson
+    });
+    const authCredential = buildAuthCredential(serviceAccountJson);
+    const toolsByName = /* @__PURE__ */ new Map();
+    if (integration) {
+      const specDict2 = await integrationClient.getOpenApiSpecForIntegration();
+      const spec2 = toOpenApiDocument(specDict2);
+      for (const [path, pathItem] of Object.entries((_a = spec2.paths) != null ? _a : {})) {
+        const openApiToolset = new import_openapi_toolset.OpenAPIToolset({
+          specDict: { ...spec2, paths: { [removeFragment(path)]: pathItem } },
+          authCredential,
+          authScheme: AUTH_SCHEME
+        });
+        this.openApiToolsets.push(openApiToolset);
+        const tools = await openApiToolset.getTools();
+        for (const tool of tools) {
+          toolsByName.set(tool.name, tool);
+        }
+      }
+      return [...toolsByName.values()];
+    }
+    const connectionName = connection != null ? connection : "";
+    const connectionDetails = await new import_connections_client.ConnectionsClient({
+      project,
+      location,
+      connection: connectionName,
+      serviceAccountJson
+    }).getConnectionDetails();
+    if (authScheme && dynamicAuthCredential && !connectionDetails.authOverrideEnabled) {
+      import_logger.logger.warn(
+        "Authentication schema and credentials are not used because authOverrideEnabled is not enabled in the connection."
+      );
+    }
+    const specDict = await integrationClient.getOpenApiSpecForConnection(
+      resolvedToolName,
+      toolInstructions
+    );
+    const spec = toOpenApiDocument(specDict);
+    addDynamicAuthConfigToConnectionSchemas(spec);
+    const operations = new import_openapi_spec_parser.OpenApiSpecParser().parse(spec);
+    for (const openApiOperation of operations) {
+      const operationObject = (0, import_json_utils.toJsonObject)(openApiOperation.operation);
+      const operation = toStringValue(operationObject["x-operation"]);
+      const entity = toStringValue(operationObject["x-entity"]);
+      const action = toStringValue(operationObject["x-action"]);
+      const restApiTool = (0, import_rest_api_tool.createRestApiTool)({
+        ...openApiOperation,
+        endpoint: {
+          ...openApiOperation.endpoint,
+          path: removeFragment(openApiOperation.endpoint.path)
+        }
+      });
+      restApiTool.configureAuthScheme(AUTH_SCHEME);
+      restApiTool.configureAuthCredential(authCredential);
+      const tool = new import_integration_connector_tool.IntegrationConnectorTool({
+        name: restApiTool.name,
+        description: restApiTool.description,
+        connectionName: (_b = connectionDetails.name) != null ? _b : "",
+        connectionHost: connectionDetails.host,
+        connectionServiceName: connectionDetails.serviceName,
+        entity,
+        action,
+        operation,
+        restApiTool,
+        authScheme: connectionDetails.authOverrideEnabled ? authScheme : void 0,
+        authCredential: connectionDetails.authOverrideEnabled ? dynamicAuthCredential : void 0
+      });
+      toolsByName.set(tool.name, tool);
+    }
+    return [...toolsByName.values()];
+  }
+};
+__name(ApplicationIntegrationToolset, "ApplicationIntegrationToolset");
+ApplicationIntegrationToolset = __decorateClass([
+  import_experimental.experimental
+], ApplicationIntegrationToolset);
+function addDynamicAuthConfigToConnectionSchemas(spec) {
+  var _a;
+  const schemas = (_a = spec.components) == null ? void 0 : _a.schemas;
+  if (!schemas) {
+    return;
+  }
+  for (const [schemaName, schema] of Object.entries(schemas)) {
+    if (schemaName.endsWith("_Request") && (0, import_json_utils.isJsonObject)(schema) && (0, import_json_utils.isJsonObject)(schema.properties) && !("query" in schema.properties) && !("dynamicAuthConfig" in schema.properties)) {
+      schema.properties = {
+        ...schema.properties,
+        dynamicAuthConfig: {
+          $ref: "#/components/schemas/dynamicAuthConfig"
+        }
+      };
+    }
+  }
+}
+__name(addDynamicAuthConfigToConnectionSchemas, "addDynamicAuthConfigToConnectionSchemas");
+function toOpenApiDocument(specDict) {
+  return specDict;
+}
+__name(toOpenApiDocument, "toOpenApiDocument");
+function toStringValue(value) {
+  return typeof value === "string" ? value : "";
+}
+__name(toStringValue, "toStringValue");
+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,
+  IntegrationConnectorTool
+});

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
+});