@google/adk 2.2.0 → 2.3.0

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

@@ -0,0 +1,215 @@
+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 { experimental } from "../../../utils/experimental.js";
+import { isJsonObject } from "../../../utils/json_utils.js";
+import {
+  CloudPlatformTokenSource,
+  sendCloudRequest,
+  unexpectedError
+} from "./cloud_request.js";
+import {
+  actionRequest,
+  actionResponse,
+  ConnectionsClient,
+  CONNECTOR_BASE_SPEC,
+  connectorPayload,
+  createOperation,
+  createOperationRequest,
+  deleteOperation,
+  deleteOperationRequest,
+  executeCustomQueryRequest,
+  getActionOperation,
+  getOperation,
+  getOperationRequest,
+  listOperation,
+  listOperationRequest,
+  updateOperation,
+  updateOperationRequest
+} from "./connections_client.js";
+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 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 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 = 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 (!isJsonObject(parsed)) {
+        throw new Error("The openApiSpec is not a JSON object.");
+      }
+      return parsed;
+    } catch (e) {
+      throw 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 ConnectionsClient({
+      project: this.project,
+      location: this.location,
+      connection: (_a = this.connection) != null ? _a : "",
+      serviceAccountJson: this.serviceAccountJson
+    });
+    const connectorSpec = structuredClone(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}`] = connectorPayload(schema);
+      for (const operation of operations) {
+        const operationLower = operation.toLowerCase();
+        const path = `${pathPrefix}#${operationLower}_${entity}`;
+        switch (operationLower) {
+          case "create":
+            connectorSpec.paths[path] = createOperation({
+              entity,
+              toolName,
+              toolInstructions
+            });
+            schemas[`create_${entity}_Request`] = createOperationRequest(entity);
+            break;
+          case "update":
+            connectorSpec.paths[path] = updateOperation({
+              entity,
+              toolName,
+              toolInstructions
+            });
+            schemas[`update_${entity}_Request`] = updateOperationRequest(entity);
+            break;
+          case "delete":
+            connectorSpec.paths[path] = deleteOperation({
+              entity,
+              toolName,
+              toolInstructions
+            });
+            schemas[`delete_${entity}_Request`] = deleteOperationRequest();
+            break;
+          case "list":
+            connectorSpec.paths[path] = listOperation({
+              entity,
+              schemaAsString,
+              toolName,
+              toolInstructions
+            });
+            schemas[`list_${entity}_Request`] = listOperationRequest();
+            break;
+          case "get":
+            connectorSpec.paths[path] = getOperation({
+              entity,
+              schemaAsString,
+              toolName,
+              toolInstructions
+            });
+            schemas[`get_${entity}_Request`] = 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`] = executeCustomQueryRequest();
+        operation = "EXECUTE_QUERY";
+      } else {
+        schemas[`${displayName}_Request`] = actionRequest(displayName);
+        schemas[`connectorInputPayload_${displayName}`] = connectorPayload(inputSchema);
+      }
+      schemas[`connectorOutputPayload_${displayName}`] = connectorPayload(outputSchema);
+      schemas[`${displayName}_Response`] = actionResponse(displayName);
+      connectorSpec.paths[`${pathPrefix}#${action}`] = getActionOperation({
+        action,
+        operation,
+        actionDisplayName: displayName,
+        toolName,
+        toolInstructions
+      });
+    }
+    return connectorSpec;
+  }
+};
+__name(IntegrationClient, "IntegrationClient");
+IntegrationClient = __decorateClass([
+  experimental
+], IntegrationClient);
+export {
+  IntegrationClient
+};

package/dist/esm/tools/crewai_tool.js

@@ -0,0 +1,107 @@
+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
+ */
+var _a, _b;
+import { toJsonSchema } from "../utils/schema.js";
+import { isZodObject, isZodSchema } from "../utils/simple_zod_to_json.js";
+import { GoogleLLMVariant } from "../utils/variant_utils.js";
+import {
+  buildFunctionDeclarationForParamsForCrewai,
+  FunctionTool
+} from "./function_tool.js";
+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 (isZodSchema(argsSchema)) {
+    const raw = structuredClone(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 = 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: 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 buildFunctionDeclarationForParamsForCrewai(
+      this.apiVariant === GoogleLLMVariant.VERTEX_AI,
+      this.name,
+      this.description,
+      this.tool.run,
+      schemaJson
+    );
+  }
+};
+__name(_CrewaiTool, "CrewaiTool");
+let CrewaiTool = _CrewaiTool;
+export {
+  CrewaiTool,
+  isCrewaiTool
+};

package/dist/esm/tools/example_tool.js

@@ -7,12 +7,21 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { buildExampleSi } from "../examples/example_util.js";
+import {
+  isBaseExampleProvider
+} from "../examples/base_example_provider.js";
+import { buildExampleSi, validateExamples } from "../examples/example_util.js";
 import { appendInstructions } from "../models/llm_request.js";
 import {
   BaseTool
 } from "./base_tool.js";
 const _ExampleTool = class _ExampleTool extends 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
@@ -20,6 +29,9 @@ const _ExampleTool = class _ExampleTool extends BaseTool {
       name: "example_tool",
       description: "example tool"
     });
+    if (!isBaseExampleProvider(examples)) {
+      validateExamples(examples);
+    }
     this.examples = examples;
   }
   async runAsync(_request) {