@google/adk 2.3.0 → 2.5.0

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

@@ -19,16 +19,26 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   AuthCredentialTypes
 } from "../../auth/auth_credential.js";
+import { toSnakeCaseName } from "../../utils/case_utils.js";
 import { experimental } from "../../utils/experimental.js";
-import { isJsonObject } from "../../utils/json_utils.js";
+import {
+  isJsonObject,
+  toJsonObject
+} from "../../utils/json_utils.js";
+import { logger } from "../../utils/logger.js";
 import { BaseToolset } from "../base_toolset.js";
-import { serviceAccountDictToSchemeCredential } from "../openapi_tool/auth/auth_helpers.js";
+import { serviceAccountRecordToSchemeCredential } from "../openapi_tool/auth/auth_helpers.js";
+import { OpenApiSpecParser } from "../openapi_tool/openapi_spec_parser/openapi_spec_parser.js";
 import { OpenAPIToolset } from "../openapi_tool/openapi_toolset.js";
+import { createRestApiTool } from "../openapi_tool/rest_api_tool.js";
 import { CLOUD_PLATFORM_SCOPE } from "./clients/cloud_request.js";
 import {
   ConnectionsClient
 } from "./clients/connections_client.js";
 import { IntegrationClient } from "./clients/integration_client.js";
+import {
+  IntegrationConnectorTool
+} from "./integration_connector_tool.js";
 const AUTH_SCHEME = {
   type: "http",
   scheme: "bearer",
@@ -36,19 +46,20 @@ const AUTH_SCHEME = {
 };
 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.
+   * @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;
-    super([]);
-    const hasIntegration = Boolean(options.integration && options.trigger);
+    var _a, _b, _c;
+    super((_a = options.toolFilter) != null ? _a : []);
+    this.openApiToolsets = [];
+    const hasIntegration = Boolean(options.integration);
     const hasConnection = Boolean(
-      options.connection && (Object.keys((_a = options.entityOperations) != null ? _a : {}).length > 0 || ((_b = options.actions) != null ? _b : []).length > 0)
+      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 and trigger) or (connection and (entityOperations or actions)) should be provided."
+        "Either integration or (connection and (entityOperations or actions)) should be provided."
       );
     }
     this.options = options;
@@ -59,72 +70,122 @@ let ApplicationIntegrationToolset = class extends BaseToolset {
    * 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() {
+  async getTools(context) {
     if (!this.toolsPromise) {
       this.toolsPromise = this.loadTools();
     }
     try {
-      return await this.toolsPromise;
+      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;
+    var _a, _b;
     const {
       project,
       location,
       integration,
-      trigger,
+      triggers,
       connection,
       entityOperations,
       actions,
-      toolName = "",
+      toolNamePrefix,
       toolInstructions = "",
-      serviceAccountJson
+      serviceAccountJson,
+      authScheme,
+      authCredential: dynamicAuthCredential
     } = this.options;
+    const resolvedToolName = toolNamePrefix != null ? toolNamePrefix : "";
+    this.openApiToolsets = [];
     const integrationClient = new IntegrationClient({
       project,
       location,
       integration,
-      trigger,
+      triggers,
       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);
+    if (integration) {
+      const specRecord2 = await integrationClient.getOpenApiSpecForIntegration();
+      const spec2 = toOpenApiDocument(specRecord2);
+      for (const [path, pathItem] of Object.entries((_a = spec2.paths) != null ? _a : {})) {
+        const openApiToolset = new 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 ConnectionsClient({
+      project,
+      location,
+      connection: connectionName,
+      serviceAccountJson
+    }).getConnectionDetails();
+    if (authScheme && dynamicAuthCredential && !connectionDetails.authOverrideEnabled) {
+      logger.warn(
+        "Authentication schema and credentials are not used because authOverrideEnabled is not enabled in the connection."
+      );
+    }
+    const specRecord = await integrationClient.getOpenApiSpecForConnection(
+      resolvedToolName,
+      toolInstructions
+    );
+    const spec = toOpenApiDocument(specRecord);
+    const operations = new OpenApiSpecParser({
+      preservePropertyNames: true
+    }).parse(spec);
+    for (const openApiOperation of operations) {
+      const operationObject = toJsonObject(openApiOperation.operation);
+      const operation = toStringValue(operationObject["x-operation"]);
+      const entity = toStringValue(operationObject["x-entity"]);
+      const action = toStringValue(operationObject["x-action"]);
+      const restApiTool = createRestApiTool(
+        {
+          ...openApiOperation,
+          name: toSnakeCaseName(openApiOperation.name),
+          endpoint: {
+            ...openApiOperation.endpoint,
+            path: removeFragment(openApiOperation.endpoint.path)
+          }
+        },
+        { preservePropertyNames: true }
+      );
+      restApiTool.configureAuthScheme(AUTH_SCHEME);
+      restApiTool.configureAuthCredential(authCredential);
+      const tool = new 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()];
   }
@@ -133,6 +194,14 @@ __name(ApplicationIntegrationToolset, "ApplicationIntegrationToolset");
 ApplicationIntegrationToolset = __decorateClass([
   experimental
 ], ApplicationIntegrationToolset);
+function toOpenApiDocument(specRecord) {
+  return specRecord;
+}
+__name(toOpenApiDocument, "toOpenApiDocument");
+function toStringValue(value) {
+  return typeof value === "string" ? value : "";
+}
+__name(toStringValue, "toStringValue");
 function buildAuthCredential(serviceAccountJson) {
   if (!serviceAccountJson) {
     return {
@@ -147,7 +216,7 @@ function buildAuthCredential(serviceAccountJson) {
   if (!isJsonObject(key)) {
     throw new Error("serviceAccountJson must hold a JSON object.");
   }
-  const [, authCredential] = serviceAccountDictToSchemeCredential(key, [
+  const [, authCredential] = serviceAccountRecordToSchemeCredential(key, [
     CLOUD_PLATFORM_SCOPE
   ]);
   return authCredential;
@@ -159,5 +228,6 @@ function removeFragment(path) {
 }
 __name(removeFragment, "removeFragment");
 export {
-  ApplicationIntegrationToolset
+  ApplicationIntegrationToolset,
+  IntegrationConnectorTool
 };