@elizaos/plugin-mcp 2.0.0-alpha.7 → 2.0.11-beta.7

package/dist/cjs/index.cjs

@@ -4,38 +4,59 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -349,7 +370,7 @@ IMPORTANT: ${constraintText}`;
       if (constraints.maxItems) {
         rules.push(`array must have at most ${constraints.maxItems} items`);
       }
-      return rules.length > 0 ? rules.join(", ") : JSON.stringify(constraints);
+      return rules.length > 0 ? rules.join(", ") : Object.entries(constraints).map(([key, value]) => `${key}: ${String(value)}`).join(", ");
     }
   };
 });
@@ -503,51 +524,16 @@ Constraints: ${constraintText}`;
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
+  handleMcpRoutes: () => handleMcpRoutes,
   default: () => src_default
 });
 module.exports = __toCommonJS(exports_src);
-var import_core7 = require("@elizaos/core");
+var import_core8 = require("@elizaos/core");
 
-// src/types.ts
-var MCP_SERVICE_NAME = "mcp";
-var DEFAULT_MCP_TIMEOUT_SECONDS = 60000;
-var DEFAULT_MAX_RETRIES = 2;
-var ResourceSelectionSchema = {
-  type: "object",
-  required: ["serverName", "uri"],
-  properties: {
-    serverName: {
-      type: "string",
-      minLength: 1,
-      errorMessage: "serverName must not be empty"
-    },
-    uri: {
-      type: "string",
-      minLength: 1,
-      errorMessage: "uri must not be empty"
-    },
-    reasoning: {
-      type: "string"
-    },
-    noResourceAvailable: {
-      type: "boolean"
-    }
-  }
-};
-var DEFAULT_PING_CONFIG = {
-  enabled: true,
-  intervalMs: 1e4,
-  timeoutMs: 5000,
-  failuresBeforeDisconnect: 3
-};
-var MAX_RECONNECT_ATTEMPTS = 5;
-var BACKOFF_MULTIPLIER = 2;
-var INITIAL_RETRY_DELAY = 2000;
-
-// src/utils/error.ts
-var import_core = require("@elizaos/core");
+// src/actions/mcp.ts
+var import_core5 = require("@elizaos/core");
 
-// src/generated/prompts/typescript/prompts.ts
+// src/prompts.ts
 var errorAnalysisTemplate = `{{{mcpProvider.text}}}
 
 {{{recentMessages}}}
@@ -572,15 +558,15 @@ var resourceAnalysisTemplate = `{{{mcpProvider.text}}}
 
 # Prompt
 
-You are a helpful assistant responding to a user's request. You've just accessed the resource "{{{uri}}}" to help answer this request.
+Respond to the user's request using the resource "{{{uri}}}".
 
 Original user request: "{{{userMessage}}}"
 
-Resource metadata: 
-{{{resourceMeta}}
+Resource metadata:
+{{{resourceMeta}}}
 
-Resource content: 
-{{{resourceContent}}
+Resource content:
+{{{resourceContent}}}
 
 Instructions:
 1. Analyze how well the resource's content addresses the user's specific question or need
@@ -597,45 +583,50 @@ var resourceSelectionTemplate = `{{{mcpProvider.text}}}
 
 # Prompt
 
-You are an intelligent assistant helping select the right resource to address a user's request.
+Select the right resource to address the user's request.
 
 CRITICAL INSTRUCTIONS:
 1. You MUST specify both a valid serverName AND uri from the list above
 2. The serverName value should match EXACTLY the server name shown in parentheses (Server: X)
-   CORRECT: "serverName": "github"  (if the server is called "github") 
-   WRONG: "serverName": "GitHub" or "Github" or any other variation
+   CORRECT: serverName: github (if the server is called "github")
+   WRONG: serverName: GitHub, serverName: Github, or any other variation
 3. The uri value should match EXACTLY the resource uri listed
-   CORRECT: "uri": "weather://San Francisco/current"  (if that's the exact uri)
-   WRONG: "uri": "weather://sanfrancisco/current" or any variation
+   CORRECT: uri: weather://San Francisco/current (if that's the exact uri)
+   WRONG: uri: weather://sanfrancisco/current or any variation
 4. Identify the user's information need from the conversation context
 5. Select the most appropriate resource based on its description and the request
-6. If no resource seems appropriate, output {"noResourceAvailable": true}
+6. If no resource seems appropriate, set noResourceAvailable: true
 
-!!! YOUR RESPONSE MUST BE A VALID JSON OBJECT ONLY !!! 
+Respond with compact JSON only.
 
 STRICT FORMAT REQUIREMENTS:
-- NO code block formatting (NO backticks or \`\`\`)
-- NO comments (NO // or /* */)
+- Include "noResourceAvailable": false when selecting a resource
+- NO code block formatting (NO backticks)
+- NO comments
 - NO placeholders like "replace with...", "example", "your...", "actual", etc.
 - Every parameter value must be a concrete, usable value (not instructions to replace)
-- Use proper JSON syntax with double quotes for strings
 - NO explanatory text before or after the JSON object
 
 EXAMPLE RESPONSE:
 {
   "serverName": "weather-server",
   "uri": "weather://San Francisco/current",
-  "reasoning": "Based on the conversation, the user is asking about current weather in San Francisco. This resource provides up-to-date weather information for that city."
+  "reasoning": "The user is asking about current weather in San Francisco. This resource provides up-to-date weather information for that city.",
+  "noResourceAvailable": false
 }
 
-REMEMBER: Your response will be parsed directly as JSON. If it fails to parse, the operation will fail completely!`;
+NO RESOURCE EXAMPLE:
+{
+  "reasoning": "None of the available resources match the user's request.",
+  "noResourceAvailable": true
+}`;
 var toolReasoningTemplate = `{{{mcpProvider.text}}}
 
 {{{recentMessages}}}
 
 # Prompt
 
-You are a helpful assistant responding to a user's request. You've just used the "{{{toolName}}}" tool from the "{{{serverName}}}" server to help answer this request.
+Synthesize the result from the "{{{toolName}}}" tool into a response to the user's request.
 
 Original user request: "{{{userMessage}}}"
 
@@ -657,34 +648,34 @@ Instructions:
 Your response (written as if directly to the user):`;
 var toolSelectionArgumentTemplate = `{{recentMessages}}
 
-# TASK: Generate a Strictly Valid JSON Object for Tool Execution
+# TASK: Generate Tool Arguments for Tool Execution
 
 You have chosen the "{{toolSelectionName.toolName}}" tool from the "{{toolSelectionName.serverName}}" server to address the user's request.
 The reasoning behind this selection is: "{{toolSelectionName.reasoning}}"
 
 ## CRITICAL INSTRUCTIONS
-1. Ensure the "toolArguments" object strictly adheres to the structure and requirements defined in the schema.
+1. Ensure the toolArguments block strictly adheres to the structure and requirements defined in the schema.
 2. All parameter values must be extracted from the conversation context and must be concrete, usable values.
 3. Avoid placeholders or generic terms unless explicitly provided by the user.
 
-!!! YOUR RESPONSE MUST BE A VALID JSON OBJECT ONLY !!! 
+Respond with compact JSON only.
 
 ## STRICT FORMAT REQUIREMENTS
-- The response MUST be a single valid JSON object.
-- DO NOT wrap the JSON in triple backticks (\`\`\`), code blocks, or include any explanatory text.
-- DO NOT include comments (// or /* */) anywhere.
+- The response MUST be one JSON object.
+- DO NOT wrap it in triple backticks, code blocks, or include any explanatory text.
+- DO NOT include comments anywhere.
 - DO NOT use placeholders (e.g., "replace with...", "example", "your...", etc.)
-- ALL strings must use double quotes
 
 ## CRITICAL NOTES
 - All values must be fully grounded in user input or inferred contextually.
 - No missing fields unless they are explicitly optional in the schema.
 - All types must match the schema (strings, numbers, booleans).
+- Put all executable parameters under the toolArguments object.
 
-## JSON OBJECT STRUCTURE
+## RESPONSE STRUCTURE
 Your response MUST contain ONLY these two top-level keys:
-1. "toolArguments" — An object matching the input schema: {{toolInputSchema}}
-2. "reasoning" — A string explaining how the values were inferred from the conversation.
+1. toolArguments - object with fields matching the input schema: {{toolInputSchema}}
+2. reasoning - a short explanation of how the values were inferred from the conversation.
 
 ## EXAMPLE RESPONSE
 {
@@ -697,50 +688,46 @@ Your response MUST contain ONLY these two top-level keys:
   "reasoning": "The user wants to see the README from the facebook/react repository based on our conversation."
 }
 
-REMEMBER: Your response will be parsed directly as JSON. If it fails to parse, the operation will fail completely.`;
+If the tool takes no arguments, use an empty toolArguments object:
+{
+  "toolArguments": {},
+  "reasoning": "The selected tool does not require arguments for this request."
+}`;
 var toolSelectionNameTemplate = `{{mcpProvider.text}}
 
 {{recentMessages}}
 
 # TASK: Select the Most Appropriate Tool and Server
 
-You must select the most appropriate tool from the list above to fulfill the user's request. Your response must be a valid JSON object with the required properties.
+You must select the most appropriate tool from the list above to fulfill the user's request. Respond with compact JSON.
 
 ## CRITICAL INSTRUCTIONS
-1. Provide both "serverName" and "toolName" from the options listed above.
+1. Provide both serverName and toolName from the options listed above.
 2. Each name must match EXACTLY as shown in the list:
-   - Example (correct): "serverName": "github"
-   - Example (incorrect): "serverName": "GitHub", "Github", or variations
+   - Example (correct): serverName: github
+   - Example (incorrect): serverName: GitHub, serverName: Github, or variations
 3. Extract ACTUAL parameter values from the conversation context.
    - Do not invent or use placeholders like "octocat" or "Hello-World" unless the user said so.
-4. Include a "reasoning" field explaining why the selected tool fits the request.
-5. If no tool is appropriate, respond with:
-   {
-     "noToolAvailable": true
-   }
-
-!!! YOUR RESPONSE MUST BE A VALID JSON OBJECT ONLY !!! 
-
-CRITICAL: Your response must START with { and END with }. DO NOT include ANY text before or after the JSON.
+4. Include a reasoning field explaining why the selected tool fits the request.
+5. If no tool is appropriate, set noToolAvailable: true.
 
 ## STRICT FORMAT REQUIREMENTS
-- The response MUST be a single valid JSON object.
-- DO NOT wrap the JSON in triple backticks (\`\`\`), code blocks, or include any explanatory text.
-- DO NOT include comments (// or /* */) anywhere.
+- The response MUST be one JSON object.
+- DO NOT wrap it in triple backticks, code blocks, or include any explanatory text.
+- DO NOT include comments anywhere.
 - DO NOT use placeholders (e.g., "replace with...", "example", "your...", etc.)
-- ALL strings must use double quotes.
 
 ## CRITICAL NOTES
 - All values must be fully grounded in user input or inferred contextually.
 - No missing fields unless they are explicitly optional in the schema.
 - All types must match the schema (strings, numbers, booleans).
 
-## JSON OBJECT STRUCTURE
+## RESPONSE STRUCTURE
 Your response MUST contain ONLY these top-level keys:
-1. "serverName" — The name of the server (e.g., "github", "notion")
-2. "toolName" — The name of the tool (e.g., "get_file_contents", "search")
-3. "reasoning" — A string explaining how the values were inferred from the conversation.
-4. "noToolAvailable" — A boolean indicating if no tool is available (true/false)
+1. serverName - The name of the server (e.g., github, notion)
+2. toolName - The name of the tool (e.g., get_file_contents, search)
+3. reasoning - A short explanation of how the values were inferred from the conversation
+4. noToolAvailable - true or false
 
 ## EXAMPLE RESPONSE
 {
@@ -750,12 +737,68 @@ Your response MUST contain ONLY these top-level keys:
   "noToolAvailable": false
 }
 
+## NO TOOL EXAMPLE
+{
+  "reasoning": "None of the available tools match the user's request.",
+  "noToolAvailable": true
+}
+
 ## REMINDERS
 - Use "github" as serverName for GitHub tools.
 - Use "notion" as serverName for Notion tools.
-- For search and knowledge-based tasks, MCP tools are often appropriate.
+- For search and knowledge-based tasks, MCP tools are often appropriate.`;
+
+// src/types.ts
+var MCP_SERVICE_NAME = "mcp";
+var DEFAULT_MCP_TIMEOUT_SECONDS = 60000;
+var DEFAULT_MAX_RETRIES = 2;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStdioMcpServerConfig(value) {
+  return isRecord(value) && value.type === "stdio" && typeof value.command === "string" && (value.args === undefined || Array.isArray(value.args) && value.args.every((arg) => typeof arg === "string")) && (value.env === undefined || isRecord(value.env) && Object.values(value.env).every((entry) => typeof entry === "string")) && (value.cwd === undefined || typeof value.cwd === "string") && (value.timeoutInMillis === undefined || typeof value.timeoutInMillis === "number");
+}
+function isHttpMcpServerConfig(value) {
+  return isRecord(value) && (value.type === "http" || value.type === "streamable-http" || value.type === "sse") && typeof value.url === "string" && (value.timeout === undefined || typeof value.timeout === "number");
+}
+function isMcpSettings(value) {
+  if (!isRecord(value) || !isRecord(value.servers)) {
+    return false;
+  }
+  return Object.values(value.servers).every((server) => isStdioMcpServerConfig(server) || isHttpMcpServerConfig(server)) && (value.maxRetries === undefined || typeof value.maxRetries === "number");
+}
+var ResourceSelectionSchema = {
+  type: "object",
+  required: ["serverName", "uri"],
+  properties: {
+    serverName: {
+      type: "string",
+      minLength: 1
+    },
+    uri: {
+      type: "string",
+      minLength: 1
+    },
+    reasoning: {
+      type: "string"
+    },
+    noResourceAvailable: {
+      type: "boolean"
+    }
+  }
+};
+var DEFAULT_PING_CONFIG = {
+  enabled: true,
+  intervalMs: 1e4,
+  timeoutMs: 5000,
+  failuresBeforeDisconnect: 3
+};
+var MAX_RECONNECT_ATTEMPTS = 5;
+var BACKOFF_MULTIPLIER = 2;
+var INITIAL_RETRY_DELAY = 2000;
 
-REMEMBER: This output will be parsed directly as JSON. If the format is incorrect, the operation will fail.`;
+// src/utils/error.ts
+var import_core = require("@elizaos/core");
 
 // src/templates/errorAnalysisPrompt.ts
 var errorAnalysisPrompt = errorAnalysisTemplate;
@@ -796,7 +839,8 @@ async function handleMcpError(state, mcpProvider, error, runtime, message, type,
       errorType: type
     },
     data: {
-      actionName: type === "tool" ? "CALL_MCP_TOOL" : "READ_MCP_RESOURCE",
+      actionName: "MCP",
+      op: type === "tool" ? "call_tool" : "read_resource",
       error: errorMessage,
       mcpType: type
     },
@@ -822,7 +866,8 @@ async function handleNoToolAvailable(callback, toolSelection) {
       fallbackToDirectAssistance: true
     },
     data: {
-      actionName: "CALL_MCP_TOOL",
+      actionName: "MCP",
+      op: "call_tool",
       noToolAvailable: true,
       reason: toolSelection?.reasoning ?? "No appropriate tool available"
     },
@@ -1088,12 +1133,12 @@ function parseJSON(input) {
   return import_json5.default.parse(cleanedInput);
 }
 var ajv = new import_ajv.default({
-  allErrors: true,
-  strict: false
+  allErrors: true
 });
 function formatAjvErrors(errors) {
   return errors.map((err) => {
-    const path = err.instancePath ? `${err.instancePath.replace(/^\//, "")}` : "value";
+    const errorPath = err.instancePath ?? err.dataPath ?? "";
+    const path = errorPath ? errorPath.replace(/^\//, "") : "value";
     return `${path}: ${err.message ?? "validation failed"}`;
   }).join(", ");
 }
@@ -1107,6 +1152,15 @@ function validateJsonSchema(data, schema) {
   }
   return { success: true, data };
 }
+function parseStructuredModelOutput(input) {
+  const errors = [];
+  try {
+    return parseJSON(input);
+  } catch {
+    errors.push("JSON object parse failed");
+  }
+  throw new Error(`No valid JSON object found: ${errors.join("; ")}`);
+}
 
 // src/utils/schemas.ts
 var toolSelectionNameSchema = {
@@ -1115,13 +1169,11 @@ var toolSelectionNameSchema = {
   properties: {
     serverName: {
       type: "string",
-      minLength: 1,
-      errorMessage: "serverName must not be empty"
+      minLength: 1
     },
     toolName: {
       type: "string",
-      minLength: 1,
-      errorMessage: "toolName must not be empty"
+      minLength: 1
     },
     reasoning: {
       type: "string"
@@ -1142,7 +1194,24 @@ var toolSelectionArgumentSchema = {
 };
 
 // src/utils/validation.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalReasoning(parsed) {
+  return typeof parsed.reasoning === "string" ? { reasoning: parsed.reasoning } : {};
+}
 function validateToolSelectionName(parsed, state) {
+  if (isRecord2(parsed) && parsed.noToolAvailable === true) {
+    return {
+      success: true,
+      data: {
+        serverName: "",
+        toolName: "",
+        noToolAvailable: true,
+        ...optionalReasoning(parsed)
+      }
+    };
+  }
   const basicResult = validateJsonSchema(parsed, toolSelectionNameSchema);
   if (basicResult.success === false) {
     return { success: false, error: basicResult.error };
@@ -1150,7 +1219,7 @@ function validateToolSelectionName(parsed, state) {
   const data = basicResult.data;
   const mcpData = state.values.mcp ?? {};
   const server = mcpData[data.serverName];
-  if (!server || server.status !== "connected") {
+  if (server?.status !== "connected") {
     return {
       success: false,
       error: `Server "${data.serverName}" not found or not connected`
@@ -1166,7 +1235,8 @@ function validateToolSelectionName(parsed, state) {
   return { success: true, data };
 }
 function validateToolSelectionArgument(parsed, toolInputSchema) {
-  const basicResult = validateJsonSchema(parsed, toolSelectionArgumentSchema);
+  const normalizedParsed = isRecord2(parsed) && typeof parsed.toolArguments === "string" && ["", "{}"].includes(parsed.toolArguments.trim()) ? { ...parsed, toolArguments: {} } : parsed;
+  const basicResult = validateJsonSchema(normalizedParsed, toolSelectionArgumentSchema);
   if (basicResult.success === false) {
     return { success: false, error: basicResult.error };
   }
@@ -1181,6 +1251,17 @@ function validateToolSelectionArgument(parsed, toolInputSchema) {
   return { success: true, data };
 }
 function validateResourceSelection(selection) {
+  if (isRecord2(selection) && selection.noResourceAvailable === true) {
+    return {
+      success: true,
+      data: {
+        serverName: "",
+        uri: "",
+        noResourceAvailable: true,
+        ...optionalReasoning(selection)
+      }
+    };
+  }
   return validateJsonSchema(selection, ResourceSelectionSchema);
 }
 function createToolSelectionFeedbackPrompt(originalResponse, errorMessage, composedState, userMessage) {
@@ -1228,16 +1309,18 @@ function createResourceSelectionFeedbackPrompt(originalResponse, errorMessage, c
   return createFeedbackPrompt(originalResponse, errorMessage, "resource", resourcesDescription, userMessage);
 }
 function createFeedbackPrompt(originalResponse, errorMessage, itemType, itemsDescription, userMessage) {
-  return `Error parsing JSON: ${errorMessage}
+  return `The previous ${itemType} selection could not be parsed or validated: ${errorMessage}
 
 Your original response:
 ${originalResponse}
 
-Please try again with valid JSON for ${itemType} selection.
+Reply again as compact JSON for ${itemType} selection.
 Available ${itemType}s:
 ${itemsDescription}
 
-User request: ${userMessage}`;
+User request: ${userMessage}
+
+Use exact names from the list. For tools, return a JSON object with serverName, toolName, reasoning, and noToolAvailable. For resources, return a JSON object with serverName, uri, reasoning, and noResourceAvailable.`;
 }
 
 // src/utils/wrapper.ts
@@ -1254,15 +1337,21 @@ async function withModelRetry({
   retryCount = 0
 }) {
   const maxRetries = getMaxRetries(runtime);
-  const parsedJson = typeof input === "string" ? parseJSON(input) : input;
-  const validationResult = validationFn(parsedJson);
+  let validationResult;
+  try {
+    const parsedInput = typeof input === "string" ? parseStructuredModelOutput(input) : input;
+    validationResult = validationFn(parsedInput);
+  } catch (error) {
+    const errorMessage2 = error instanceof Error ? error.message : String(error);
+    validationResult = { success: false, error: errorMessage2 };
+  }
   if (validationResult.success) {
     return validationResult.data;
   }
   const errorMessage = validationResult.error;
   if (retryCount < maxRetries) {
     const feedbackPrompt = createFeedbackPromptFn(input, errorMessage, state, message.content.text ?? "");
-    const retrySelection = await runtime.useModel(import_core3.ModelType.OBJECT_LARGE, {
+    const retrySelection = await runtime.useModel(import_core3.ModelType.TEXT_LARGE, {
       prompt: feedbackPrompt
     });
     return withModelRetry({
@@ -1287,11 +1376,8 @@ async function withModelRetry({
 }
 function getMaxRetries(runtime) {
   const rawSettings = runtime.getSetting("mcp");
-  if (rawSettings && typeof rawSettings === "object") {
-    const settings = rawSettings;
-    if (typeof settings.maxRetries === "number" && settings.maxRetries >= 0) {
-      return settings.maxRetries;
-    }
+  if (isMcpSettings(rawSettings) && typeof rawSettings.maxRetries === "number" && rawSettings.maxRetries >= 0) {
+    return rawSettings.maxRetries;
   }
   return DEFAULT_MAX_RETRIES;
 }
@@ -1304,8 +1390,16 @@ async function createToolSelectionName({
   callback,
   mcpProvider
 }) {
+  const stateWithMcp = {
+    ...state,
+    values: {
+      ...state.values,
+      mcp: state.values.mcp ?? mcpProvider.data.mcp,
+      mcpProvider
+    }
+  };
   const toolSelectionPrompt = import_core4.composePromptFromState({
-    state: { ...state, values: { ...state.values, mcpProvider } },
+    state: stateWithMcp,
     template: toolSelectionNameTemplate
   });
   const toolSelectionName = await runtime.useModel(import_core4.ModelType.TEXT_LARGE, {
@@ -1314,10 +1408,10 @@ async function createToolSelectionName({
   return await withModelRetry({
     runtime,
     message,
-    state,
+    state: stateWithMcp,
     callback,
     input: toolSelectionName,
-    validationFn: (parsed) => validateToolSelectionName(parsed, state),
+    validationFn: (parsed) => validateToolSelectionName(parsed, stateWithMcp),
     createFeedbackPromptFn: (originalResponse, errorMessage, composedState, userMessage) => createToolSelectionFeedbackPrompt(typeof originalResponse === "string" ? originalResponse : JSON.stringify(originalResponse), errorMessage, composedState, userMessage),
     failureMsg: "I'm having trouble figuring out the best way to help with your request."
   });
@@ -1369,138 +1463,48 @@ async function createToolSelectionArgument({
   });
 }
 
-// src/actions/callToolAction.ts
-var callToolAction = {
-  name: "CALL_MCP_TOOL",
-  similes: [
-    "CALL_TOOL",
-    "CALL_MCP_TOOL",
-    "USE_TOOL",
-    "USE_MCP_TOOL",
-    "EXECUTE_TOOL",
-    "EXECUTE_MCP_TOOL",
-    "RUN_TOOL",
-    "RUN_MCP_TOOL",
-    "INVOKE_TOOL",
-    "INVOKE_MCP_TOOL"
-  ],
-  description: "Calls a tool from an MCP server to perform a specific task",
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["call", "mcp", "tool"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:call|mcp|tool)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const mcpService = runtime2.getService(MCP_SERVICE_NAME);
-      if (!mcpService)
-        return false;
-      const servers = mcpService.getServers();
-      return servers.length > 0 && servers.some((server) => server.status === "connected" && server.tools && server.tools.length > 0);
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    const composedState = await runtime.composeState(message, ["RECENT_MESSAGES", "MCP"]);
-    const mcpService = runtime.getService(MCP_SERVICE_NAME);
-    if (!mcpService) {
-      throw new Error("MCP service not available");
-    }
-    const mcpProvider = mcpService.getProviderData();
-    try {
-      const toolSelectionName = await createToolSelectionName({
-        runtime,
-        state: composedState,
-        message,
-        callback,
-        mcpProvider
-      });
-      if (!toolSelectionName || toolSelectionName.noToolAvailable) {
-        return await handleNoToolAvailable(callback, toolSelectionName);
-      }
-      const { serverName, toolName } = toolSelectionName;
-      const toolSelectionArgument = await createToolSelectionArgument({
-        runtime,
-        state: composedState,
-        message,
-        callback,
-        mcpProvider,
-        toolSelectionName
-      });
-      if (!toolSelectionArgument) {
-        return await handleNoToolAvailable(callback, toolSelectionName);
-      }
-      const result = await mcpService.callTool(serverName, toolName, toolSelectionArgument.toolArguments);
-      const { toolOutput, hasAttachments, attachments } = processToolResult(result, serverName, toolName, runtime, message.entityId);
-      const replyMemory = await handleToolResponse(runtime, message, serverName, toolName, toolSelectionArgument.toolArguments, toolOutput, hasAttachments, attachments, composedState, mcpProvider, callback);
-      return {
-        text: `Successfully called tool: ${serverName}/${toolName}. Reasoned response: ${replyMemory.content.text}`,
-        values: {
-          success: true,
-          toolExecuted: true,
-          serverName,
-          toolName,
-          hasAttachments,
-          output: toolOutput
-        },
-        data: {
-          actionName: "CALL_MCP_TOOL",
-          serverName,
-          toolName,
-          toolArgumentsJson: JSON.stringify(toolSelectionArgument.toolArguments),
-          reasoning: toolSelectionName.reasoning,
-          output: toolOutput,
-          attachmentCount: attachments?.length ?? 0
-        },
-        success: true
-      };
-    } catch (error) {
-      return await handleMcpError(composedState, mcpProvider, error, runtime, message, "tool", callback);
-    }
-  },
-  examples: [
-    [
-      {
-        name: "{{user}}",
-        content: {
-          text: "Can you search for information about climate change?"
-        }
-      },
-      {
-        name: "{{assistant}}",
-        content: {
-          text: "I'll help you with that request. Let me access the right tool...",
-          actions: ["CALL_MCP_TOOL"]
-        }
-      },
-      {
-        name: "{{assistant}}",
-        content: {
-          text: `I found the following information about climate change:
-
-Climate change refers to long-term shifts in temperatures and weather patterns. These shifts may be natural, but since the 1800s, human activities have been the main driver of climate change, primarily due to the burning of fossil fuels like coal, oil, and gas, which produces heat-trapping gases.`,
-          actions: ["CALL_MCP_TOOL"]
-        }
-      }
-    ]
-  ]
-};
-
-// src/actions/readResourceAction.ts
-var import_core5 = require("@elizaos/core");
+// src/actions/mcp.ts
+var MCP_ACTION_CONTEXT = "mcp";
+function readOptions(options) {
+  const direct = options ?? {};
+  const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
+  return { ...direct, ...parameters };
+}
+function normalizeOp(value) {
+  if (typeof value !== "string")
+    return null;
+  const v = value.trim().toLowerCase();
+  if (v === "call_tool" || v === "tool" || v === "call")
+    return "call_tool";
+  if (v === "read_resource" || v === "resource" || v === "read")
+    return "read_resource";
+  if (v === "search_actions" || v === "search" || v === "discover")
+    return "search_actions";
+  if (v === "list_connections" || v === "list" || v === "connections")
+    return "list_connections";
+  return null;
+}
+function inferOpFromText(text) {
+  if (/\b(read|get|fetch|access|open|list)\b.*\b(resource|resources|document|docs?|file)\b/i.test(text)) {
+    return "read_resource";
+  }
+  if (/\b(call|use|run|execute|invoke|search|query)\b.*\b(tool|tools|mcp)\b/i.test(text)) {
+    return "call_tool";
+  }
+  return null;
+}
+function getDirectResourceSelection(options) {
+  const params = readOptions(options);
+  const serverName = typeof params.serverName === "string" ? params.serverName.trim() : "";
+  const uri = typeof params.uri === "string" ? params.uri.trim() : "";
+  if (!serverName || !uri)
+    return null;
+  return {
+    serverName,
+    uri,
+    reasoning: typeof params.reasoning === "string" && params.reasoning.trim() ? params.reasoning.trim() : "Selected from structured MCP read_resource parameters."
+  };
+}
 function createResourceSelectionPrompt(composedState, userMessage) {
   const mcpData = composedState.values.mcp ?? {};
   const serverNames = Object.keys(mcpData);
@@ -1536,61 +1540,80 @@ function createResourceSelectionPrompt(composedState, userMessage) {
     template: resourceSelectionTemplate
   });
 }
-var readResourceAction = {
-  name: "READ_MCP_RESOURCE",
-  similes: [
-    "READ_RESOURCE",
-    "READ_MCP_RESOURCE",
-    "GET_RESOURCE",
-    "GET_MCP_RESOURCE",
-    "FETCH_RESOURCE",
-    "FETCH_MCP_RESOURCE",
-    "ACCESS_RESOURCE",
-    "ACCESS_MCP_RESOURCE"
-  ],
-  description: "Reads a resource from an MCP server",
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["read", "mcp", "resource"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:read|mcp|resource)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const mcpService = runtime2.getService(MCP_SERVICE_NAME);
-      if (!mcpService)
-        return false;
-      const servers = mcpService.getServers();
-      return servers.length > 0 && servers.some((server) => server.status === "connected" && server.resources && server.resources.length > 0);
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
+async function handleCallTool(runtime, message, callback) {
+  const composedState = await runtime.composeState(message, ["RECENT_MESSAGES", "MCP"]);
+  const mcpService = runtime.getService(MCP_SERVICE_NAME);
+  if (!mcpService) {
+    throw new Error("MCP service not available");
+  }
+  const mcpProvider = mcpService.getProviderData();
+  try {
+    const toolSelectionName = await createToolSelectionName({
+      runtime,
+      state: composedState,
+      message,
+      callback,
+      mcpProvider
+    });
+    if (!toolSelectionName || toolSelectionName.noToolAvailable) {
+      return await handleNoToolAvailable(callback, toolSelectionName);
     }
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    const composedState = await runtime.composeState(message, ["RECENT_MESSAGES", "MCP"]);
-    const mcpService = runtime.getService(MCP_SERVICE_NAME);
-    if (!mcpService) {
-      throw new Error("MCP service not available");
+    const { serverName, toolName } = toolSelectionName;
+    const toolSelectionArgument = await createToolSelectionArgument({
+      runtime,
+      state: composedState,
+      message,
+      callback,
+      mcpProvider,
+      toolSelectionName
+    });
+    if (!toolSelectionArgument) {
+      return await handleNoToolAvailable(callback, toolSelectionName);
     }
-    const mcpProvider = mcpService.getProviderData();
-    try {
-      await sendInitialResponse(callback);
+    const result = await mcpService.callTool(serverName, toolName, toolSelectionArgument.toolArguments);
+    const { toolOutput, hasAttachments, attachments } = processToolResult(result, serverName, toolName, runtime, message.entityId);
+    const replyMemory = await handleToolResponse(runtime, message, serverName, toolName, toolSelectionArgument.toolArguments, toolOutput, hasAttachments, attachments, composedState, mcpProvider, callback);
+    return {
+      text: `Successfully called tool: ${serverName}/${toolName}. Reasoned response: ${replyMemory.content.text}`,
+      values: {
+        success: true,
+        toolExecuted: true,
+        serverName,
+        toolName,
+        hasAttachments,
+        output: toolOutput
+      },
+      data: {
+        actionName: "MCP",
+        op: "call_tool",
+        serverName,
+        toolName,
+        toolArgumentsJson: JSON.stringify(toolSelectionArgument.toolArguments),
+        reasoning: toolSelectionName.reasoning,
+        output: toolOutput,
+        attachmentCount: attachments?.length ?? 0
+      },
+      success: true
+    };
+  } catch (error) {
+    return await handleMcpError(composedState, mcpProvider, error, runtime, message, "tool", callback);
+  }
+}
+async function handleReadResource(runtime, message, options, callback) {
+  const composedState = await runtime.composeState(message, ["RECENT_MESSAGES", "MCP"]);
+  const mcpService = runtime.getService(MCP_SERVICE_NAME);
+  if (!mcpService) {
+    throw new Error("MCP service not available");
+  }
+  const mcpProvider = mcpService.getProviderData();
+  try {
+    await sendInitialResponse(callback);
+    const parsedSelection = getDirectResourceSelection(options) ?? await (async () => {
       const resourceSelectionPrompt = createResourceSelectionPrompt(composedState, message.content.text ?? "");
       const resourceSelection = await runtime.useModel(import_core5.ModelType.TEXT_SMALL, {
         prompt: resourceSelectionPrompt
       });
-      const parsedSelection = await withModelRetry({
+      return withModelRetry({
         runtime,
         state: composedState,
         message,
@@ -1601,75 +1624,210 @@ var readResourceAction = {
         failureMsg: `I'm having trouble finding the resource you're looking for. Could you provide more details about what you need?`,
         retryCount: 0
       });
-      if (!parsedSelection || parsedSelection.noResourceAvailable) {
-        const responseText = "I don't have a specific resource that contains the information you're looking for. Let me try to assist you directly instead.";
-        if (callback && parsedSelection?.noResourceAvailable) {
-          await callback({
-            text: responseText,
-            actions: ["REPLY"]
-          });
-        }
-        return {
+    })();
+    if (!parsedSelection || parsedSelection.noResourceAvailable) {
+      const responseText = "I don't have a specific resource that contains the information you're looking for. Let me try to assist you directly instead.";
+      if (callback && parsedSelection?.noResourceAvailable) {
+        await callback({
           text: responseText,
-          values: {
-            success: true,
-            noResourceAvailable: true,
-            fallbackToDirectAssistance: true
-          },
-          data: {
-            actionName: "READ_MCP_RESOURCE",
-            noResourceAvailable: true,
-            reason: parsedSelection?.reasoning ?? "No appropriate resource available"
-          },
-          success: true
-        };
+          actions: ["REPLY"]
+        });
       }
-      const { serverName, uri } = parsedSelection;
-      const result = await mcpService.readResource(serverName, uri);
-      const { resourceContent, resourceMeta } = processResourceResult(result, uri);
-      await handleResourceAnalysis(runtime, message, uri, serverName, resourceContent, resourceMeta, callback);
       return {
-        text: `Successfully read resource: ${uri}`,
+        text: responseText,
         values: {
           success: true,
-          resourceRead: true,
-          serverName,
-          uri
+          noResourceAvailable: true,
+          fallbackToDirectAssistance: true
         },
         data: {
-          actionName: "READ_MCP_RESOURCE",
-          serverName,
-          uri,
-          reasoning: parsedSelection?.reasoning,
-          resourceMeta,
-          contentLength: resourceContent?.length ?? 0
+          actionName: "MCP",
+          op: "read_resource",
+          noResourceAvailable: true,
+          reason: parsedSelection?.reasoning ?? "No appropriate resource available"
         },
         success: true
       };
-    } catch (error) {
-      return await handleMcpError(composedState, mcpProvider, error, runtime, message, "resource", callback);
     }
+    const { serverName, uri } = parsedSelection;
+    const result = await mcpService.readResource(serverName, uri);
+    const { resourceContent, resourceMeta } = processResourceResult(result, uri);
+    await handleResourceAnalysis(runtime, message, uri, serverName, resourceContent, resourceMeta, callback);
+    return {
+      text: `Successfully read resource: ${uri}`,
+      values: {
+        success: true,
+        resourceRead: true,
+        serverName,
+        uri
+      },
+      data: {
+        actionName: "MCP",
+        op: "read_resource",
+        serverName,
+        uri,
+        reasoning: parsedSelection?.reasoning,
+        resourceMeta,
+        contentLength: resourceContent?.length ?? 0
+      },
+      success: true
+    };
+  } catch (error) {
+    return await handleMcpError(composedState, mcpProvider, error, runtime, message, "resource", callback);
+  }
+}
+function textOf(message) {
+  return typeof message.content?.text === "string" ? message.content.text : "";
+}
+function hasConnectedCapability(runtime) {
+  const mcpService = runtime.getService(MCP_SERVICE_NAME);
+  if (!mcpService)
+    return false;
+  return mcpService.getServers().some((server) => {
+    if (server.status !== "connected")
+      return false;
+    return (server.tools?.length ?? 0) > 0 || (server.resources?.length ?? 0) > 0;
+  });
+}
+var mcpAction = {
+  name: "MCP",
+  contexts: ["general", "automation", "knowledge", "connectors", MCP_ACTION_CONTEXT, "files"],
+  contextGate: {
+    anyOf: ["general", "automation", "knowledge", "connectors", MCP_ACTION_CONTEXT, "files"]
+  },
+  roleGate: { minRole: "USER" },
+  similes: [
+    "MCP_ACTION",
+    "MCP_ROUTER",
+    "USE_MCP",
+    "CALL_MCP_TOOL",
+    "CALL_TOOL",
+    "USE_TOOL",
+    "USE_MCP_TOOL",
+    "EXECUTE_TOOL",
+    "EXECUTE_MCP_TOOL",
+    "RUN_TOOL",
+    "RUN_MCP_TOOL",
+    "INVOKE_TOOL",
+    "INVOKE_MCP_TOOL",
+    "READ_MCP_RESOURCE",
+    "READ_RESOURCE",
+    "GET_RESOURCE",
+    "GET_MCP_RESOURCE",
+    "FETCH_RESOURCE",
+    "FETCH_MCP_RESOURCE",
+    "ACCESS_RESOURCE",
+    "ACCESS_MCP_RESOURCE"
+  ],
+  description: "Single MCP entry point. Use action=call_tool to invoke an MCP tool, action=read_resource to read an MCP resource. Cloud runtimes also accept action=search_actions and action=list_connections.",
+  descriptionCompressed: "MCP call_tool read_resource search_actions list_connections",
+  parameters: [
+    {
+      name: "action",
+      description: "MCP operation: call_tool | read_resource | search_actions | list_connections",
+      required: false,
+      schema: {
+        type: "string",
+        enum: ["call_tool", "read_resource", "search_actions", "list_connections"]
+      }
+    },
+    {
+      name: "serverName",
+      description: "Optional MCP server name that owns the tool or resource.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "toolName",
+      description: "For action=call_tool: optional exact MCP tool name to call.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "arguments",
+      description: "For action=call_tool: optional JSON arguments to pass to the selected MCP tool.",
+      required: false,
+      schema: { type: "object" }
+    },
+    {
+      name: "uri",
+      description: "For action=read_resource: exact MCP resource URI to read.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "query",
+      description: "Natural-language description of the tool call or resource to select; for action=search_actions, the keyword query.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "platform",
+      description: "For action=search_actions: filter results to a single connected platform.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "limit",
+      description: "For action=search_actions: maximum results to return.",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "offset",
+      description: "For action=search_actions: skip first N results for pagination.",
+      required: false,
+      schema: { type: "number" }
+    }
+  ],
+  validate: async (runtime) => {
+    if (!hasConnectedCapability(runtime))
+      return false;
+    return true;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const opts = readOptions(options);
+    const requested = normalizeOp(opts.action ?? opts.subaction ?? opts.op ?? opts.operation);
+    const op = requested ?? inferOpFromText(textOf(message)) ?? "call_tool";
+    if (op === "read_resource") {
+      return handleReadResource(runtime, message, options, callback);
+    }
+    if (op === "search_actions" || op === "list_connections") {
+      const text = `MCP op=${op} is only available in the cloud runtime.`;
+      await callback?.({ text, source: message.content?.source });
+      return {
+        success: false,
+        text,
+        values: { error: "OP_NOT_SUPPORTED" },
+        data: { actionName: "MCP", op }
+      };
+    }
+    return handleCallTool(runtime, message, callback);
   },
   examples: [
     [
       {
         name: "{{user}}",
-        content: {
-          text: "Can you get the documentation about installing elizaOS?"
-        }
+        content: { text: "Use the MCP GitHub tool to read the repository README" }
       },
       {
         name: "{{assistant}}",
         content: {
-          text: `I'll retrieve that information for you. Let me access the resource...`,
-          actions: ["READ_MCP_RESOURCE"]
+          text: "I'll route that through MCP.",
+          actions: ["MCP"]
         }
+      }
+    ],
+    [
+      {
+        name: "{{user}}",
+        content: { text: "Can you get the documentation about installing elizaOS?" }
       },
       {
         name: "{{assistant}}",
         content: {
-          text: `elizaOS installation is straightforward. You'll need Node.js 23+ and Git installed. For Windows users, WSL 2 is required. The quickest way to get started is by cloning the elizaOS starter repository with \`git clone https://github.com/elizaos/eliza-starter.git\`, then run \`cd eliza-starter && cp .env.example .env && bun i && bun run build && bun start\`. This will set up a development environment with the core features enabled. After starting, you can access the web interface at http://localhost:3000 to interact with your agent.`,
-          actions: ["READ_MCP_RESOURCE"]
+          text: "I'll read the MCP resource for that.",
+          actions: ["MCP"]
         }
       }
     ]
@@ -1677,10 +1835,36 @@ var readResourceAction = {
 };
 
 // src/provider.ts
+var MAX_MCP_SERVERS_IN_STATE = 20;
+var MAX_MCP_TOOLS_PER_SERVER = 30;
+var MAX_MCP_RESOURCES_PER_SERVER = 30;
+function formatMcpServersForPrompt(mcp) {
+  const entries = Object.entries(mcp).slice(0, MAX_MCP_SERVERS_IN_STATE);
+  if (entries.length === 0)
+    return "No MCP servers are available.";
+  return [
+    `mcpServers[${Object.keys(mcp).length}, showing ${entries.length}]:`,
+    ...entries.flatMap(([serverName, server]) => {
+      const tools = Object.keys(server.tools ?? {}).slice(0, MAX_MCP_TOOLS_PER_SERVER);
+      const resources = Object.keys(server.resources ?? {}).slice(0, MAX_MCP_RESOURCES_PER_SERVER);
+      return [
+        `  - name: ${serverName}`,
+        `    status: ${server.status}`,
+        `    tools: ${tools.length > 0 ? tools.join(", ") : "none"}`,
+        `    resources: ${resources.length > 0 ? resources.join(", ") : "none"}`
+      ];
+    })
+  ].join(`
+`);
+}
 var provider = {
   name: "MCP",
   description: "Information about connected MCP servers, tools, and resources",
   dynamic: true,
+  contexts: ["connectors", "settings"],
+  contextGate: { anyOf: ["connectors", "settings"] },
+  cacheStable: false,
+  cacheScope: "turn",
   get: async (runtime, _message, _state) => {
     const mcpService = runtime.getService(MCP_SERVICE_NAME);
     if (!mcpService) {
@@ -1690,17 +1874,31 @@ var provider = {
         text: "No MCP servers are available."
       };
     }
-    const providerData = mcpService.getProviderData();
-    return {
-      values: { mcpServers: JSON.stringify(providerData.values.mcp) },
-      data: { mcpServerCount: Object.keys(providerData.data.mcp).length },
-      text: providerData.text
-    };
+    try {
+      const providerData = mcpService.getProviderData();
+      const mcp = providerData.values.mcp;
+      const serverEntries = Object.entries(providerData.data.mcp).slice(0, MAX_MCP_SERVERS_IN_STATE);
+      return {
+        values: { mcpServers: formatMcpServersForPrompt(mcp) },
+        data: {
+          mcpServerCount: Object.keys(providerData.data.mcp).length,
+          shownMcpServerCount: serverEntries.length
+        },
+        text: formatMcpServersForPrompt(mcp)
+      };
+    } catch (error) {
+      return {
+        values: {},
+        data: { error: error instanceof Error ? error.message : String(error) },
+        text: "No MCP servers are available."
+      };
+    }
   }
 };
 
 // src/service.ts
 var import_core6 = require("@elizaos/core");
+var import_mcp_server_config = require("@elizaos/security/mcp-server-config");
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
 var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
 var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
@@ -1742,7 +1940,9 @@ class McpService extends import_core6.Service {
   initializationPromise = null;
   constructor(runtime) {
     super(runtime);
-    this.initializationPromise = this.initializeMcpServers();
+    if (runtime) {
+      this.initializationPromise = this.initializeMcpServers();
+    }
   }
   static async start(runtime) {
     const service = new McpService(runtime);
@@ -1771,7 +1971,7 @@ class McpService extends import_core6.Service {
   }
   async initializeMcpServers() {
     const mcpSettings = this.getMcpSettings();
-    if (!mcpSettings || !mcpSettings.servers || Object.keys(mcpSettings.servers).length === 0) {
+    if (!mcpSettings?.servers || Object.keys(mcpSettings.servers).length === 0) {
       this.mcpProvider = buildMcpProviderData([]);
       return;
     }
@@ -1782,17 +1982,14 @@ class McpService extends import_core6.Service {
   getMcpSettings() {
     const rawSettings = this.runtime.getSetting("mcp");
     let settings = null;
-    if (rawSettings && typeof rawSettings === "object" && !Array.isArray(rawSettings)) {
-      const parsed = rawSettings;
-      if ("servers" in parsed && typeof parsed.servers === "object" && parsed.servers !== null) {
-        settings = parsed;
-      }
+    if (isMcpSettings(rawSettings)) {
+      settings = rawSettings;
     }
-    if (!settings || !settings.servers) {
+    if (!settings?.servers) {
       const characterSettings = this.runtime.character.settings;
       if (characterSettings && typeof characterSettings === "object" && "mcp" in characterSettings) {
         const characterMcpSettings = characterSettings.mcp;
-        if (characterMcpSettings && typeof characterMcpSettings === "object" && "servers" in characterMcpSettings) {
+        if (isMcpSettings(characterMcpSettings)) {
           settings = characterMcpSettings;
         }
       }
@@ -1802,15 +1999,28 @@ class McpService extends import_core6.Service {
     }
     return;
   }
+  async filterValidatedServerConfigs(serverConfigs) {
+    const validated = {};
+    for (const [name, config] of Object.entries(serverConfigs)) {
+      const rejection = await import_mcp_server_config.validateMcpServerConfig(config);
+      if (rejection) {
+        import_core6.logger.error({ server: name, rejection }, "Skipping MCP server with invalid or unsafe config");
+        continue;
+      }
+      validated[name] = config;
+    }
+    return validated;
+  }
   async updateServerConnections(serverConfigs) {
+    const safeConfigs = await this.filterValidatedServerConfigs(serverConfigs);
     const currentNames = new Set(this.connections.keys());
-    const newNames = new Set(Object.keys(serverConfigs));
+    const newNames = new Set(Object.keys(safeConfigs));
     for (const name of currentNames) {
       if (!newNames.has(name)) {
         await this.deleteConnection(name);
       }
     }
-    const connectionPromises = Object.entries(serverConfigs).map(async ([name, config]) => {
+    const connectionPromises = Object.entries(safeConfigs).map(async ([name, config]) => {
       const currentConnection = this.connections.get(name);
       if (!currentConnection) {
         await this.initializeConnection(name, config);
@@ -1956,9 +2166,16 @@ class McpService extends import_core6.Service {
   async deleteConnection(name) {
     const connection = this.connections.get(name);
     if (connection) {
-      await connection.transport.close();
-      await connection.client.close();
+      const closeResults = await Promise.allSettled([
+        connection.transport.close(),
+        connection.client.close()
+      ]);
       this.connections.delete(name);
+      for (const result of closeResults) {
+        if (result.status === "rejected") {
+          import_core6.logger.warn({ error: result.reason, serverName: name }, `Failed to close MCP connection resource for "${name}"`);
+        }
+      }
     }
     const state = this.connectionStates.get(name);
     if (state) {
@@ -1976,6 +2193,17 @@ class McpService extends import_core6.Service {
     if (!config.command) {
       throw new Error(`Missing command for stdio MCP server ${name}`);
     }
+    const rejection = await import_mcp_server_config.validateMcpServerConfig({
+      type: "stdio",
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      cwd: config.cwd,
+      timeoutInMillis: config.timeoutInMillis
+    });
+    if (rejection) {
+      throw new Error(`MCP stdio server "${name}" rejected at spawn: ${rejection}`);
+    }
     return new import_stdio.StdioClientTransport({
       command: config.command,
       args: config.args ? [...config.args] : undefined,
@@ -1991,6 +2219,13 @@ class McpService extends import_core6.Service {
     if (!config.url) {
       throw new Error(`Missing URL for HTTP MCP server ${name}`);
     }
+    const rejection = await import_mcp_server_config.validateMcpServerConfig({
+      type: config.type,
+      url: config.url
+    });
+    if (rejection) {
+      throw new Error(`MCP remote server "${name}" rejected at connect: ${rejection}`);
+    }
     return new import_sse.SSEClientTransport(new URL(config.url));
   }
   appendErrorMessage(connection, error) {
@@ -2097,17 +2332,324 @@ ${error}` : error;
   }
 }
 
+// src/routes-mcp.ts
+var import_core7 = require("@elizaos/core");
+
+// src/mcp-marketplace.ts
+var MCP_REGISTRY_BASE_URL = "https://registry.modelcontextprotocol.io";
+async function searchMcpMarketplace(query, limit = 30) {
+  const resp = await fetch(`${MCP_REGISTRY_BASE_URL}/v0/servers`, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!resp.ok) {
+    throw new Error(`Registry API error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = await resp.json();
+  const results = [];
+  const seenNames = new Set;
+  for (const entry of data.servers) {
+    const server = entry.server;
+    const meta = entry._meta?.["io.modelcontextprotocol.registry/official"];
+    if (!meta?.isLatest)
+      continue;
+    if (seenNames.has(server.name))
+      continue;
+    seenNames.add(server.name);
+    if (query) {
+      const q = query.toLowerCase();
+      const matchName = server.name.toLowerCase().includes(q);
+      const matchTitle = server.title?.toLowerCase().includes(q);
+      const matchDesc = server.description?.toLowerCase().includes(q);
+      if (!matchName && !matchTitle && !matchDesc)
+        continue;
+    }
+    let connectionType = "remote";
+    let connectionUrl;
+    let npmPackage;
+    let dockerImage;
+    if (server.remotes && server.remotes.length > 0) {
+      connectionType = "remote";
+      connectionUrl = server.remotes[0].url;
+    } else if (server.packages && server.packages.length > 0) {
+      const pkg = server.packages[0];
+      connectionType = "stdio";
+      if (pkg.registryType === "npm") {
+        npmPackage = pkg.identifier;
+      } else if (pkg.registryType === "oci") {
+        dockerImage = pkg.identifier;
+      }
+    }
+    results.push({
+      id: `${server.name}@${server.version}`,
+      name: server.name,
+      title: server.title || server.name.split("/").pop() || server.name,
+      description: server.description || "No description",
+      version: server.version,
+      connectionType,
+      connectionUrl,
+      npmPackage,
+      dockerImage,
+      repositoryUrl: server.repository?.url,
+      websiteUrl: server.websiteUrl,
+      iconUrl: server.icons?.[0]?.src,
+      publishedAt: meta?.publishedAt,
+      isLatest: true
+    });
+    if (results.length >= limit)
+      break;
+  }
+  return { results };
+}
+async function getMcpServerDetails(name) {
+  const resp = await fetch(`${MCP_REGISTRY_BASE_URL}/v0/servers/${encodeURIComponent(name)}`, {
+    headers: { Accept: "application/json" }
+  });
+  if (!resp.ok) {
+    if (resp.status === 404) {
+      return null;
+    }
+    throw new Error(`Registry API error: ${resp.status}`);
+  }
+  const data = await resp.json();
+  return data.server;
+}
+
+// src/routes-mcp.ts
+var MCP_MARKETPLACE_QUERY_MAX_LENGTH = 200;
+var MCP_MARKETPLACE_SERVER_NAME_MAX_LENGTH = 200;
+function parseClampedInteger(value, options = {}) {
+  const raw = value == null ? "" : value.trim();
+  if (!raw)
+    return Number.isFinite(options.fallback) ? options.fallback : undefined;
+  if (!/^[+-]?\d+$/.test(raw)) {
+    return Number.isFinite(options.fallback) ? options.fallback : undefined;
+  }
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed)) {
+    return Number.isFinite(options.fallback) ? options.fallback : undefined;
+  }
+  if (options.min !== undefined && parsed < options.min)
+    return options.min;
+  if (options.max !== undefined && parsed > options.max)
+    return options.max;
+  return parsed;
+}
+function normalizeBoundedString(value, maxLength, label) {
+  const normalized = value.trim();
+  if (normalized.length > maxLength) {
+    throw new RangeError(`${label} must be ${maxLength} characters or fewer`);
+  }
+  return normalized;
+}
+async function handleMcpRoutes(ctx) {
+  const { req, res, method, pathname, url, state, json, error, readJsonBody } = ctx;
+  if (method === "GET" && pathname === "/api/mcp/marketplace/search") {
+    let query;
+    try {
+      query = normalizeBoundedString(url.searchParams.get("q") ?? "", MCP_MARKETPLACE_QUERY_MAX_LENGTH, "Marketplace search query");
+    } catch (err) {
+      error(res, err instanceof Error ? err.message : String(err), 400);
+      return true;
+    }
+    const limitStr = url.searchParams.get("limit");
+    const limit = limitStr ? parseClampedInteger(limitStr, { min: 1, max: 50, fallback: 30 }) : 30;
+    try {
+      const result = await searchMcpMarketplace(query || undefined, limit);
+      json(res, { ok: true, results: result.results });
+    } catch (err) {
+      error(res, `MCP marketplace search failed: ${err instanceof Error ? err.message : err}`, 502);
+    }
+    return true;
+  }
+  if (method === "GET" && pathname.startsWith("/api/mcp/marketplace/details/")) {
+    const serverName = ctx.decodePathComponent(pathname.slice("/api/mcp/marketplace/details/".length), res, "server name");
+    if (serverName === null)
+      return true;
+    let normalizedServerName;
+    try {
+      normalizedServerName = normalizeBoundedString(serverName, MCP_MARKETPLACE_SERVER_NAME_MAX_LENGTH, "Server name");
+    } catch (err) {
+      error(res, err instanceof Error ? err.message : String(err), 400);
+      return true;
+    }
+    if (!normalizedServerName) {
+      error(res, "Server name is required", 400);
+      return true;
+    }
+    try {
+      const details = await getMcpServerDetails(normalizedServerName);
+      if (!details) {
+        error(res, `MCP server "${normalizedServerName}" not found`, 404);
+        return true;
+      }
+      json(res, { ok: true, server: details });
+    } catch (err) {
+      error(res, `Failed to fetch server details: ${err instanceof Error ? err.message : err}`, 502);
+    }
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/mcp/config") {
+    const servers = state.config.mcp?.servers ?? {};
+    json(res, { ok: true, servers: ctx.redactDeep(servers) });
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/mcp/config/server") {
+    const body = await readJsonBody(req, res);
+    if (!body)
+      return true;
+    const serverName = body.name?.trim();
+    if (!serverName) {
+      error(res, "Server name is required", 400);
+      return true;
+    }
+    if (ctx.isBlockedObjectKey(serverName)) {
+      error(res, 'Invalid server name: "__proto__", "constructor", and "prototype" are reserved', 400);
+      return true;
+    }
+    const config = body.config;
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+      error(res, "Server config object is required", 400);
+      return true;
+    }
+    const mcpRejection = await ctx.resolveMcpServersRejection({
+      [serverName]: config
+    });
+    if (mcpRejection) {
+      error(res, mcpRejection, 400);
+      return true;
+    }
+    const mcpTerminalRejection = ctx.resolveMcpTerminalAuthorizationRejection(req, { [serverName]: config }, body);
+    if (mcpTerminalRejection) {
+      error(res, `Configuring stdio MCP servers requires terminal authorization. ${mcpTerminalRejection.reason}`, mcpTerminalRejection.status);
+      return true;
+    }
+    if (!state.config.mcp)
+      state.config.mcp = {};
+    if (!state.config.mcp.servers)
+      state.config.mcp.servers = {};
+    const sanitized = ctx.cloneWithoutBlockedObjectKeys(config);
+    state.config.mcp.servers[serverName] = sanitized;
+    try {
+      ctx.saveElizaConfig(state.config);
+    } catch (err) {
+      import_core7.logger.warn(`[api] Config save failed: ${err instanceof Error ? err.message : err}`);
+    }
+    json(res, { ok: true, name: serverName, requiresRestart: true });
+    return true;
+  }
+  if (method === "DELETE" && pathname.startsWith("/api/mcp/config/server/")) {
+    const serverName = ctx.decodePathComponent(pathname.slice("/api/mcp/config/server/".length), res, "server name");
+    if (serverName === null)
+      return true;
+    if (ctx.isBlockedObjectKey(serverName)) {
+      error(res, 'Invalid server name: "__proto__", "constructor", and "prototype" are reserved', 400);
+      return true;
+    }
+    if (state.config.mcp?.servers?.[serverName]) {
+      delete state.config.mcp.servers[serverName];
+      try {
+        ctx.saveElizaConfig(state.config);
+      } catch (err) {
+        import_core7.logger.warn(`[api] Config save failed: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    json(res, { ok: true, requiresRestart: true });
+    return true;
+  }
+  if (method === "PUT" && pathname === "/api/mcp/config") {
+    const body = await readJsonBody(req, res);
+    if (!body)
+      return true;
+    if (!state.config.mcp)
+      state.config.mcp = {};
+    if (body.servers !== undefined) {
+      if (!body.servers || typeof body.servers !== "object" || Array.isArray(body.servers)) {
+        error(res, "servers must be a JSON object", 400);
+        return true;
+      }
+      for (const serverName of Object.keys(body.servers)) {
+        if (ctx.isBlockedObjectKey(serverName)) {
+          error(res, 'Invalid server name: "__proto__", "constructor", and "prototype" are reserved', 400);
+          return true;
+        }
+      }
+      const mcpRejection = await ctx.resolveMcpServersRejection(body.servers);
+      if (mcpRejection) {
+        error(res, mcpRejection, 400);
+        return true;
+      }
+      const mcpTerminalRejection = ctx.resolveMcpTerminalAuthorizationRejection(req, body.servers, body);
+      if (mcpTerminalRejection) {
+        error(res, `Configuring stdio MCP servers requires terminal authorization. ${mcpTerminalRejection.reason}`, mcpTerminalRejection.status);
+        return true;
+      }
+      const sanitized = ctx.cloneWithoutBlockedObjectKeys(body.servers);
+      state.config.mcp.servers = sanitized;
+    }
+    try {
+      ctx.saveElizaConfig(state.config);
+    } catch (err) {
+      import_core7.logger.warn(`[api] Config save failed: ${err instanceof Error ? err.message : err}`);
+    }
+    json(res, { ok: true });
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/mcp/status") {
+    const servers = [];
+    if (state.runtime) {
+      try {
+        const mcpService = state.runtime.getService("MCP");
+        if (mcpService && typeof mcpService.getServers === "function") {
+          for (const s of mcpService.getServers()) {
+            servers.push({
+              name: s.name,
+              status: s.status,
+              toolCount: Array.isArray(s.tools) ? s.tools.length : 0,
+              resourceCount: Array.isArray(s.resources) ? s.resources.length : 0
+            });
+          }
+        }
+      } catch (err) {
+        import_core7.logger.debug(`[api] Service not available: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    json(res, { ok: true, servers });
+    return true;
+  }
+  return false;
+}
+
 // src/index.ts
+function withMcpContext(action) {
+  return {
+    ...action,
+    contexts: [
+      ...new Set([
+        ...action.contexts ?? [],
+        "general",
+        "automation",
+        "knowledge",
+        MCP_ACTION_CONTEXT
+      ])
+    ]
+  };
+}
 var mcpPlugin = {
   name: "mcp",
   description: "Plugin for connecting to MCP (Model Context Protocol) servers",
   init: async (_config, _runtime) => {
-    import_core7.logger.info("Initializing MCP plugin...");
+    import_core8.logger.info("Initializing MCP plugin...");
+  },
+  async dispose(runtime) {
+    const svc = runtime.getService(McpService.serviceType);
+    await svc?.stop();
   },
   services: [McpService],
-  actions: [callToolAction, readResourceAction],
+  actions: [...import_core8.promoteSubactionsToActions(withMcpContext(mcpAction))],
   providers: [provider]
 };
 var src_default = mcpPlugin;
 
-//# debugId=1F147A30DFB3603364756E2164756E21
+//# debugId=E8D9359237465E8664756E2164756E21