@google/adk 2.2.1 → 2.3.0

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

@@ -0,0 +1,163 @@
+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 {
+  AuthCredentialTypes
+} from "../../auth/auth_credential.js";
+import { experimental } from "../../utils/experimental.js";
+import { isJsonObject } from "../../utils/json_utils.js";
+import { BaseToolset } from "../base_toolset.js";
+import { serviceAccountDictToSchemeCredential } from "../openapi_tool/auth/auth_helpers.js";
+import { OpenAPIToolset } from "../openapi_tool/openapi_toolset.js";
+import { CLOUD_PLATFORM_SCOPE } from "./clients/cloud_request.js";
+import {
+  ConnectionsClient
+} from "./clients/connections_client.js";
+import { IntegrationClient } from "./clients/integration_client.js";
+const AUTH_SCHEME = {
+  type: "http",
+  scheme: "bearer",
+  bearerFormat: "JWT"
+};
+let ApplicationIntegrationToolset = class extends 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 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 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 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([
+  experimental
+], ApplicationIntegrationToolset);
+function buildAuthCredential(serviceAccountJson) {
+  if (!serviceAccountJson) {
+    return {
+      authType: AuthCredentialTypes.SERVICE_ACCOUNT,
+      serviceAccount: {
+        useDefaultCredential: true,
+        scopes: [CLOUD_PLATFORM_SCOPE]
+      }
+    };
+  }
+  const key = JSON.parse(serviceAccountJson);
+  if (!isJsonObject(key)) {
+    throw new Error("serviceAccountJson must hold a JSON object.");
+  }
+  const [, authCredential] = serviceAccountDictToSchemeCredential(key, [
+    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");
+export {
+  ApplicationIntegrationToolset
+};

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

@@ -0,0 +1,103 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleAuth } from "google-auth-library";
+import { getErrorMessage } from "../../../utils/error_utils.js";
+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: ${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 GoogleAuth({
+          scopes: [CLOUD_PLATFORM_SCOPE],
+          credentials
+        });
+      } else {
+        this.auth = new 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: ${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");
+export {
+  CLOUD_PLATFORM_SCOPE,
+  CloudPlatformTokenSource,
+  sendCloudRequest,
+  unexpectedError
+};