@paean-ai/adk 0.2.17 → 0.2.18

package/dist/esm/telemetry/google_cloud.js

@@ -1,54 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { GoogleAuth } from "google-auth-library";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { detectResources } from "@opentelemetry/resources";
-import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
-import { TraceExporter } from "@google-cloud/opentelemetry-cloud-trace-exporter";
-import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { MetricExporter } from "@google-cloud/opentelemetry-cloud-monitoring-exporter";
-import { logger } from "../utils/logger.js";
-const GCP_PROJECT_ERROR_MESSAGE = "Cannot determine GCP Project. OTel GCP Exporters cannot be set up. Please make sure to log into correct GCP Project.";
-async function getGcpProjectId() {
-  try {
-    const auth = new GoogleAuth();
-    const projectId = await auth.getProjectId();
-    return projectId || void 0;
-  } catch (error) {
-    return void 0;
-  }
-}
-async function getGcpExporters(config = {}) {
-  const {
-    enableTracing = false,
-    enableMetrics = false
-    // enableCloudLogging = false,
-  } = config;
-  const projectId = await getGcpProjectId();
-  if (!projectId) {
-    logger.warn(GCP_PROJECT_ERROR_MESSAGE);
-    return {};
-  }
-  return {
-    spanProcessors: enableTracing ? [
-      new BatchSpanProcessor(new TraceExporter({ projectId }))
-    ] : [],
-    metricReaders: enableMetrics ? [
-      new PeriodicExportingMetricReader({
-        exporter: new MetricExporter({ projectId }),
-        exportIntervalMillis: 5e3
-      })
-    ] : [],
-    logRecordProcessors: []
-  };
-}
-function getGcpResource() {
-  return detectResources({ detectors: [gcpDetector] });
-}
-export {
-  getGcpExporters,
-  getGcpResource
-};

package/dist/esm/telemetry/setup.js

@@ -1,67 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { trace, metrics } from "@opentelemetry/api";
-import { logs } from "@opentelemetry/api-logs";
-import { LoggerProvider, BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
-import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { detectResources } from "@opentelemetry/resources";
-import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
-function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
-  const resource = otelResource || getOtelResource();
-  const allHooks = [...otelHooksToSetup, getOtelExporters()];
-  const spanProcessors = allHooks.flatMap((hooks) => hooks.spanProcessors || []);
-  const metricReaders = allHooks.flatMap((hooks) => hooks.metricReaders || []);
-  const logRecordProcessors = allHooks.flatMap((hooks) => hooks.logRecordProcessors || []);
-  if (spanProcessors.length > 0) {
-    const tracerProvider = new NodeTracerProvider({
-      resource,
-      spanProcessors
-    });
-    tracerProvider.register();
-    trace.setGlobalTracerProvider(tracerProvider);
-  }
-  if (metricReaders.length > 0) {
-    const meterProvider = new MeterProvider({
-      readers: metricReaders,
-      resource
-    });
-    metrics.setGlobalMeterProvider(meterProvider);
-  }
-  if (logRecordProcessors.length > 0) {
-    const loggerProvider = new LoggerProvider({
-      resource,
-      processors: logRecordProcessors
-    });
-    logs.setGlobalLoggerProvider(loggerProvider);
-  }
-}
-function getOtelResource() {
-  return detectResources({
-    detectors: []
-  });
-}
-function getOtelExportersConfig() {
-  return {
-    enableTracing: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT),
-    enableMetrics: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT),
-    enableLogging: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)
-  };
-}
-function getOtelExporters(config = getOtelExportersConfig()) {
-  const { enableTracing, enableMetrics, enableLogging } = config;
-  return {
-    spanProcessors: enableTracing ? [new BatchSpanProcessor(new OTLPTraceExporter())] : [],
-    metricReaders: enableMetrics ? [new PeriodicExportingMetricReader({ exporter: new OTLPMetricExporter() })] : [],
-    logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor(new OTLPLogExporter())] : []
-  };
-}
-export {
-  maybeSetOtelProviders
-};

package/dist/esm/telemetry/tracing.js

@@ -1,195 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { trace, context } from "@opentelemetry/api";
-import { version } from "../version.js";
-const GEN_AI_AGENT_DESCRIPTION = "gen_ai.agent.description";
-const GEN_AI_AGENT_NAME = "gen_ai.agent.name";
-const GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
-const GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
-const GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
-const GEN_AI_TOOL_DESCRIPTION = "gen_ai.tool.description";
-const GEN_AI_TOOL_NAME = "gen_ai.tool.name";
-const GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
-const tracer = trace.getTracer(
-  "gcp.vertex.agent",
-  version
-);
-function safeJsonSerialize(obj) {
-  try {
-    return JSON.stringify(obj);
-  } catch (error) {
-    return "<not serializable>";
-  }
-}
-function traceAgentInvocation({
-  agent,
-  invocationContext
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "invoke_agent",
-    // Conditionally Required
-    [GEN_AI_AGENT_DESCRIPTION]: agent.description,
-    [GEN_AI_AGENT_NAME]: agent.name,
-    [GEN_AI_CONVERSATION_ID]: invocationContext.session.id
-  });
-}
-function traceToolCall({
-  tool,
-  args,
-  functionResponseEvent
-}) {
-  var _a, _b;
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "execute_tool",
-    [GEN_AI_TOOL_DESCRIPTION]: tool.description || "",
-    [GEN_AI_TOOL_NAME]: tool.name,
-    // e.g. FunctionTool
-    [GEN_AI_TOOL_TYPE]: tool.constructor.name,
-    // Setting empty llm request and response (as UI expect these) while not
-    // applicable for tool_response.
-    "gcp.vertex.agent.llm_request": "{}",
-    "gcp.vertex.agent.llm_response": "{}",
-    "gcp.vertex.agent.tool_call_args": shouldAddRequestResponseToSpans() ? safeJsonSerialize(args) : "{}"
-  });
-  let toolCallId = "<not specified>";
-  let toolResponse = "<not specified>";
-  if ((_a = functionResponseEvent.content) == null ? void 0 : _a.parts) {
-    const responseParts = functionResponseEvent.content.parts;
-    const functionResponse = (_b = responseParts[0]) == null ? void 0 : _b.functionResponse;
-    if (functionResponse == null ? void 0 : functionResponse.id) {
-      toolCallId = functionResponse.id;
-    }
-    if (functionResponse == null ? void 0 : functionResponse.response) {
-      toolResponse = functionResponse.response;
-    }
-  }
-  if (typeof toolResponse !== "object" || toolResponse === null) {
-    toolResponse = { result: toolResponse };
-  }
-  span.setAttributes({
-    [GEN_AI_TOOL_CALL_ID]: toolCallId,
-    "gcp.vertex.agent.event_id": functionResponseEvent.id,
-    "gcp.vertex.agent.tool_response": shouldAddRequestResponseToSpans() ? safeJsonSerialize(toolResponse) : "{}"
-  });
-}
-function traceMergedToolCalls({
-  responseEventId,
-  functionResponseEvent
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "execute_tool",
-    [GEN_AI_TOOL_NAME]: "(merged tools)",
-    [GEN_AI_TOOL_DESCRIPTION]: "(merged tools)",
-    [GEN_AI_TOOL_CALL_ID]: responseEventId,
-    "gcp.vertex.agent.tool_call_args": "N/A",
-    "gcp.vertex.agent.event_id": responseEventId,
-    // Setting empty llm request and response (as UI expect these) while not
-    // applicable for tool_response.
-    "gcp.vertex.agent.llm_request": "{}",
-    "gcp.vertex.agent.llm_response": "{}"
-  });
-  span.setAttribute("gcp.vertex.agent.tool_response", shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}");
-}
-function traceCallLlm({
-  invocationContext,
-  eventId,
-  llmRequest,
-  llmResponse
-}) {
-  var _a, _b, _c;
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    "gen_ai.system": "gcp.vertex.agent",
-    "gen_ai.request.model": llmRequest.model,
-    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
-    "gcp.vertex.agent.session_id": invocationContext.session.id,
-    "gcp.vertex.agent.event_id": eventId,
-    // Consider removing once GenAI SDK provides a way to record this info.
-    "gcp.vertex.agent.llm_request": shouldAddRequestResponseToSpans() ? safeJsonSerialize(buildLlmRequestForTrace(llmRequest)) : "{}"
-  });
-  if ((_a = llmRequest.config) == null ? void 0 : _a.topP) {
-    span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
-  }
-  if (((_b = llmRequest.config) == null ? void 0 : _b.maxOutputTokens) !== void 0) {
-    span.setAttribute("gen_ai.request.max_tokens", llmRequest.config.maxOutputTokens);
-  }
-  span.setAttribute("gcp.vertex.agent.llm_response", shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}");
-  if (llmResponse.usageMetadata) {
-    span.setAttribute("gen_ai.usage.input_tokens", llmResponse.usageMetadata.promptTokenCount || 0);
-  }
-  if ((_c = llmResponse.usageMetadata) == null ? void 0 : _c.candidatesTokenCount) {
-    span.setAttribute("gen_ai.usage.output_tokens", llmResponse.usageMetadata.candidatesTokenCount);
-  }
-  if (llmResponse.finishReason) {
-    const finishReasonValue = typeof llmResponse.finishReason === "string" ? llmResponse.finishReason.toLowerCase() : String(llmResponse.finishReason).toLowerCase();
-    span.setAttribute("gen_ai.response.finish_reasons", [finishReasonValue]);
-  }
-}
-function traceSendData({
-  invocationContext,
-  eventId,
-  data
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
-    "gcp.vertex.agent.event_id": eventId
-  });
-  span.setAttribute("gcp.vertex.agent.data", shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}");
-}
-function buildLlmRequestForTrace(llmRequest) {
-  const result = {
-    model: llmRequest.model,
-    contents: []
-  };
-  if (llmRequest.config) {
-    const { responseSchema, ...cleanConfig } = llmRequest.config;
-    result.config = cleanConfig;
-  }
-  result.contents = llmRequest.contents.map((content) => {
-    var _a;
-    return {
-      role: content.role,
-      parts: ((_a = content.parts) == null ? void 0 : _a.filter((part) => !part.inlineData)) || []
-    };
-  });
-  return result;
-}
-function bindAsyncGenerator(ctx, generator) {
-  return {
-    // Bind the next() method to execute within the provided context
-    next: context.bind(ctx, generator.next.bind(generator)),
-    // Bind the return() method to execute within the provided context
-    return: context.bind(ctx, generator.return.bind(generator)),
-    // Bind the throw() method to execute within the provided context
-    throw: context.bind(ctx, generator.throw.bind(generator)),
-    // Ensure the async iterator symbol also returns a context-bound generator
-    [Symbol.asyncIterator]() {
-      return bindAsyncGenerator(ctx, generator[Symbol.asyncIterator]());
-    }
-  };
-}
-function shouldAddRequestResponseToSpans() {
-  const envValue = process.env.ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS || "true";
-  return envValue === "true" || envValue === "1";
-}
-export {
-  bindAsyncGenerator,
-  traceAgentInvocation,
-  traceCallLlm,
-  traceMergedToolCalls,
-  traceSendData,
-  traceToolCall,
-  tracer
-};

package/dist/esm/tools/agent_tool.js

@@ -1,104 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { LlmAgent } from "../agents/llm_agent.js";
-import { InMemoryMemoryService } from "../memory/in_memory_memory_service.js";
-import { Runner } from "../runner/runner.js";
-import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
-import { GoogleLLMVariant } from "../utils/variant_utils.js";
-import { BaseTool } from "./base_tool.js";
-import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
-class AgentTool extends BaseTool {
-  constructor(config) {
-    super(
-      { name: config.agent.name, description: config.agent.description || "" }
-    );
-    this.agent = config.agent;
-    this.skipSummarization = config.skipSummarization || false;
-  }
-  _getDeclaration() {
-    let declaration;
-    if (this.agent instanceof LlmAgent && 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: Type.OBJECT,
-          properties: {
-            "request": {
-              type: Type.STRING
-            }
-          },
-          required: ["request"]
-        }
-      };
-    }
-    if (this.apiVariant !== GoogleLLMVariant.GEMINI_API) {
-      const hasOutputSchema = this.agent instanceof LlmAgent && this.agent.outputSchema;
-      declaration.response = hasOutputSchema ? { type: Type.OBJECT } : { type: Type.STRING };
-    }
-    return declaration;
-  }
-  async runAsync({ args, toolContext }) {
-    var _a, _b;
-    if (this.skipSummarization) {
-      toolContext.actions.skipSummarization = true;
-    }
-    const hasInputSchema = this.agent instanceof LlmAgent && 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 Runner({
-      appName: this.agent.name,
-      agent: this.agent,
-      artifactService: new ForwardingArtifactService(toolContext),
-      sessionService: new InMemorySessionService(),
-      memoryService: new InMemoryMemoryService(),
-      credentialService: toolContext.invocationContext.credentialService
-    });
-    const session = await runner.sessionService.createSession({
-      appName: this.agent.name,
-      userId: "tmp_user",
-      state: toolContext.state.toRecord()
-    });
-    let lastEvent;
-    for await (const event of runner.runAsync({
-      userId: session.userId,
-      sessionId: session.id,
-      newMessage: content
-    })) {
-      if (event.actions.stateDelta) {
-        toolContext.state.update(event.actions.stateDelta);
-      }
-      lastEvent = event;
-    }
-    if (!((_b = (_a = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
-      return "";
-    }
-    const hasOutputSchema = this.agent instanceof LlmAgent && this.agent.outputSchema;
-    const mergetText = lastEvent.content.parts.map((part) => part.text).filter((text) => text).join("\n");
-    return hasOutputSchema ? JSON.parse(mergetText) : mergetText;
-  }
-}
-export {
-  AgentTool
-};

package/dist/esm/tools/base_tool.js

@@ -1,77 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { getGoogleLlmVariant } from "../utils/variant_utils.js";
-class BaseTool {
-  /**
-   * Base constructor for a tool.
-   *
-   * @param params The parameters for `BaseTool`.
-   */
-  constructor(params) {
-    var _a;
-    this.name = params.name;
-    this.description = params.description;
-    this.isLongRunning = (_a = params.isLongRunning) != null ? _a : 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({ toolContext, llmRequest }) {
-    const functionDeclaration = this._getDeclaration();
-    if (!functionDeclaration) {
-      return;
-    }
-    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 getGoogleLlmVariant();
-  }
-}
-function findToolWithFunctionDeclarations(llmRequest) {
-  var _a;
-  return (((_a = llmRequest.config) == null ? void 0 : _a.tools) || []).find((tool) => "functionDeclarations" in tool);
-}
-export {
-  BaseTool
-};

package/dist/esm/tools/base_toolset.js

@@ -1,46 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-class BaseToolset {
-  constructor(toolFilter) {
-    this.toolFilter = toolFilter;
-  }
-  /**
-   * 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) {
-  }
-}
-export {
-  BaseToolset
-};

package/dist/esm/tools/forwarding_artifact_service.js

@@ -1,41 +0,0 @@
-/**
- * @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(request) {
-    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
-    );
-  }
-}
-export {
-  ForwardingArtifactService
-};

package/dist/esm/tools/function_tool.js

@@ -1,71 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { ZodObject } from "zod";
-import { isZodObject, zodObjectToSchema } from "../utils/simple_zod_to_json.js";
-import { BaseTool } from "./base_tool.js";
-function toSchema(parameters) {
-  if (parameters === void 0) {
-    return { type: Type.OBJECT, properties: {} };
-  }
-  if (isZodObject(parameters)) {
-    return zodObjectToSchema(parameters);
-  }
-  return parameters;
-}
-class FunctionTool extends BaseTool {
-  /**
-   * The constructor acts as the user-friendly factory.
-   * @param options The configuration for the tool.
-   */
-  constructor(options) {
-    var _a;
-    const name = (_a = options.name) != null ? _a : 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
-    });
-    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 (this.parameters instanceof ZodObject) {
-        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}`);
-    }
-  }
-}
-export {
-  FunctionTool
-};