@softactivate/adk 1.1.0

package/dist/cjs/tools/google_maps_grounding_tool.js

@@ -0,0 +1,80 @@
+/**
+  * @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 google_maps_grounding_tool_exports = {};
+__export(google_maps_grounding_tool_exports, {
+  GOOGLE_MAPS_GROUNDING: () => GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool: () => GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding: () => applyGoogleMapsGrounding
+});
+module.exports = __toCommonJS(google_maps_grounding_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function applyGoogleMapsGrounding(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = (0, import_model_name.isGeminiModelIdCheckDisabled)();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if ((0, import_model_name.isGemini1Model)(llmRequest.model)) {
+    throw new Error(
+      "Google Maps grounding tool cannot be used with Gemini 1.x models."
+    );
+  }
+  if ((0, import_model_name.isGeminiModel)(llmRequest.model) || modelCheckDisabled) {
+    llmRequest.config.tools.push({
+      googleMaps: {}
+    });
+    return;
+  }
+  throw new Error(
+    `Google maps tool is not supported for model ${llmRequest.model}`
+  );
+}
+class GoogleMapsGroundingTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({ name: "google_maps", description: "Google Maps Grounding Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    applyGoogleMapsGrounding(llmRequest);
+  }
+}
+const GOOGLE_MAPS_GROUNDING = new GoogleMapsGroundingTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding
+});

package/dist/cjs/tools/google_search_tool.js

@@ -0,0 +1,80 @@
+/**
+  * @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 google_search_tool_exports = {};
+__export(google_search_tool_exports, {
+  GOOGLE_SEARCH: () => GOOGLE_SEARCH,
+  GoogleSearchTool: () => GoogleSearchTool
+});
+module.exports = __toCommonJS(google_search_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class GoogleSearchTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({ name: "google_search", description: "Google Search Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    if ((0, import_model_name.isGemini1Model)(llmRequest.model)) {
+      if (llmRequest.config.tools.length > 0) {
+        throw new Error(
+          "Google search tool can not be used with other tools in Gemini 1.x."
+        );
+      }
+      llmRequest.config.tools.push({
+        googleSearchRetrieval: {}
+      });
+      return;
+    }
+    if ((0, import_model_name.isGeminiModel)(llmRequest.model)) {
+      llmRequest.config.tools.push({
+        googleSearch: {}
+      });
+      return;
+    }
+    throw new Error(
+      `Google search tool is not supported for model ${llmRequest.model}`
+    );
+  }
+}
+const GOOGLE_SEARCH = new GoogleSearchTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GOOGLE_SEARCH,
+  GoogleSearchTool
+});

package/dist/cjs/tools/load_artifacts_tool.js

@@ -0,0 +1,188 @@
+/**
+  * @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 load_artifacts_tool_exports = {};
+__export(load_artifacts_tool_exports, {
+  LOAD_ARTIFACTS: () => LOAD_ARTIFACTS,
+  LoadArtifactsTool: () => LoadArtifactsTool
+});
+module.exports = __toCommonJS(load_artifacts_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_request = require("../models/llm_request.js");
+var import_logger = require("../utils/logger.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = (0, import_logger.getLogger)();
+const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
+const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
+const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/csv",
+  "application/json",
+  "application/xml"
+]);
+function normalizeMimeType(mimeType) {
+  if (!mimeType) {
+    return void 0;
+  }
+  return mimeType.split(";")[0].trim();
+}
+function isInlineMimeTypeSupported(mimeType) {
+  const normalized = normalizeMimeType(mimeType);
+  if (!normalized) {
+    return false;
+  }
+  return GEMINI_SUPPORTED_INLINE_MIME_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
+}
+function asSafePartForLlm(artifact, artifactName) {
+  const inlineData = artifact.inlineData;
+  if (!inlineData) {
+    return artifact;
+  }
+  if (isInlineMimeTypeSupported(inlineData.mimeType)) {
+    return artifact;
+  }
+  const mimeType = normalizeMimeType(inlineData.mimeType) || "application/octet-stream";
+  const data = inlineData.data;
+  if (!data) {
+    return {
+      text: `[Artifact: ${artifactName}, type: ${mimeType}. No inline data was provided.]`
+    };
+  }
+  const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
+  const decodedBuffer = Buffer.from(data, "base64");
+  if (isTextLike) {
+    try {
+      const decoded = decodedBuffer.toString("utf8");
+      return { text: decoded };
+    } catch {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
+  };
+}
+class LoadArtifactsTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: `Loads artifacts into the session for this request.
+
+NOTE: Call when you need access to artifacts (for example, uploads saved by the web UI).`
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: import_genai.Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: import_genai.Type.ARRAY,
+            items: {
+              type: import_genai.Type.STRING
+            },
+            description: "The names of the artifacts to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const artifactNames = args["artifact_names"] || [];
+    return {
+      artifact_names: artifactNames,
+      status: "artifact contents temporarily inserted and removed. to access these artifacts, call load_artifacts tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendArtifactsToLlmRequest(
+      request.toolContext,
+      request.llmRequest
+    );
+  }
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    if (!toolContext.invocationContext.artifactService) {
+      return;
+    }
+    const artifactNames = await toolContext.listArtifacts();
+    if (!artifactNames || artifactNames.length === 0) {
+      return;
+    }
+    (0, import_llm_request.appendInstructions)(llmRequest, [
+      `You have a list of artifacts:
+  ${JSON.stringify(
+        artifactNames
+      )}
+
+  When the user asks questions about any of the artifacts, you should call the
+  \`load_artifacts\` function to load the artifact. Always call load_artifacts
+  before answering questions related to the artifacts, regardless of whether the
+  artifacts have been loaded before. Do not depend on prior answers about the
+  artifacts.`
+    ]);
+    const contents = llmRequest.contents;
+    if (contents && contents.length > 0) {
+      const lastContent = contents[contents.length - 1];
+      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
+        const functionResponsePart = lastContent.parts[0];
+        const functionResponse = functionResponsePart.functionResponse;
+        if (functionResponse && functionResponse.name === "load_artifacts") {
+          const response = functionResponse.response || {};
+          const namesToLoad = response["artifact_names"] || [];
+          for (const artifactName of namesToLoad) {
+            let artifact = await toolContext.loadArtifact(artifactName);
+            if (!artifact && !artifactName.startsWith("user:")) {
+              const prefixedName = `user:${artifactName}`;
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn(`Artifact "${artifactName}" not found, skipping`);
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+});

package/dist/cjs/tools/load_memory_tool.js

@@ -0,0 +1,107 @@
+/**
+  * @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 load_memory_tool_exports = {};
+__export(load_memory_tool_exports, {
+  LOAD_MEMORY: () => LOAD_MEMORY,
+  LoadMemoryTool: () => LoadMemoryTool
+});
+module.exports = __toCommonJS(load_memory_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_request = require("../models/llm_request.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class LoadMemoryTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: import_genai.Type.OBJECT,
+        properties: {
+          query: {
+            type: import_genai.Type.STRING,
+            description: "The query to load the memory for."
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    try {
+      const query = args["query"];
+      if (!toolContext.invocationContext.memoryService) {
+        throw new Error("Memory service is not initialized.");
+      }
+      const searchMemoryResponse = await toolContext.searchMemory(query);
+      return {
+        memories: searchMemoryResponse.memories.map((m) => {
+          var _a, _b;
+          return {
+            // Join all text parts by a space, or empty string if no text parts
+            content: (_b = (_a = m.content.parts) == null ? void 0 : _a.map((p) => {
+              var _a2;
+              return (_a2 = p.text) != null ? _a2 : "";
+            }).join(" ")) != null ? _b : "",
+            author: m.author,
+            timestamp: m.timestamp
+          };
+        })
+      };
+    } catch (e) {
+      console.error("ERROR in LoadMemoryTool runAsync:", e);
+      throw e;
+    }
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    if (!request.toolContext.invocationContext.memoryService) {
+      return;
+    }
+    (0, import_llm_request.appendInstructions)(request.llmRequest, [
+      `You have memory. You can use it to answer questions. If any questions need
+you to look up the memory, you should call load_memory function with a query.`
+    ]);
+  }
+}
+const LOAD_MEMORY = new LoadMemoryTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOAD_MEMORY,
+  LoadMemoryTool
+});

package/dist/cjs/tools/long_running_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 long_running_tool_exports = {};
+__export(long_running_tool_exports, {
+  LongRunningFunctionTool: () => LongRunningFunctionTool
+});
+module.exports = __toCommonJS(long_running_tool_exports);
+var import_function_tool = require("./function_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const LONG_RUNNING_INSTRUCTION = `
+
+NOTE: This is a long-running operation. Do not call this tool again if it has already returned some intermediate or pending status.`;
+class LongRunningFunctionTool extends import_function_tool.FunctionTool {
+  /**
+   * The constructor acts as the user-friendly factory.
+   * @param options The configuration for the tool.
+   */
+  constructor(options) {
+    super({ ...options, isLongRunning: true });
+  }
+  /**
+   * Provide a schema for the function.
+   */
+  _getDeclaration() {
+    const declaration = super._getDeclaration();
+    if (declaration.description) {
+      declaration.description += LONG_RUNNING_INSTRUCTION;
+    } else {
+      declaration.description = LONG_RUNNING_INSTRUCTION.trimStart();
+    }
+    return declaration;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LongRunningFunctionTool
+});

package/dist/cjs/tools/mcp/mcp_session_manager.js

@@ -0,0 +1,77 @@
+/**
+  * @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 mcp_session_manager_exports = {};
+__export(mcp_session_manager_exports, {
+  MCPSessionManager: () => MCPSessionManager
+});
+module.exports = __toCommonJS(mcp_session_manager_exports);
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MCPSessionManager {
+  constructor(connectionParams) {
+    this.connectionParams = connectionParams;
+  }
+  async createSession() {
+    var _a;
+    const client = new import_client.Client({ name: "MCPClient", version: "1.0.0" });
+    switch (this.connectionParams.type) {
+      case "StdioConnectionParams":
+        await client.connect(
+          new import_stdio.StdioClientTransport(this.connectionParams.serverParams)
+        );
+        break;
+      case "StreamableHTTPConnectionParams": {
+        const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
+        if (!options.requestInit && this.connectionParams.header !== void 0) {
+          options.requestInit = {
+            headers: this.connectionParams.header
+          };
+        }
+        await client.connect(
+          new import_streamableHttp.StreamableHTTPClientTransport(
+            new URL(this.connectionParams.url),
+            options
+          )
+        );
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = this.connectionParams;
+        break;
+      }
+    }
+    return client;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPSessionManager
+});

package/dist/cjs/tools/mcp/mcp_tool.js

@@ -0,0 +1,68 @@
+/**
+  * @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 mcp_tool_exports = {};
+__export(mcp_tool_exports, {
+  MCPTool: () => MCPTool
+});
+module.exports = __toCommonJS(mcp_tool_exports);
+var import_gemini_schema_util = require("../../utils/gemini_schema_util.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MCPTool extends import_base_tool.BaseTool {
+  constructor(mcpTool, mcpSessionManager, originalName) {
+    super({ name: mcpTool.name, description: mcpTool.description || "" });
+    this.mcpTool = mcpTool;
+    this.mcpSessionManager = mcpSessionManager;
+    this.originalName = originalName || mcpTool.name;
+  }
+  _getDeclaration() {
+    return {
+      name: this.mcpTool.name,
+      description: this.mcpTool.description,
+      parameters: (0, import_gemini_schema_util.toGeminiSchema)(this.mcpTool.inputSchema),
+      // TODO: need revisit, refer to this
+      // https://modelcontextprotocol.io/specification/2025-06-18/server/tools#tool-result
+      response: (0, import_gemini_schema_util.toGeminiSchema)(this.mcpTool.outputSchema)
+    };
+  }
+  async runAsync(request) {
+    const session = await this.mcpSessionManager.createSession();
+    const callRequest = {};
+    callRequest.params = { name: this.originalName, arguments: request.args };
+    const result = await session.callTool(callRequest.params, void 0, {
+      signal: request.toolContext.abortSignal
+    });
+    await session.close();
+    return result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPTool
+});