@softactivate/adk 1.1.0

package/dist/cjs/tools/agent_tool.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 __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 agent_tool_exports = {};
+__export(agent_tool_exports, {
+  AgentTool: () => AgentTool,
+  isAgentTool: () => isAgentTool
+});
+module.exports = __toCommonJS(agent_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_agent = require("../agents/llm_agent.js");
+var import_in_memory_memory_service = require("../memory/in_memory_memory_service.js");
+var import_runner = require("../runner/runner.js");
+var import_in_memory_session_service = require("../sessions/in_memory_session_service.js");
+var import_variant_utils = require("../utils/variant_utils.js");
+var import_base_tool = require("./base_tool.js");
+var import_forwarding_artifact_service = require("./forwarding_artifact_service.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const AGENT_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.agentTool");
+function isAgentTool(obj) {
+  return typeof obj === "object" && obj !== null && AGENT_TOOL_SIGNATURE_SYMBOL in obj && obj[AGENT_TOOL_SIGNATURE_SYMBOL] === true;
+}
+class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    super({
+      name: config.agent.name,
+      description: config.agent.description || ""
+    });
+    /** A unique symbol to identify ADK agent tool class. */
+    this[_a] = true;
+    this.agent = config.agent;
+    this.skipSummarization = config.skipSummarization || false;
+  }
+  _getDeclaration() {
+    let declaration;
+    if ((0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.inputSchema) {
+      declaration = {
+        name: this.name,
+        description: this.description,
+        // TODO(b/425992518): We should not use the agent's input schema as is.
+        // It should be validated and possibly transformed. Consider similar
+        // logic to one we have in Python ADK.
+        parameters: this.agent.inputSchema
+      };
+    } else {
+      declaration = {
+        name: this.name,
+        description: this.description,
+        parameters: {
+          type: import_genai.Type.OBJECT,
+          properties: {
+            "request": {
+              type: import_genai.Type.STRING
+            }
+          },
+          required: ["request"]
+        }
+      };
+    }
+    if (this.apiVariant !== import_variant_utils.GoogleLLMVariant.GEMINI_API) {
+      const hasOutputSchema = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.outputSchema;
+      declaration.response = hasOutputSchema ? { type: import_genai.Type.OBJECT } : { type: import_genai.Type.STRING };
+    }
+    return declaration;
+  }
+  /**
+   * Sets up the Runner and Session for sub-agent execution.
+   *
+   * Shared by {@link runAsync} and {@link runAsyncWithEvents}.
+   */
+  async setupRunnerAndSession({
+    args,
+    toolContext
+  }) {
+    var _a2, _b2;
+    const hasInputSchema = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.inputSchema;
+    const content = {
+      role: "user",
+      parts: [
+        {
+          // TODO(b/425992518): Should be validated. Consider similar
+          // logic to one we have in Python ADK.
+          text: hasInputSchema ? JSON.stringify(args) : args["request"]
+        }
+      ]
+    };
+    const runner = new import_runner.Runner({
+      appName: this.agent.name,
+      agent: this.agent,
+      artifactService: new import_forwarding_artifact_service.ForwardingArtifactService(toolContext),
+      sessionService: (_a2 = toolContext.invocationContext.sessionService) != null ? _a2 : new import_in_memory_session_service.InMemorySessionService(),
+      memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new import_in_memory_memory_service.InMemoryMemoryService(),
+      credentialService: toolContext.invocationContext.credentialService
+    });
+    const session = await runner.sessionService.getOrCreateSession({
+      appName: this.agent.name,
+      userId: toolContext.invocationContext.userId,
+      sessionId: toolContext.invocationContext.session.id,
+      state: toolContext.state.toRecord()
+    });
+    return {
+      runner,
+      content,
+      sessionUserId: session.userId,
+      sessionId: session.id
+    };
+  }
+  /**
+   * Builds the tool result from the last content event of the sub-agent.
+   *
+   * Excludes thought parts and applies the output schema (if any).
+   */
+  buildToolResultFromContent(lastContent) {
+    var _a2;
+    if (!((_a2 = lastContent == null ? void 0 : lastContent.parts) == null ? void 0 : _a2.length)) {
+      return "";
+    }
+    const hasOutputSchema = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.outputSchema;
+    const mergedText = lastContent.parts.filter((part) => !part.thought).map((part) => part.text).filter((text) => text).join("\n");
+    return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    var _a2, _b2;
+    if (this.skipSummarization) {
+      toolContext.actions.skipSummarization = true;
+    }
+    const { runner, content, sessionUserId, sessionId } = await this.setupRunnerAndSession({ args, toolContext });
+    if ((_a2 = toolContext.abortSignal) == null ? void 0 : _a2.aborted) {
+      return "";
+    }
+    let lastEvent;
+    for await (const event of runner.runAsync({
+      userId: sessionUserId,
+      sessionId,
+      newMessage: content,
+      runConfig: toolContext.invocationContext.runConfig,
+      abortSignal: toolContext.abortSignal
+    })) {
+      if ((_b2 = toolContext.abortSignal) == null ? void 0 : _b2.aborted) {
+        return;
+      }
+      if (event.actions.stateDelta) {
+        toolContext.state.update(event.actions.stateDelta);
+      }
+      lastEvent = event;
+    }
+    return this.buildToolResultFromContent(lastEvent == null ? void 0 : lastEvent.content);
+  }
+  /**
+   * Runs the wrapped agent and yields the sub-agent's events as they are
+   * produced, providing real-time visibility into sub-agent progress.
+   *
+   * Counterpart to {@link runAsync}; the caller is responsible for tracking
+   * the last content event and building the final tool result via
+   * {@link buildToolResultFromContent}.
+   */
+  async *runAsyncWithEvents({
+    args,
+    toolContext
+  }) {
+    var _a2, _b2;
+    if (this.skipSummarization) {
+      toolContext.actions.skipSummarization = true;
+    }
+    const { runner, content, sessionUserId, sessionId } = await this.setupRunnerAndSession({ args, toolContext });
+    if ((_a2 = toolContext.abortSignal) == null ? void 0 : _a2.aborted) {
+      return;
+    }
+    for await (const event of runner.runAsync({
+      userId: sessionUserId,
+      sessionId,
+      newMessage: content,
+      runConfig: toolContext.invocationContext.runConfig,
+      abortSignal: toolContext.abortSignal
+    })) {
+      if ((_b2 = toolContext.abortSignal) == null ? void 0 : _b2.aborted) {
+        return;
+      }
+      if (event.actions.stateDelta) {
+        toolContext.state.update(event.actions.stateDelta);
+      }
+      yield event;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentTool,
+  isAgentTool
+});

package/dist/cjs/tools/base_tool.js

@@ -0,0 +1,122 @@
+/**
+  * @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 __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 base_tool_exports = {};
+__export(base_tool_exports, {
+  BaseTool: () => BaseTool,
+  isBaseTool: () => isBaseTool
+});
+module.exports = __toCommonJS(base_tool_exports);
+var import_variant_utils = require("../utils/variant_utils.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const BASE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseTool");
+function isBaseTool(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_TOOL_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOL_SIGNATURE_SYMBOL;
+class BaseTool {
+  /**
+   * Base constructor for a tool.
+   *
+   * @param params The parameters for `BaseTool`.
+   */
+  constructor(params) {
+    /** A unique symbol to identify ADK base tool class. */
+    this[_a] = true;
+    var _a2;
+    this.name = params.name;
+    this.description = params.description;
+    this.isLongRunning = (_a2 = params.isLongRunning) != null ? _a2 : false;
+  }
+  /**
+   * Gets the OpenAPI specification of this tool in the form of a
+   * FunctionDeclaration.
+   *
+   * NOTE
+   * - Required if subclass uses the default implementation of
+   *   `processLlmRequest` to add function declaration to LLM request.
+   * - Otherwise, can be skipped, e.g. for a built-in GoogleSearch tool for
+   *   Gemini.
+   *
+   * @return The FunctionDeclaration of this tool, or undefined if it doesn't
+   *     need to be added to LlmRequest.config.
+   */
+  _getDeclaration() {
+    return void 0;
+  }
+  /**
+   * Processes the outgoing LLM request for this tool.
+   *
+   * Use cases:
+   * - Most common use case is adding this tool to the LLM request.
+   * - Some tools may just preprocess the LLM request before it's sent out.
+   *
+   * @param request The request to process the LLM request.
+   */
+  async processLlmRequest({ llmRequest }) {
+    const functionDeclaration = this._getDeclaration();
+    if (!functionDeclaration) {
+      return;
+    }
+    if (this.name in llmRequest.toolsDict) {
+      throw new Error(`Duplicate tool name: ${this.name}`);
+    }
+    llmRequest.toolsDict[this.name] = this;
+    const tool = findToolWithFunctionDeclarations(llmRequest);
+    if (tool) {
+      if (!tool.functionDeclarations) {
+        tool.functionDeclarations = [];
+      }
+      tool.functionDeclarations.push(functionDeclaration);
+    } else {
+      llmRequest.config = llmRequest.config || {};
+      llmRequest.config.tools = llmRequest.config.tools || [];
+      llmRequest.config.tools.push({
+        functionDeclarations: [functionDeclaration]
+      });
+    }
+  }
+  /**
+   * The Google API LLM variant to use.
+   */
+  get apiVariant() {
+    return (0, import_variant_utils.getGoogleLlmVariant)();
+  }
+}
+function findToolWithFunctionDeclarations(llmRequest) {
+  var _a2;
+  return (((_a2 = llmRequest.config) == null ? void 0 : _a2.tools) || []).find(
+    (tool) => "functionDeclarations" in tool
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseTool,
+  isBaseTool
+});

package/dist/cjs/tools/base_toolset.js

@@ -0,0 +1,86 @@
+/**
+  * @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 __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 base_toolset_exports = {};
+__export(base_toolset_exports, {
+  BaseToolset: () => BaseToolset,
+  isBaseToolset: () => isBaseToolset
+});
+module.exports = __toCommonJS(base_toolset_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const BASE_TOOLSET_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseToolset");
+function isBaseToolset(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[BASE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOLSET_SIGNATURE_SYMBOL;
+class BaseToolset {
+  constructor(toolFilter, prefix) {
+    this.toolFilter = toolFilter;
+    this.prefix = prefix;
+    this[_a] = true;
+  }
+  /**
+   * Returns whether the tool should be exposed to LLM.
+   *
+   * @param tool The tool to check.
+   * @param context Context used to filter tools available to the agent.
+   * @return Whether the tool should be exposed to LLM.
+   */
+  isToolSelected(tool, context) {
+    if (!this.toolFilter) {
+      return true;
+    }
+    if (typeof this.toolFilter === "function") {
+      return this.toolFilter(tool, context);
+    }
+    if (Array.isArray(this.toolFilter)) {
+      return this.toolFilter.includes(tool.name);
+    }
+    return false;
+  }
+  /**
+   * Processes the outgoing LLM request for this toolset. This method will be
+   * called before each tool processes the llm request.
+   *
+   * Use cases:
+   * - Instead of let each tool process the llm request, we can let the toolset
+   *   process the llm request. e.g. ComputerUseToolset can add computer use
+   *   tool to the llm request.
+   *
+   * @param toolContext The context of the tool.
+   * @param llmRequest The outgoing LLM request, mutable this method.
+   */
+  async processLlmRequest(toolContext, llmRequest) {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseToolset,
+  isBaseToolset
+});

package/dist/cjs/tools/exit_loop_tool.js

@@ -0,0 +1,63 @@
+/**
+  * @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 __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 exit_loop_tool_exports = {};
+__export(exit_loop_tool_exports, {
+  EXIT_LOOP: () => EXIT_LOOP,
+  ExitLoopTool: () => ExitLoopTool
+});
+module.exports = __toCommonJS(exit_loop_tool_exports);
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ExitLoopTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "exit_loop",
+      description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description
+    };
+  }
+  async runAsync({
+    toolContext
+  }) {
+    toolContext.actions.escalate = true;
+    toolContext.actions.skipSummarization = true;
+    return "";
+  }
+}
+const EXIT_LOOP = new ExitLoopTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXIT_LOOP,
+  ExitLoopTool
+});

package/dist/cjs/tools/forwarding_artifact_service.js

@@ -0,0 +1,87 @@
+/**
+  * @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 __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 forwarding_artifact_service_exports = {};
+__export(forwarding_artifact_service_exports, {
+  ForwardingArtifactService: () => ForwardingArtifactService
+});
+module.exports = __toCommonJS(forwarding_artifact_service_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ForwardingArtifactService {
+  constructor(toolContext) {
+    this.toolContext = toolContext;
+    this.invocationContext = toolContext.invocationContext;
+  }
+  // TODO - b/425992518: Remove unnecessary parameters. We should rethink the
+  // abstraction layer to make it more clear.
+  async saveArtifact(request) {
+    return this.toolContext.saveArtifact(request.filename, request.artifact);
+  }
+  async loadArtifact(request) {
+    return this.toolContext.loadArtifact(request.filename, request.version);
+  }
+  async listArtifactKeys() {
+    return this.toolContext.listArtifacts();
+  }
+  async deleteArtifact(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.deleteArtifact(
+      request
+    );
+  }
+  async listVersions(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.listVersions(
+      request
+    );
+  }
+  listArtifactVersions(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.listArtifactVersions(
+      request
+    );
+  }
+  getArtifactVersion(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.getArtifactVersion(
+      request
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForwardingArtifactService
+});

package/dist/cjs/tools/function_tool.js

@@ -0,0 +1,109 @@
+/**
+  * @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 __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 function_tool_exports = {};
+__export(function_tool_exports, {
+  FunctionTool: () => FunctionTool,
+  isFunctionTool: () => isFunctionTool
+});
+module.exports = __toCommonJS(function_tool_exports);
+var import_genai = require("@google/genai");
+var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+function toSchema(parameters) {
+  if (parameters === void 0) {
+    return { type: import_genai.Type.OBJECT, properties: {} };
+  }
+  if ((0, import_simple_zod_to_json.isZodObject)(parameters)) {
+    return (0, import_simple_zod_to_json.zodObjectToSchema)(parameters);
+  }
+  return parameters;
+}
+const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
+function isFunctionTool(obj) {
+  return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
+}
+class FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL, _b) {
+  /**
+   * The constructor acts as the user-friendly factory.
+   * @param options The configuration for the tool.
+   */
+  constructor(options) {
+    var _a2;
+    const name = (_a2 = options.name) != null ? _a2 : options.execute.name;
+    if (!name) {
+      throw new Error(
+        "Tool name cannot be empty. Either name the `execute` function or provide a `name`."
+      );
+    }
+    super({
+      name,
+      description: options.description,
+      isLongRunning: options.isLongRunning
+    });
+    /** A unique symbol to identify ADK function tool class. */
+    this[_a] = true;
+    this.execute = options.execute;
+    this.parameters = options.parameters;
+  }
+  /**
+   * Provide a schema for the function.
+   */
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: toSchema(this.parameters)
+    };
+  }
+  /**
+   * Logic for running the tool.
+   */
+  async runAsync(req) {
+    try {
+      let validatedArgs = req.args;
+      if ((0, import_simple_zod_to_json.isZodObject)(this.parameters)) {
+        validatedArgs = this.parameters.parse(req.args);
+      }
+      return await this.execute(
+        validatedArgs,
+        req.toolContext
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error in tool '${this.name}': ${errorMessage}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FunctionTool,
+  isFunctionTool
+});