@google/adk 2.2.1 → 2.3.0

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

@@ -0,0 +1,219 @@
+/**
+  * @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 integration_client_exports = {};
+__export(integration_client_exports, {
+  IntegrationClient: () => IntegrationClient
+});
+module.exports = __toCommonJS(integration_client_exports);
+var import_experimental = require("../../../utils/experimental.js");
+var import_json_utils = require("../../../utils/json_utils.js");
+var import_cloud_request = require("./cloud_request.js");
+var import_connections_client = require("./connections_client.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const EXECUTE_CONNECTION_INTEGRATION = "ExecuteConnection";
+const EXECUTE_CUSTOM_QUERY_ACTION = "ExecuteCustomQuery";
+let IntegrationClient = class {
+  constructor(options) {
+    var _a, _b;
+    this.project = options.project;
+    this.location = options.location;
+    this.integration = options.integration;
+    this.trigger = options.trigger;
+    this.connection = options.connection;
+    this.entityOperations = (_a = options.entityOperations) != null ? _a : {};
+    this.actions = (_b = options.actions) != null ? _b : [];
+    this.serviceAccountJson = options.serviceAccountJson;
+    this.tokenSource = new import_cloud_request.CloudPlatformTokenSource(options.serviceAccountJson);
+  }
+  /**
+   * Fetches the OpenAPI spec Application Integration generates for the API
+   * trigger of the integration.
+   *
+   * @throws Error For a rejected request, a missing credential, or a response
+   *   that carries no parseable spec.
+   */
+  async getOpenApiSpecForIntegration() {
+    const url = `https://${this.location}-integrations.googleapis.com/v1/projects/${this.project}/locations/${this.location}:generateOpenApiSpec`;
+    const body = await (0, import_cloud_request.sendCloudRequest)({
+      url,
+      method: "POST",
+      body: {
+        apiTriggerResources: [
+          {
+            integrationResource: this.integration,
+            triggerId: [this.trigger]
+          }
+        ],
+        fileFormat: "JSON"
+      },
+      tokenSource: this.tokenSource,
+      invalidRequestMessage: `Invalid request. Please check the provided values of project(${this.project}), location(${this.location}), integration(${this.integration}) and trigger(${this.trigger}).`
+    });
+    try {
+      const spec = (0, import_json_utils.isJsonObject)(body) ? body["openApiSpec"] : void 0;
+      if (typeof spec !== "string") {
+        throw new Error("The response carries no openApiSpec string.");
+      }
+      const parsed = JSON.parse(spec);
+      if (!(0, import_json_utils.isJsonObject)(parsed)) {
+        throw new Error("The openApiSpec is not a JSON object.");
+      }
+      return parsed;
+    } catch (e) {
+      throw (0, import_cloud_request.unexpectedError)(e);
+    }
+  }
+  /**
+   * Builds an OpenAPI spec for the entity operations and actions of the
+   * connection.
+   *
+   * Every operation becomes a POST to the `ExecuteConnection` integration,
+   * with a path fragment that keeps the paths distinct.
+   *
+   * @param toolName Prefix of every generated `operationId`.
+   * @param toolInstructions Text appended to every operation description.
+   * @throws Error When neither entity operations nor actions are configured,
+   *   or an operation is not one of create, update, delete, list or get.
+   */
+  async getOpenApiSpecForConnection(toolName = "", toolInstructions = "") {
+    var _a;
+    if (Object.keys(this.entityOperations).length === 0 && this.actions.length === 0) {
+      throw new Error(
+        "No entity operations or actions provided. Please provide at least one of them."
+      );
+    }
+    const connectionsClient = new import_connections_client.ConnectionsClient({
+      project: this.project,
+      location: this.location,
+      connection: (_a = this.connection) != null ? _a : "",
+      serviceAccountJson: this.serviceAccountJson
+    });
+    const connectorSpec = structuredClone(import_connections_client.CONNECTOR_BASE_SPEC);
+    const schemas = connectorSpec.components.schemas;
+    const pathPrefix = `/v2/projects/${this.project}/locations/${this.location}/integrations/${EXECUTE_CONNECTION_INTEGRATION}:execute?triggerId=api_trigger/${EXECUTE_CONNECTION_INTEGRATION}`;
+    for (const [entity, requestedOperations] of Object.entries(
+      this.entityOperations
+    )) {
+      const { schema, operations: supportedOperations } = await connectionsClient.getEntitySchemaAndOperations(entity);
+      const operations = requestedOperations.length > 0 ? requestedOperations : supportedOperations;
+      const schemaAsString = JSON.stringify(schema);
+      schemas[`connectorInputPayload_${entity}`] = (0, import_connections_client.connectorPayload)(schema);
+      for (const operation of operations) {
+        const operationLower = operation.toLowerCase();
+        const path = `${pathPrefix}#${operationLower}_${entity}`;
+        switch (operationLower) {
+          case "create":
+            connectorSpec.paths[path] = (0, import_connections_client.createOperation)({
+              entity,
+              toolName,
+              toolInstructions
+            });
+            schemas[`create_${entity}_Request`] = (0, import_connections_client.createOperationRequest)(entity);
+            break;
+          case "update":
+            connectorSpec.paths[path] = (0, import_connections_client.updateOperation)({
+              entity,
+              toolName,
+              toolInstructions
+            });
+            schemas[`update_${entity}_Request`] = (0, import_connections_client.updateOperationRequest)(entity);
+            break;
+          case "delete":
+            connectorSpec.paths[path] = (0, import_connections_client.deleteOperation)({
+              entity,
+              toolName,
+              toolInstructions
+            });
+            schemas[`delete_${entity}_Request`] = (0, import_connections_client.deleteOperationRequest)();
+            break;
+          case "list":
+            connectorSpec.paths[path] = (0, import_connections_client.listOperation)({
+              entity,
+              schemaAsString,
+              toolName,
+              toolInstructions
+            });
+            schemas[`list_${entity}_Request`] = (0, import_connections_client.listOperationRequest)();
+            break;
+          case "get":
+            connectorSpec.paths[path] = (0, import_connections_client.getOperation)({
+              entity,
+              schemaAsString,
+              toolName,
+              toolInstructions
+            });
+            schemas[`get_${entity}_Request`] = (0, import_connections_client.getOperationRequest)();
+            break;
+          default:
+            throw new Error(
+              `Invalid operation: ${operation} for entity: ${entity}`
+            );
+        }
+      }
+    }
+    for (const action of this.actions) {
+      const { inputSchema, outputSchema, displayName } = await connectionsClient.getActionSchema(action);
+      let operation = "EXECUTE_ACTION";
+      if (action === EXECUTE_CUSTOM_QUERY_ACTION) {
+        schemas[`${action}_Request`] = (0, import_connections_client.executeCustomQueryRequest)();
+        operation = "EXECUTE_QUERY";
+      } else {
+        schemas[`${displayName}_Request`] = (0, import_connections_client.actionRequest)(displayName);
+        schemas[`connectorInputPayload_${displayName}`] = (0, import_connections_client.connectorPayload)(inputSchema);
+      }
+      schemas[`connectorOutputPayload_${displayName}`] = (0, import_connections_client.connectorPayload)(outputSchema);
+      schemas[`${displayName}_Response`] = (0, import_connections_client.actionResponse)(displayName);
+      connectorSpec.paths[`${pathPrefix}#${action}`] = (0, import_connections_client.getActionOperation)({
+        action,
+        operation,
+        actionDisplayName: displayName,
+        toolName,
+        toolInstructions
+      });
+    }
+    return connectorSpec;
+  }
+};
+__name(IntegrationClient, "IntegrationClient");
+IntegrationClient = __decorateClass([
+  import_experimental.experimental
+], IntegrationClient);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IntegrationClient
+});

package/dist/cjs/tools/crewai_tool.js

@@ -0,0 +1,132 @@
+/**
+  * @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 crewai_tool_exports = {};
+__export(crewai_tool_exports, {
+  CrewaiTool: () => CrewaiTool,
+  isCrewaiTool: () => isCrewaiTool
+});
+module.exports = __toCommonJS(crewai_tool_exports);
+var import_schema = require("../utils/schema.js");
+var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
+var import_variant_utils = require("../utils/variant_utils.js");
+var import_function_tool = require("./function_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const CREWAI_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.crewaiTool");
+function isCrewaiTool(obj) {
+  return typeof obj === "object" && obj !== null && CREWAI_TOOL_SIGNATURE_SYMBOL in obj && obj[CREWAI_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isCrewaiTool, "isCrewaiTool");
+function isCrewaiToolConfig(value) {
+  return typeof value === "object" && value !== null && "tool" in value && typeof value.tool === "object" && value.tool !== null && typeof value.tool.run === "function";
+}
+__name(isCrewaiToolConfig, "isCrewaiToolConfig");
+function normalizeCrewaiSchemaJson(argsSchema) {
+  if (!argsSchema) {
+    return {};
+  }
+  if (typeof argsSchema.modelJsonSchema === "function") {
+    return argsSchema.modelJsonSchema();
+  }
+  if (typeof argsSchema.jsonSchema === "function") {
+    return argsSchema.jsonSchema();
+  }
+  if ((0, import_simple_zod_to_json.isZodSchema)(argsSchema)) {
+    const raw = structuredClone((0, import_schema.toJsonSchema)(argsSchema));
+    const requiredSet = new Set(
+      Array.isArray(raw["required"]) ? raw["required"] : []
+    );
+    const properties = raw["properties"];
+    if (properties && typeof properties === "object") {
+      for (const [key, prop] of Object.entries(properties)) {
+        if (!prop || typeof prop !== "object") {
+          continue;
+        }
+        if (Array.isArray(prop["type"])) {
+          const types = prop["type"];
+          delete prop["type"];
+          prop["anyOf"] = types.map((t) => ({ type: t }));
+        } else if (!requiredSet.has(key) && !("default" in prop) && !("anyOf" in prop) && typeof prop["type"] === "string") {
+          const propType = prop["type"];
+          delete prop["type"];
+          prop["anyOf"] = [{ type: propType }, { type: "null" }];
+        }
+      }
+    }
+    return raw;
+  }
+  return structuredClone(argsSchema);
+}
+__name(normalizeCrewaiSchemaJson, "normalizeCrewaiSchemaJson");
+const _CrewaiTool = class _CrewaiTool extends (_b = import_function_tool.FunctionTool, _a = CREWAI_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor(toolOrConfig, options) {
+    const config = isCrewaiToolConfig(toolOrConfig) ? toolOrConfig : {
+      tool: toolOrConfig,
+      name: options == null ? void 0 : options.name,
+      description: options == null ? void 0 : options.description
+    };
+    const resolvedName = config.name || (config.tool.name ? config.tool.name.replace(/ /g, "_").toLowerCase() : config.tool.run.name || "crewai_tool");
+    const resolvedDescription = config.description || config.tool.description || "";
+    super({
+      name: resolvedName,
+      description: resolvedDescription,
+      parameters: (0, import_simple_zod_to_json.isZodObject)(config.tool.argsSchema) ? config.tool.argsSchema : void 0,
+      execute: /* @__PURE__ */ __name(async (args, toolContext) => {
+        return await config.tool.run(
+          args != null ? args : {},
+          toolContext
+        );
+      }, "execute")
+    });
+    /** A unique symbol to identify ADK CrewaiTool class. */
+    this[_a] = true;
+    this.tool = config.tool;
+  }
+  /**
+   * Builds the `FunctionDeclaration` for the wrapped CrewAI tool.
+   */
+  _getDeclaration() {
+    const schemaJson = normalizeCrewaiSchemaJson(this.tool.argsSchema);
+    return (0, import_function_tool.buildFunctionDeclarationForParamsForCrewai)(
+      this.apiVariant === import_variant_utils.GoogleLLMVariant.VERTEX_AI,
+      this.name,
+      this.description,
+      this.tool.run,
+      schemaJson
+    );
+  }
+};
+__name(_CrewaiTool, "CrewaiTool");
+let CrewaiTool = _CrewaiTool;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CrewaiTool,
+  isCrewaiTool
+});

package/dist/cjs/tools/example_tool.js

@@ -28,6 +28,7 @@ __export(example_tool_exports, {
   ExampleTool: () => ExampleTool
 });
 module.exports = __toCommonJS(example_tool_exports);
+var import_base_example_provider = require("../examples/base_example_provider.js");
 var import_example_util = require("../examples/example_util.js");
 var import_llm_request = require("../models/llm_request.js");
 var import_base_tool = require("./base_tool.js");
@@ -37,6 +38,12 @@ var import_base_tool = require("./base_tool.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 const _ExampleTool = class _ExampleTool extends import_base_tool.BaseTool {
+  /**
+   * @param examples - A list of {@link Example}s, or a
+   *   {@link BaseExampleProvider} that returns them for a query.
+   * @throws {InputValidationError} When `examples` is neither a
+   *   {@link BaseExampleProvider} nor a list of well-formed examples.
+   */
   constructor(examples) {
     super({
       // Name and description are not used because this tool only changes
@@ -44,6 +51,9 @@ const _ExampleTool = class _ExampleTool extends import_base_tool.BaseTool {
       name: "example_tool",
       description: "example tool"
     });
+    if (!(0, import_base_example_provider.isBaseExampleProvider)(examples)) {
+      (0, import_example_util.validateExamples)(examples);
+    }
     this.examples = examples;
   }
   async runAsync(_request) {