feat!: Dynamic MCP tool actions (v1.8.0) (#22)

* feat: add StreamableHTTP transport support and code quality improvements

- Add StreamableHTTPClientTransport for non-SSE HTTP connections
- Add headers support for HTTP transports (auth injection)
- Simplify error handling with errMsg helper
- Clean up verbose logging and redundant code
- Fix restartConnection to throw on missing connection

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* feat!: dynamic MCP tool actions with schema caching

BREAKING CHANGE: MCP tools are now registered as native ElizaOS actions instead of using a single CALL_MCP_TOOL action. This reduces LLM calls from 3 to 1 per tool invocation.

- **Dynamic Action Registration**: Each MCP tool becomes a native ElizaOS action (e.g., GOOGLE_SEARCH, GITHUB_GET_FILE)
- **Schema Caching**: Optional Redis/Upstash caching for tool schemas enables lazy connections
- **Tool Compatibility Layer**: Automatic schema transformation for different LLM providers (OpenAI, Anthropic, Google)
- **Parameter Validation**: Validates required parameters before calling MCP server

- Removed `CALL_MCP_TOOL` action and related templates
- Added `dynamic-tool-actions.ts` for action factory
- Added `schema-converter.ts` for JSON Schema to ActionParameter conversion
- Added `action-naming.ts` for collision-free action name generation
- Added `cache/schema-cache.ts` for optional Redis caching

- Comprehensive test suite (204 tests, 388 assertions)
- Removed dead code and over-engineering
- Fixed silent error swallowing
- Fixed ESM compatibility issues

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: 0xbbjoker

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elizaos/plugin-mcp",
   "description": "ElizaOS plugin to integrate with MCP (Model Context Protocol) servers",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -41,6 +41,8 @@
     "elizaos-plugins"
   ],
   "scripts": {
+    "test": "bun test tests/",
+    "test:watch": "bun test --watch tests/",
     "build": "bun run build.ts",
     "dev": "bun --hot build.ts",
     "clean": "rm -rf dist .turbo node_modules .turbo-tsconfig.json tsconfig.tsbuildinfo",

src/actions/callToolAction.ts

@@ -0,0 +1,122 @@
+import {
+  type Action,
+  type ActionResult,
+  type HandlerCallback,
+  type IAgentRuntime,
+  type Memory,
+  type State,
+  logger,
+} from "@elizaos/core";
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { McpService } from "../service";
+import { MCP_SERVICE_NAME } from "../types";
+import { type ActionParameter, convertJsonSchemaToActionParams, validateParamsAgainstSchema } from "../utils/schema-converter";
+import { toActionName, generateSimiles, makeUniqueActionName } from "../utils/action-naming";
+import { processToolResult } from "../utils/processing";
+
+export interface McpToolAction extends Action {
+  parameters?: Record<string, ActionParameter>;
+  _mcpMeta: { serverName: string; toolName: string; originalSchema: Tool["inputSchema"] };
+}
+
+function extractParams(message: Memory, state?: State): Record<string, unknown> {
+  const content = message.content as Record<string, unknown>;
+  return (content.actionParams as Record<string, unknown>) ||
+         (content.actionInput as Record<string, unknown>) ||
+         (state?.data?.actionParams as Record<string, unknown>) ||
+         {};
+}
+
+export function createMcpToolAction(serverName: string, tool: Tool, existingNames: Set<string>): McpToolAction {
+  const actionName = makeUniqueActionName(serverName, tool.name, existingNames);
+  const description = `${tool.description || `Execute ${tool.name}`} (MCP: ${serverName}/${tool.name})`;
+
+  return {
+    name: actionName,
+    description,
+    similes: generateSimiles(serverName, tool.name),
+    parameters: convertJsonSchemaToActionParams(tool.inputSchema),
+
+    validate: async (runtime: IAgentRuntime) => {
+      const svc = runtime.getService<McpService>(MCP_SERVICE_NAME);
+      if (!svc) return false;
+      if (svc.isLazyConnection(serverName)) return true;
+
+      const server = svc.getServers().find(s => s.name === serverName);
+      return server?.status === "connected" && !!server.tools?.some(t => t.name === tool.name);
+    },
+
+    handler: async (runtime, message, state, _options, callback): Promise<ActionResult> => {
+      const svc = runtime.getService<McpService>(MCP_SERVICE_NAME);
+      if (!svc) {
+        return { success: false, error: "MCP service not available", data: { actionName, serverName, toolName: tool.name } };
+      }
+
+      const params = extractParams(message, state);
+      logger.info({ serverName, toolName: tool.name, params }, `[MCP] Executing ${actionName}`);
+
+      const errors = validateParamsAgainstSchema(params, tool.inputSchema);
+      const missing = errors.filter(e => e.startsWith("Missing required"));
+      if (missing.length > 0) {
+        logger.error({ missing, params }, `[MCP] Missing required params for ${actionName}`);
+        return { success: false, error: missing.join(", "), data: { actionName, serverName, toolName: tool.name } };
+      }
+
+      const warnings = errors.filter(e => !e.startsWith("Missing required"));
+      if (warnings.length > 0) {
+        logger.warn({ warnings, params }, `[MCP] Type warnings for ${actionName}`);
+      }
+
+      const result = await svc.callTool(serverName, tool.name, params);
+      const { toolOutput, hasAttachments, attachments } = processToolResult(result, serverName, tool.name, runtime, message.entityId);
+
+      if (result.isError) {
+        logger.error({ serverName, toolName: tool.name, output: toolOutput }, `[MCP] Tool error`);
+        return {
+          success: false,
+          error: toolOutput || "Tool execution failed",
+          text: toolOutput,
+          data: { actionName, serverName, toolName: tool.name, toolArguments: params, isError: true },
+        };
+      }
+
+      if (callback && hasAttachments && attachments.length > 0) {
+        await callback({ text: `Executed ${serverName}/${tool.name}`, attachments });
+      }
+
+      return {
+        success: true,
+        text: toolOutput,
+        values: { success: true, serverName, toolName: tool.name, hasAttachments, output: toolOutput },
+        data: { actionName, serverName, toolName: tool.name, toolArguments: params, output: toolOutput, attachments: attachments.length > 0 ? attachments : undefined },
+      };
+    },
+
+    examples: [[
+      { name: "{{user}}", content: { text: `Can you use ${tool.name}?` } },
+      { name: "{{assistant}}", content: { text: `I'll execute ${tool.name} for you.`, actions: [actionName] } },
+    ]],
+
+    _mcpMeta: { serverName, toolName: tool.name, originalSchema: tool.inputSchema },
+  };
+}
+
+export function createMcpToolActions(serverName: string, tools: Tool[], existingNames: Set<string>): McpToolAction[] {
+  const actions = tools.map(tool => {
+    const action = createMcpToolAction(serverName, tool, existingNames);
+    existingNames.add(action.name);
+    logger.debug({ actionName: action.name, serverName, toolName: tool.name }, `[MCP] Created action`);
+    return action;
+  });
+
+  logger.info({ serverName, toolCount: actions.length }, `[MCP] Created ${actions.length} actions for ${serverName}`);
+  return actions;
+}
+
+export function isMcpToolAction(action: Action): action is McpToolAction {
+  return "_mcpMeta" in action && typeof (action as McpToolAction)._mcpMeta === "object";
+}
+
+export function getMcpToolActionsForServer(actions: Action[], serverName: string): McpToolAction[] {
+  return actions.filter((a): a is McpToolAction => isMcpToolAction(a) && a._mcpMeta.serverName === serverName);
+}

src/actions/dynamic-tool-actions.ts

@@ -0,0 +1,4 @@
+/**
+ * MCP Cache Module
+ */
+export { McpSchemaCache, getSchemaCache } from "./schema-cache";