@elizaos/plugin-mcp 1.7.0 → 2.0.0-alpha.2

package/dist/cjs/index.cjs

@@ -40,18 +40,226 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// src/tool-compatibility/base.ts
+class McpToolCompatibility {
+  modelInfo;
+  constructor(modelInfo) {
+    this.modelInfo = modelInfo;
+  }
+  transformToolSchema(toolSchema) {
+    if (!this.shouldApply()) {
+      return toolSchema;
+    }
+    return this.processSchema(toolSchema);
+  }
+  processSchema(schema) {
+    const processed = { ...schema };
+    switch (processed.type) {
+      case "string":
+        return this.processStringSchema(processed);
+      case "number":
+      case "integer":
+        return this.processNumberSchema(processed);
+      case "array":
+        return this.processArraySchema(processed);
+      case "object":
+        return this.processObjectSchema(processed);
+      default:
+        return this.processGenericSchema(processed);
+    }
+  }
+  processStringSchema(schema) {
+    const constraints = {};
+    const processed = { ...schema };
+    if (typeof schema.minLength === "number") {
+      constraints.minLength = schema.minLength;
+    }
+    if (typeof schema.maxLength === "number") {
+      constraints.maxLength = schema.maxLength;
+    }
+    if (typeof schema.pattern === "string") {
+      constraints.pattern = schema.pattern;
+    }
+    if (typeof schema.format === "string") {
+      constraints.format = schema.format;
+    }
+    if (Array.isArray(schema.enum)) {
+      constraints.enum = schema.enum;
+    }
+    const unsupportedProps = this.getUnsupportedStringProperties();
+    for (const prop of unsupportedProps) {
+      if (prop in processed) {
+        delete processed[prop];
+      }
+    }
+    if (Object.keys(constraints).length > 0) {
+      processed.description = this.mergeDescription(schema.description, constraints);
+    }
+    return processed;
+  }
+  processNumberSchema(schema) {
+    const constraints = {};
+    const processed = { ...schema };
+    if (typeof schema.minimum === "number") {
+      constraints.minimum = schema.minimum;
+    }
+    if (typeof schema.maximum === "number") {
+      constraints.maximum = schema.maximum;
+    }
+    if (typeof schema.exclusiveMinimum === "number") {
+      constraints.exclusiveMinimum = schema.exclusiveMinimum;
+    }
+    if (typeof schema.exclusiveMaximum === "number") {
+      constraints.exclusiveMaximum = schema.exclusiveMaximum;
+    }
+    if (typeof schema.multipleOf === "number") {
+      constraints.multipleOf = schema.multipleOf;
+    }
+    const unsupportedProps = this.getUnsupportedNumberProperties();
+    for (const prop of unsupportedProps) {
+      if (prop in processed) {
+        delete processed[prop];
+      }
+    }
+    if (Object.keys(constraints).length > 0) {
+      processed.description = this.mergeDescription(schema.description, constraints);
+    }
+    return processed;
+  }
+  processArraySchema(schema) {
+    const constraints = {};
+    const processed = { ...schema };
+    if (typeof schema.minItems === "number") {
+      constraints.minItems = schema.minItems;
+    }
+    if (typeof schema.maxItems === "number") {
+      constraints.maxItems = schema.maxItems;
+    }
+    if (typeof schema.uniqueItems === "boolean") {
+      constraints.uniqueItems = schema.uniqueItems;
+    }
+    if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+      processed.items = this.processSchema(schema.items);
+    }
+    const unsupportedProps = this.getUnsupportedArrayProperties();
+    for (const prop of unsupportedProps) {
+      if (prop in processed) {
+        delete processed[prop];
+      }
+    }
+    if (Object.keys(constraints).length > 0) {
+      processed.description = this.mergeDescription(schema.description, constraints);
+    }
+    return processed;
+  }
+  processObjectSchema(schema) {
+    const constraints = {};
+    const processed = { ...schema };
+    if (typeof schema.minProperties === "number") {
+      constraints.minProperties = schema.minProperties;
+    }
+    if (typeof schema.maxProperties === "number") {
+      constraints.maxProperties = schema.maxProperties;
+    }
+    if (typeof schema.additionalProperties === "boolean") {
+      constraints.additionalProperties = schema.additionalProperties;
+    }
+    if (schema.properties && typeof schema.properties === "object") {
+      const newProperties = {};
+      for (const [key, prop] of Object.entries(schema.properties)) {
+        if (typeof prop === "object" && !Array.isArray(prop)) {
+          newProperties[key] = this.processSchema(prop);
+        } else {
+          newProperties[key] = prop;
+        }
+      }
+      processed.properties = newProperties;
+    }
+    const unsupportedProps = this.getUnsupportedObjectProperties();
+    for (const prop of unsupportedProps) {
+      if (prop in processed) {
+        delete processed[prop];
+      }
+    }
+    if (Object.keys(constraints).length > 0) {
+      processed.description = this.mergeDescription(schema.description, constraints);
+    }
+    return processed;
+  }
+  processGenericSchema(schema) {
+    const processed = { ...schema };
+    if (Array.isArray(schema.oneOf)) {
+      processed.oneOf = schema.oneOf.map((s) => typeof s === "object" ? this.processSchema(s) : s);
+    }
+    if (Array.isArray(schema.anyOf)) {
+      processed.anyOf = schema.anyOf.map((s) => typeof s === "object" ? this.processSchema(s) : s);
+    }
+    if (Array.isArray(schema.allOf)) {
+      processed.allOf = schema.allOf.map((s) => typeof s === "object" ? this.processSchema(s) : s);
+    }
+    return processed;
+  }
+  mergeDescription(originalDescription, constraints) {
+    const constraintJson = JSON.stringify(constraints);
+    if (originalDescription) {
+      return `${originalDescription}
+${constraintJson}`;
+    }
+    return constraintJson;
+  }
+}
+function hasModelInfo(runtime) {
+  return typeof runtime === "object" && runtime !== null && (("modelProvider" in runtime) || ("model" in runtime));
+}
+function getModelString(runtime) {
+  if (hasModelInfo(runtime)) {
+    return runtime.modelProvider ?? runtime.model ?? "";
+  }
+  if (runtime.character && typeof runtime.character === "object" && "settings" in runtime.character && runtime.character.settings && typeof runtime.character.settings === "object") {
+    const settings = runtime.character.settings;
+    const modelProvider = settings.MODEL_PROVIDER ?? settings.modelProvider;
+    const model = settings.MODEL ?? settings.model;
+    return String(modelProvider ?? model ?? "");
+  }
+  return "";
+}
+function detectModelProvider(runtime) {
+  const modelString = getModelString(runtime);
+  const modelId = String(modelString).toLowerCase();
+  let provider2 = "openrouter";
+  let supportsStructuredOutputs = false;
+  let isReasoningModel = false;
+  if (modelId.includes("openai") || modelId.includes("gpt-") || modelId.includes("o1-") || modelId.includes("o3-")) {
+    provider2 = "openai";
+    supportsStructuredOutputs = modelId.includes("gpt-4") || modelId.includes("o1") || modelId.includes("o3");
+    isReasoningModel = modelId.includes("o1") || modelId.includes("o3");
+  } else if (modelId.includes("anthropic") || modelId.includes("claude")) {
+    provider2 = "anthropic";
+    supportsStructuredOutputs = true;
+  } else if (modelId.includes("google") || modelId.includes("gemini")) {
+    provider2 = "google";
+    supportsStructuredOutputs = true;
+  } else if (modelId.includes("openrouter")) {
+    provider2 = "openrouter";
+    supportsStructuredOutputs = false;
+  }
+  return {
+    provider: provider2,
+    modelId,
+    supportsStructuredOutputs,
+    isReasoningModel
+  };
+}
+
 // src/tool-compatibility/providers/openai.ts
 var exports_openai = {};
 __export(exports_openai, {
   OpenAIReasoningMcpCompatibility: () => OpenAIReasoningMcpCompatibility,
-  OpenAIMcpCompatibility: () => OpenAIMcpCompatibility2
+  OpenAIMcpCompatibility: () => OpenAIMcpCompatibility
 });
-var OpenAIMcpCompatibility2, OpenAIReasoningMcpCompatibility;
+var OpenAIMcpCompatibility, OpenAIReasoningMcpCompatibility;
 var init_openai = __esm(() => {
-  OpenAIMcpCompatibility2 = class OpenAIMcpCompatibility2 extends McpToolCompatibility {
-    constructor(modelInfo2) {
-      super(modelInfo2);
-    }
+  OpenAIMcpCompatibility = class OpenAIMcpCompatibility extends McpToolCompatibility {
     shouldApply() {
       return this.modelInfo.provider === "openai" && (!this.modelInfo.supportsStructuredOutputs || this.modelInfo.isReasoningModel === true);
     }
@@ -82,9 +290,6 @@ var init_openai = __esm(() => {
     }
   };
   OpenAIReasoningMcpCompatibility = class OpenAIReasoningMcpCompatibility extends McpToolCompatibility {
-    constructor(modelInfo2) {
-      super(modelInfo2);
-    }
     shouldApply() {
       return this.modelInfo.provider === "openai" && this.modelInfo.isReasoningModel === true;
     }
@@ -152,14 +357,11 @@ IMPORTANT: ${constraintText}`;
 // src/tool-compatibility/providers/anthropic.ts
 var exports_anthropic = {};
 __export(exports_anthropic, {
-  AnthropicMcpCompatibility: () => AnthropicMcpCompatibility2
+  AnthropicMcpCompatibility: () => AnthropicMcpCompatibility
 });
-var AnthropicMcpCompatibility2;
+var AnthropicMcpCompatibility;
 var init_anthropic = __esm(() => {
-  AnthropicMcpCompatibility2 = class AnthropicMcpCompatibility2 extends McpToolCompatibility {
-    constructor(modelInfo2) {
-      super(modelInfo2);
-    }
+  AnthropicMcpCompatibility = class AnthropicMcpCompatibility extends McpToolCompatibility {
     shouldApply() {
       return this.modelInfo.provider === "anthropic";
     }
@@ -182,7 +384,7 @@ var init_anthropic = __esm(() => {
       } else if (constraintHints) {
         return constraintHints;
       }
-      return originalDescription || "";
+      return originalDescription ?? "";
     }
     formatConstraintsForAnthropic(constraints) {
       const hints = [];
@@ -203,14 +405,11 @@ var init_anthropic = __esm(() => {
 // src/tool-compatibility/providers/google.ts
 var exports_google = {};
 __export(exports_google, {
-  GoogleMcpCompatibility: () => GoogleMcpCompatibility2
+  GoogleMcpCompatibility: () => GoogleMcpCompatibility
 });
-var GoogleMcpCompatibility2;
+var GoogleMcpCompatibility;
 var init_google = __esm(() => {
-  GoogleMcpCompatibility2 = class GoogleMcpCompatibility2 extends McpToolCompatibility {
-    constructor(modelInfo2) {
-      super(modelInfo2);
-    }
+  GoogleMcpCompatibility = class GoogleMcpCompatibility extends McpToolCompatibility {
     shouldApply() {
       return this.modelInfo.provider === "google";
     }
@@ -235,7 +434,7 @@ Constraints: ${constraintText}`;
       } else if (constraintText) {
         return `Constraints: ${constraintText}`;
       }
-      return originalDescription || "";
+      return originalDescription ?? "";
     }
     formatConstraintsForGoogle(constraints) {
       const rules = [];
@@ -301,321 +500,37 @@ Constraints: ${constraintText}`;
   };
 });
 
-// src/tool-compatibility/index.ts
-class McpToolCompatibility {
-  modelInfo;
-  constructor(modelInfo2) {
-    this.modelInfo = modelInfo2;
-  }
-  transformToolSchema(toolSchema) {
-    if (!this.shouldApply()) {
-      return toolSchema;
-    }
-    return this.processSchema(toolSchema);
-  }
-  processSchema(schema) {
-    const processed = { ...schema };
-    switch (processed.type) {
-      case "string":
-        return this.processStringSchema(processed);
-      case "number":
-      case "integer":
-        return this.processNumberSchema(processed);
-      case "array":
-        return this.processArraySchema(processed);
-      case "object":
-        return this.processObjectSchema(processed);
-      default:
-        return this.processGenericSchema(processed);
-    }
-  }
-  processStringSchema(schema) {
-    const constraints = {};
-    const processed = { ...schema };
-    if (typeof schema.minLength === "number") {
-      constraints.minLength = schema.minLength;
-    }
-    if (typeof schema.maxLength === "number") {
-      constraints.maxLength = schema.maxLength;
-    }
-    if (typeof schema.pattern === "string") {
-      constraints.pattern = schema.pattern;
-    }
-    if (typeof schema.format === "string") {
-      constraints.format = schema.format;
-    }
-    if (Array.isArray(schema.enum)) {
-      constraints.enum = schema.enum;
-    }
-    const unsupportedProps = this.getUnsupportedStringProperties();
-    for (const prop of unsupportedProps) {
-      if (prop in processed) {
-        delete processed[prop];
-      }
-    }
-    if (Object.keys(constraints).length > 0) {
-      processed.description = this.mergeDescription(schema.description, constraints);
-    }
-    return processed;
-  }
-  processNumberSchema(schema) {
-    const constraints = {};
-    const processed = { ...schema };
-    if (typeof schema.minimum === "number") {
-      constraints.minimum = schema.minimum;
-    }
-    if (typeof schema.maximum === "number") {
-      constraints.maximum = schema.maximum;
-    }
-    if (typeof schema.exclusiveMinimum === "number") {
-      constraints.exclusiveMinimum = schema.exclusiveMinimum;
-    }
-    if (typeof schema.exclusiveMaximum === "number") {
-      constraints.exclusiveMaximum = schema.exclusiveMaximum;
-    }
-    if (typeof schema.multipleOf === "number") {
-      constraints.multipleOf = schema.multipleOf;
-    }
-    const unsupportedProps = this.getUnsupportedNumberProperties();
-    for (const prop of unsupportedProps) {
-      if (prop in processed) {
-        delete processed[prop];
-      }
-    }
-    if (Object.keys(constraints).length > 0) {
-      processed.description = this.mergeDescription(schema.description, constraints);
-    }
-    return processed;
-  }
-  processArraySchema(schema) {
-    const constraints = {};
-    const processed = { ...schema };
-    if (typeof schema.minItems === "number") {
-      constraints.minItems = schema.minItems;
-    }
-    if (typeof schema.maxItems === "number") {
-      constraints.maxItems = schema.maxItems;
-    }
-    if (typeof schema.uniqueItems === "boolean") {
-      constraints.uniqueItems = schema.uniqueItems;
-    }
-    if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
-      processed.items = this.processSchema(schema.items);
-    }
-    const unsupportedProps = this.getUnsupportedArrayProperties();
-    for (const prop of unsupportedProps) {
-      if (prop in processed) {
-        delete processed[prop];
-      }
-    }
-    if (Object.keys(constraints).length > 0) {
-      processed.description = this.mergeDescription(schema.description, constraints);
-    }
-    return processed;
-  }
-  processObjectSchema(schema) {
-    const constraints = {};
-    const processed = { ...schema };
-    if (typeof schema.minProperties === "number") {
-      constraints.minProperties = schema.minProperties;
-    }
-    if (typeof schema.maxProperties === "number") {
-      constraints.maxProperties = schema.maxProperties;
-    }
-    if (typeof schema.additionalProperties === "boolean") {
-      constraints.additionalProperties = schema.additionalProperties;
-    }
-    if (schema.properties && typeof schema.properties === "object") {
-      processed.properties = {};
-      for (const [key, prop] of Object.entries(schema.properties)) {
-        if (typeof prop === "object" && !Array.isArray(prop)) {
-          processed.properties[key] = this.processSchema(prop);
-        } else {
-          processed.properties[key] = prop;
-        }
-      }
-    }
-    const unsupportedProps = this.getUnsupportedObjectProperties();
-    for (const prop of unsupportedProps) {
-      if (prop in processed) {
-        delete processed[prop];
-      }
-    }
-    if (Object.keys(constraints).length > 0) {
-      processed.description = this.mergeDescription(schema.description, constraints);
-    }
-    return processed;
-  }
-  processGenericSchema(schema) {
-    const processed = { ...schema };
-    if (Array.isArray(schema.oneOf)) {
-      processed.oneOf = schema.oneOf.map((s) => typeof s === "object" ? this.processSchema(s) : s);
-    }
-    if (Array.isArray(schema.anyOf)) {
-      processed.anyOf = schema.anyOf.map((s) => typeof s === "object" ? this.processSchema(s) : s);
-    }
-    if (Array.isArray(schema.allOf)) {
-      processed.allOf = schema.allOf.map((s) => typeof s === "object" ? this.processSchema(s) : s);
-    }
-    return processed;
-  }
-  mergeDescription(originalDescription, constraints) {
-    const constraintJson = JSON.stringify(constraints);
-    if (originalDescription) {
-      return `${originalDescription}
-${constraintJson}`;
-    }
-    return constraintJson;
-  }
-}
-function detectModelProvider(runtime2) {
-  const modelString = runtime2?.modelProvider || runtime2?.model || "";
-  const modelId = String(modelString).toLowerCase();
-  let provider2 = "unknown";
-  let supportsStructuredOutputs = false;
-  let isReasoningModel = false;
-  if (modelId.includes("openai") || modelId.includes("gpt-") || modelId.includes("o1-") || modelId.includes("o3-")) {
-    provider2 = "openai";
-    supportsStructuredOutputs = modelId.includes("gpt-4") || modelId.includes("o1") || modelId.includes("o3");
-    isReasoningModel = modelId.includes("o1") || modelId.includes("o3");
-  } else if (modelId.includes("anthropic") || modelId.includes("claude")) {
-    provider2 = "anthropic";
-    supportsStructuredOutputs = true;
-  } else if (modelId.includes("google") || modelId.includes("gemini")) {
-    provider2 = "google";
-    supportsStructuredOutputs = true;
-  } else if (modelId.includes("openrouter")) {
-    provider2 = "openrouter";
-    supportsStructuredOutputs = false;
-  }
-  return {
-    provider: provider2,
-    modelId,
-    supportsStructuredOutputs,
-    isReasoningModel
-  };
-}
-async function createMcpToolCompatibility(runtime2) {
-  const modelInfo2 = detectModelProvider(runtime2);
-  try {
-    switch (modelInfo2.provider) {
-      case "openai":
-        const { OpenAIMcpCompatibility: OpenAIMcpCompatibility3 } = await Promise.resolve().then(() => (init_openai(), exports_openai));
-        return new OpenAIMcpCompatibility3(modelInfo2);
-      case "anthropic":
-        const { AnthropicMcpCompatibility: AnthropicMcpCompatibility3 } = await Promise.resolve().then(() => (init_anthropic(), exports_anthropic));
-        return new AnthropicMcpCompatibility3(modelInfo2);
-      case "google":
-        const { GoogleMcpCompatibility: GoogleMcpCompatibility3 } = await Promise.resolve().then(() => (init_google(), exports_google));
-        return new GoogleMcpCompatibility3(modelInfo2);
-      default:
-        return null;
-    }
-  } catch (error) {
-    console.warn("Failed to load compatibility provider:", error);
-    return null;
-  }
-}
-function createMcpToolCompatibilitySync(runtime) {
-  const modelInfo = detectModelProvider(runtime);
-  try {
-    switch (modelInfo.provider) {
-      case "openai":
-        const OpenAIModule = eval("require")("./providers/openai");
-        const { OpenAIMcpCompatibility } = OpenAIModule;
-        return new OpenAIMcpCompatibility(modelInfo);
-      case "anthropic":
-        const AnthropicModule = eval("require")("./providers/anthropic");
-        const { AnthropicMcpCompatibility } = AnthropicModule;
-        return new AnthropicMcpCompatibility(modelInfo);
-      case "google":
-        const GoogleModule = eval("require")("./providers/google");
-        const { GoogleMcpCompatibility } = GoogleModule;
-        return new GoogleMcpCompatibility(modelInfo);
-      default:
-        return null;
-    }
-  } catch (error) {
-    console.warn("Failed to load compatibility provider:", error);
-    return null;
-  }
-}
-
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  detectModelProvider: () => detectModelProvider,
-  default: () => src_default,
-  createMcpToolCompatibilitySync: () => createMcpToolCompatibilitySync,
-  createMcpToolCompatibility: () => createMcpToolCompatibility,
-  ToolSelectionSchema: () => ToolSelectionSchema,
-  ResourceSelectionSchema: () => ResourceSelectionSchema,
-  McpToolCompatibility: () => McpToolCompatibility,
-  McpService: () => McpService,
-  MIN_MCP_TIMEOUT_SECONDS: () => MIN_MCP_TIMEOUT_SECONDS,
-  MCP_SERVICE_NAME: () => MCP_SERVICE_NAME,
-  MAX_RECONNECT_ATTEMPTS: () => MAX_RECONNECT_ATTEMPTS,
-  INITIAL_RETRY_DELAY: () => INITIAL_RETRY_DELAY,
-  DEFAULT_PING_CONFIG: () => DEFAULT_PING_CONFIG,
-  DEFAULT_MCP_TIMEOUT_SECONDS: () => DEFAULT_MCP_TIMEOUT_SECONDS,
-  DEFAULT_MAX_RETRIES: () => DEFAULT_MAX_RETRIES,
-  BACKOFF_MULTIPLIER: () => BACKOFF_MULTIPLIER
-});
-module.exports = __toCommonJS(exports_src);
-var import_core9 = require("@elizaos/core");
-
-// src/actions/callToolAction.ts
-var import_core6 = require("@elizaos/core");
-
-// src/types.ts
-var MCP_SERVICE_NAME = "mcp";
-var DEFAULT_MCP_TIMEOUT_SECONDS = 60000;
-var MIN_MCP_TIMEOUT_SECONDS = 1;
-var DEFAULT_MAX_RETRIES = 2;
-var ToolSelectionSchema = {
-  type: "object",
-  required: ["serverName", "toolName", "arguments"],
-  properties: {
-    serverName: {
-      type: "string",
-      minLength: 1,
-      errorMessage: "serverName must not be empty"
-    },
-    toolName: {
-      type: "string",
-      minLength: 1,
-      errorMessage: "toolName must not be empty"
-    },
-    arguments: {
-      type: "object"
-    },
-    reasoning: {
-      type: "string"
-    },
-    noToolAvailable: {
-      type: "boolean"
-    }
-  }
-};
-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"
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(exports_src);
+var import_core7 = 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"
     }
   }
 };
@@ -629,44 +544,234 @@ 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/utils/error.ts
+var import_core = require("@elizaos/core");
+
+// src/generated/prompts/typescript/prompts.ts
+var errorAnalysisTemplate = `{{{mcpProvider.text}}}
+
+{{{recentMessages}}}
+
+# Prompt
+
+You're an assistant helping a user, but there was an error accessing the resource you tried to use.
+
+User request: "{{{userMessage}}}"
+Error message: {{{error}}}
+
+Create a helpful response that:
+1. Acknowledges the issue in user-friendly terms
+2. Offers alternative approaches to help if possible
+3. Doesn't expose technical error details unless they're truly helpful
+4. Maintains a helpful, conversational tone
+
+Your response:`;
+var resourceAnalysisTemplate = `{{{mcpProvider.text}}}
+
+{{{recentMessages}}}
+
+# Prompt
+
+You are a helpful assistant responding to a user's request. You've just accessed the resource "{{{uri}}}" to help answer this request.
+
+Original user request: "{{{userMessage}}}"
+
+Resource metadata: 
+{{{resourceMeta}}
+
+Resource content: 
+{{{resourceContent}}
+
+Instructions:
+1. Analyze how well the resource's content addresses the user's specific question or need
+2. Identify the most relevant information from the resource
+3. Create a natural, conversational response that incorporates this information
+4. If the resource content is insufficient, acknowledge its limitations and explain what you can determine
+5. Do not start with phrases like "According to the resource" or "Here's what I found" - instead, integrate the information naturally
+6. Maintain your helpful, intelligent assistant personality while presenting the information
+
+Your response (written as if directly to the user):`;
+var resourceSelectionTemplate = `{{{mcpProvider.text}}}
+
+{{{recentMessages}}}
+
+# Prompt
+
+You are an intelligent assistant helping select the right resource to address a 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
+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
+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}
+
+!!! YOUR RESPONSE MUST BE A VALID JSON OBJECT ONLY !!! 
+
+STRICT FORMAT REQUIREMENTS:
+- NO code block formatting (NO backticks or \`\`\`)
+- NO comments (NO // or /* */)
+- 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."
+}
+
+REMEMBER: Your response will be parsed directly as JSON. If it fails to parse, the operation will fail completely!`;
+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.
+
+Original user request: "{{{userMessage}}}"
+
+Tool response:
+{{{toolOutput}}}
+
+{{#if hasAttachments}}
+The tool also returned images or other media that will be shared with the user.
+{{/if}}
+
+Instructions:
+1. Analyze how well the tool's response addresses the user's specific question or need
+2. Identify the most relevant information from the tool's output
+3. Create a natural, conversational response that incorporates this information
+4. If the tool's response is insufficient, acknowledge its limitations and explain what you can determine
+5. Do not start with phrases like "I used the X tool" or "Here's what I found" - instead, integrate the information naturally
+6. Maintain your helpful, intelligent assistant personality while presenting the information
+
+Your response (written as if directly to the user):`;
+var toolSelectionArgumentTemplate = `{{recentMessages}}
+
+# TASK: Generate a Strictly Valid JSON Object 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.
+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 !!! 
+
+## 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.
+- 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
+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.
+
+## EXAMPLE RESPONSE
+{
+  "toolArguments": {
+    "owner": "facebook",
+    "repo": "react",
+    "path": "README.md",
+    "branch": "main"
+  },
+  "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.`;
+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.
+
+## CRITICAL INSTRUCTIONS
+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
+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
+   }
 
-// src/templates/errorAnalysisPrompt.ts
-var errorAnalysisPrompt = `
-{{{mcpProvider.text}}}
+!!! YOUR RESPONSE MUST BE A VALID JSON OBJECT ONLY !!! 
 
-{{{recentMessages}}}
+CRITICAL: Your response must START with { and END with }. DO NOT include ANY text before or after the JSON.
 
-# Prompt
+## 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.
+- DO NOT use placeholders (e.g., "replace with...", "example", "your...", etc.)
+- ALL strings must use double quotes.
 
-You're an assistant helping a user, but there was an error accessing the resource you tried to use.
+## 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).
 
-User request: "{{{userMessage}}}"
-Error message: {{{error}}}
+## JSON OBJECT 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)
 
-Create a helpful response that:
-1. Acknowledges the issue in user-friendly terms
-2. Offers alternative approaches to help if possible
-3. Doesn't expose technical error details unless they're truly helpful
-4. Maintains a helpful, conversational tone
+## EXAMPLE RESPONSE
+{
+  "serverName": "github",
+  "toolName": "get_file_contents",
+  "reasoning": "The user wants to retrieve the README from the facebook/react repository.",
+  "noToolAvailable": false
+}
 
-Your response:
-`;
+## 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.
+
+REMEMBER: This output will be parsed directly as JSON. If the format is incorrect, the operation will fail.`;
+
+// src/templates/errorAnalysisPrompt.ts
+var errorAnalysisPrompt = errorAnalysisTemplate;
 
 // src/utils/error.ts
-async function handleMcpError(state, mcpProvider, error, runtime2, message, type, callback) {
+async function handleMcpError(state, mcpProvider, error, runtime, message, type, callback) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   import_core.logger.error({ error, mcpType: type }, `Error executing MCP ${type}: ${errorMessage}`);
   let responseText = `I'm sorry, I wasn't able to get the information you requested. There seems to be an issue with the ${type} right now. Is there something else I can help you with?`;
-  let thoughtText = `Error calling MCP ${type} and failed to generate a custom response. Providing a generic fallback response.`;
   if (callback) {
     const enhancedState = {
       ...state,
       values: {
         ...state.values,
         mcpProvider,
-        userMessage: message.content.text || "",
+        userMessage: message.content.text ?? "",
         error: errorMessage
       }
     };
@@ -674,25 +779,14 @@ async function handleMcpError(state, mcpProvider, error, runtime2, message, type
       state: enhancedState,
       template: errorAnalysisPrompt
     });
-    try {
-      const errorResponse = await runtime2.useModel(import_core.ModelType.TEXT_SMALL, {
-        prompt
-      });
-      responseText = errorResponse;
-      thoughtText = `Error calling MCP ${type}: ${errorMessage}. Providing a helpful response to the user.`;
-      await callback({
-        thought: thoughtText,
-        text: responseText,
-        actions: ["REPLY"]
-      });
-    } catch (modelError) {
-      import_core.logger.error({ error: modelError instanceof Error ? modelError.message : String(modelError) }, "Failed to generate error response");
-      await callback({
-        thought: thoughtText,
-        text: responseText,
-        actions: ["REPLY"]
-      });
-    }
+    const errorResponse = await runtime.useModel(import_core.ModelType.TEXT_SMALL, {
+      prompt
+    });
+    responseText = errorResponse;
+    await callback({
+      text: responseText,
+      actions: ["REPLY"]
+    });
   }
   return {
     text: `Failed to execute MCP ${type}`,
@@ -711,74 +805,39 @@ async function handleMcpError(state, mcpProvider, error, runtime2, message, type
   };
 }
 
+// src/utils/handler.ts
+async function handleNoToolAvailable(callback, toolSelection) {
+  const responseText = "I don't have a specific tool that can help with that request. Let me try to assist you directly instead.";
+  if (callback && toolSelection?.noToolAvailable) {
+    await callback({
+      text: responseText,
+      actions: ["REPLY"]
+    });
+  }
+  return {
+    text: responseText,
+    values: {
+      success: true,
+      noToolAvailable: true,
+      fallbackToDirectAssistance: true
+    },
+    data: {
+      actionName: "CALL_MCP_TOOL",
+      noToolAvailable: true,
+      reason: toolSelection?.reasoning ?? "No appropriate tool available"
+    },
+    success: true
+  };
+}
+
 // src/utils/processing.ts
 var import_core2 = require("@elizaos/core");
-var import_core3 = require("@elizaos/core");
-
-// src/templates/resourceAnalysisTemplate.ts
-var resourceAnalysisTemplate = `
-{{{mcpProvider.text}}}
-
-{{{recentMessages}}}
-
-# Prompt
-
-You are a helpful assistant responding to a user's request. You've just accessed the resource "{{{uri}}}" to help answer this request.
-
-Original user request: "{{{userMessage}}}"
-
-Resource metadata: 
-{{{resourceMeta}}
-
-Resource content: 
-{{{resourceContent}}
-
-Instructions:
-1. Analyze how well the resource's content addresses the user's specific question or need
-2. Identify the most relevant information from the resource
-3. Create a natural, conversational response that incorporates this information
-4. If the resource content is insufficient, acknowledge its limitations and explain what you can determine
-5. Do not start with phrases like "According to the resource" or "Here's what I found" - instead, integrate the information naturally
-6. Maintain your helpful, intelligent assistant personality while presenting the information
-
-Your response (written as if directly to the user):
-`;
-
-// src/templates/toolReasoningTemplate.ts
-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.
-
-Original user request: "{{{userMessage}}}"
-
-Tool response:
-{{{toolOutput}}}
-
-{{#if hasAttachments}}
-The tool also returned images or other media that will be shared with the user.
-{{/if}}
-
-Instructions:
-1. Analyze how well the tool's response addresses the user's specific question or need
-2. Identify the most relevant information from the tool's output
-3. Create a natural, conversational response that incorporates this information
-4. If the tool's response is insufficient, acknowledge its limitations and explain what you can determine
-5. Do not start with phrases like "I used the X tool" or "Here's what I found" - instead, integrate the information naturally
-6. Maintain your helpful, intelligent assistant personality while presenting the information
-
-Your response (written as if directly to the user):
-`;
 
 // src/utils/mcp.ts
-async function createMcpMemory(runtime2, message, type, serverName, content, metadata) {
-  const memory = await runtime2.addEmbeddingToMemory({
+async function createMcpMemory(runtime, message, type, serverName, content, metadata) {
+  const memory = await runtime.addEmbeddingToMemory({
     entityId: message.entityId,
-    agentId: runtime2.agentId,
+    agentId: runtime.agentId,
     roomId: message.roomId,
     content: {
       text: `Used the "${type}" from "${serverName}" server. 
@@ -789,7 +848,7 @@ async function createMcpMemory(runtime2, message, type, serverName, content, met
       }
     }
   });
-  await runtime2.createMemory(memory, type === "resource" ? "resources" : "tools", true);
+  await runtime.createMemory(memory, type === "resource" ? "resources" : "tools", true);
 }
 function buildMcpProviderData(servers) {
   const mcpData = {};
@@ -802,10 +861,12 @@ function buildMcpProviderData(servers) {
     };
   }
   for (const server of servers) {
+    const tools = {};
+    const resources = {};
     mcpData[server.name] = {
       status: server.status,
-      tools: {},
-      resources: {}
+      tools,
+      resources
     };
     textContent += `## Server: ${server.name} (${server.status})
 
@@ -815,11 +876,11 @@ function buildMcpProviderData(servers) {
 
 `;
       for (const tool of server.tools) {
-        mcpData[server.name].tools[tool.name] = {
-          description: tool.description || "No description available",
-          inputSchema: tool.inputSchema || {}
+        tools[tool.name] = {
+          description: tool.description ?? "No description available",
+          inputSchema: tool.inputSchema
         };
-        textContent += `- **${tool.name}**: ${tool.description || "No description available"}
+        textContent += `- **${tool.name}**: ${tool.description ?? "No description available"}
 `;
       }
       textContent += `
@@ -830,12 +891,12 @@ function buildMcpProviderData(servers) {
 
 `;
       for (const resource of server.resources) {
-        mcpData[server.name].resources[resource.uri] = {
+        resources[resource.uri] = {
           name: resource.name,
-          description: resource.description || "No description available",
+          description: resource.description ?? "No description available",
           mimeType: resource.mimeType
         };
-        textContent += `- **${resource.name}** (${resource.uri}): ${resource.description || "No description available"}
+        textContent += `- **${resource.name}** (${resource.uri}): ${resource.description ?? "No description available"}
 `;
       }
       textContent += `
@@ -874,9 +935,9 @@ function processResourceResult(result, uri) {
     if (content.text) {
       resourceContent += content.text;
     } else if (content.blob) {
-      resourceContent += `[Binary data - ${content.mimeType || "unknown type"}]`;
+      resourceContent += `[Binary data${content.mimeType ? ` - ${content.mimeType}` : ""}]`;
     }
-    resourceMeta += `Resource: ${content.uri || uri}
+    resourceMeta += `Resource: ${content.uri ?? uri}
 `;
     if (content.mimeType) {
       resourceMeta += `Type: ${content.mimeType}
@@ -885,32 +946,32 @@ function processResourceResult(result, uri) {
   }
   return { resourceContent, resourceMeta };
 }
-function processToolResult(result, serverName, toolName, runtime2, messageEntityId) {
+function processToolResult(result, serverName, toolName, runtime, messageEntityId) {
   let toolOutput = "";
   let hasAttachments = false;
   const attachments = [];
   for (const content of result.content) {
-    if (content.type === "text") {
+    if (content.type === "text" && content.text) {
       toolOutput += content.text;
-    } else if (content.type === "image") {
+    } else if (content.type === "image" && content.data && content.mimeType) {
       hasAttachments = true;
       attachments.push({
         contentType: getMimeTypeToContentType(content.mimeType),
         url: `data:${content.mimeType};base64,${content.data}`,
-        id: import_core2.createUniqueUuid(runtime2, messageEntityId),
+        id: import_core2.createUniqueUuid(runtime, messageEntityId),
         title: "Generated image",
         source: `${serverName}/${toolName}`,
         description: "Tool-generated image",
         text: "Generated image"
       });
-    } else if (content.type === "resource") {
+    } else if (content.type === "resource" && content.resource) {
       const resource = content.resource;
-      if (resource && "text" in resource) {
+      if ("text" in resource && resource.text) {
         toolOutput += `
 
 Resource (${resource.uri}):
 ${resource.text}`;
-      } else if (resource && "blob" in resource) {
+      } else if ("blob" in resource) {
         toolOutput += `
 
 Resource (${resource.uri}): [Binary data]`;
@@ -919,53 +980,49 @@ Resource (${resource.uri}): [Binary data]`;
   }
   return { toolOutput, hasAttachments, attachments };
 }
-async function handleResourceAnalysis(runtime2, message, uri, serverName, resourceContent, resourceMeta, callback) {
-  await createMcpMemory(runtime2, message, "resource", serverName, resourceContent, {
+async function handleResourceAnalysis(runtime, message, uri, serverName, resourceContent, resourceMeta, callback) {
+  await createMcpMemory(runtime, message, "resource", serverName, resourceContent, {
     uri,
     isResourceAccess: true
   });
-  const analysisPrompt = createAnalysisPrompt(uri, message.content.text || "", resourceContent, resourceMeta);
-  const analyzedResponse = await runtime2.useModel(import_core2.ModelType.TEXT_SMALL, {
+  const analysisPrompt = createAnalysisPrompt(uri, message.content.text ?? "", resourceContent, resourceMeta);
+  const analyzedResponse = await runtime.useModel(import_core2.ModelType.TEXT_SMALL, {
     prompt: analysisPrompt
   });
   if (callback) {
     await callback({
       text: analyzedResponse,
-      thought: `I analyzed the content from the ${uri} resource on ${serverName} and crafted a thoughtful response that addresses the user's request while maintaining my conversational style.`,
       actions: ["READ_MCP_RESOURCE"]
     });
   }
 }
-async function handleToolResponse(runtime2, message, serverName, toolName, toolArgs, toolOutput, hasAttachments, attachments, state, mcpProvider, callback) {
-  await createMcpMemory(runtime2, message, "tool", serverName, toolOutput, {
+async function handleToolResponse(runtime, message, serverName, toolName, toolArgs, toolOutput, hasAttachments, attachments, state, mcpProvider, callback) {
+  await createMcpMemory(runtime, message, "tool", serverName, toolOutput, {
     toolName,
     arguments: toolArgs,
     isToolCall: true
   });
-  const reasoningPrompt = createReasoningPrompt(state, mcpProvider, toolName, serverName, message.content.text || "", toolOutput, hasAttachments);
-  import_core2.logger.info({ reasoningPrompt }, "reasoning prompt");
-  const reasonedResponse = await runtime2.useModel(import_core2.ModelType.TEXT_SMALL, {
+  const reasoningPrompt = createReasoningPrompt(state, mcpProvider, toolName, serverName, message.content.text ?? "", toolOutput, hasAttachments);
+  const reasonedResponse = await runtime.useModel(import_core2.ModelType.TEXT_SMALL, {
     prompt: reasoningPrompt
   });
-  const agentId = message.agentId || runtime2.agentId;
+  const agentId = message.agentId ?? runtime.agentId;
   const replyMemory = {
     entityId: agentId,
     roomId: message.roomId,
     worldId: message.worldId,
     content: {
       text: reasonedResponse,
-      thought: `I analyzed the output from the ${toolName} tool on ${serverName} and crafted a thoughtful response that addresses the user's request while maintaining my conversational style.`,
       actions: ["CALL_MCP_TOOL"],
-      attachments: hasAttachments && attachments.length > 0 ? attachments : undefined
+      attachments: hasAttachments && attachments.length > 0 ? [...attachments] : undefined
     }
   };
-  await runtime2.createMemory(replyMemory, "messages");
+  await runtime.createMemory(replyMemory, "messages");
   if (callback) {
     await callback({
       text: reasonedResponse,
-      thought: `I analyzed the output from the ${toolName} tool on ${serverName} and crafted a thoughtful response that addresses the user's request while maintaining my conversational style.`,
       actions: ["CALL_MCP_TOOL"],
-      attachments: hasAttachments && attachments.length > 0 ? attachments : undefined
+      attachments: hasAttachments && attachments.length > 0 ? [...attachments] : undefined
     });
   }
   return replyMemory;
@@ -973,7 +1030,6 @@ async function handleToolResponse(runtime2, message, serverName, toolName, toolA
 async function sendInitialResponse(callback) {
   if (callback) {
     const responseContent = {
-      thought: "The user is asking for information that can be found in an MCP resource. I will retrieve and analyze the appropriate resource.",
       text: "I'll retrieve that information for you. Let me access the resource...",
       actions: ["READ_MCP_RESOURCE"]
     };
@@ -991,7 +1047,7 @@ function createAnalysisPrompt(uri, userMessage, resourceContent, resourceMeta) {
       resourceMeta
     }
   };
-  return import_core3.composePromptFromState({
+  return import_core2.composePromptFromState({
     state: enhancedState,
     template: resourceAnalysisTemplate
   });
@@ -1007,232 +1063,50 @@ function createReasoningPrompt(state, mcpProvider, toolName, serverName, userMes
       userMessage,
       toolOutput,
       hasAttachments
-    }
-  };
-  return import_core3.composePromptFromState({
-    state: enhancedState,
-    template: toolReasoningTemplate
-  });
-}
-
-// src/utils/selection.ts
-var import_core5 = require("@elizaos/core");
-
-// src/utils/json.ts
-var import_ajv = __toESM(require("ajv"));
-var import_json5 = __toESM(require("json5"));
-function parseJSON(input) {
-  let cleanedInput = input.replace(/^```(?:json)?\s*|\s*```$/g, "").trim();
-  const firstBrace = cleanedInput.indexOf("{");
-  const lastBrace = cleanedInput.lastIndexOf("}");
-  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
-    cleanedInput = cleanedInput.substring(firstBrace, lastBrace + 1);
-  }
-  return import_json5.default.parse(cleanedInput);
-}
-var ajv = new import_ajv.default({
-  allErrors: true,
-  strict: false
-});
-function validateJsonSchema(data, schema) {
-  try {
-    const validate = ajv.compile(schema);
-    const valid = validate(data);
-    if (!valid) {
-      const errors = (validate.errors || []).map((err) => {
-        const path = err.instancePath ? `${err.instancePath.replace(/^\//, "")}` : "value";
-        return `${path}: ${err.message}`;
-      });
-      return { success: false, error: errors.join(", ") };
-    }
-    return { success: true, data };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Schema validation error: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-
-// src/utils/wrapper.ts
-var import_core4 = require("@elizaos/core");
-async function withModelRetry({
-  runtime: runtime2,
-  message,
-  state,
-  callback,
-  input,
-  validationFn,
-  createFeedbackPromptFn,
-  failureMsg,
-  retryCount = 0
-}) {
-  const maxRetries = getMaxRetries(runtime2);
-  try {
-    import_core4.logger.info(`[WITH-MODEL-RETRY] Raw selection input:
-${input}`);
-    const parsedJson = typeof input === "string" ? parseJSON(input) : input;
-    import_core4.logger.debug(`[WITH-MODEL-RETRY] Parsed selection input:
-${JSON.stringify(parsedJson, null, 2)}`);
-    const validationResult = validationFn(parsedJson);
-    if (validationResult.success === false) {
-      throw new Error(validationResult.error);
-    }
-    return validationResult.data;
-  } catch (parseError) {
-    const errorMessage = parseError instanceof Error ? parseError.message : "Unknown parsing error";
-    import_core4.logger.error({ errorMessage }, `[WITH-MODEL-RETRY] Failed to parse response: ${errorMessage}`);
-    if (retryCount < maxRetries) {
-      import_core4.logger.debug(`[WITH-MODEL-RETRY] Retrying (attempt ${retryCount + 1}/${maxRetries})`);
-      const feedbackPrompt = createFeedbackPromptFn(input, errorMessage, state, message.content.text || "");
-      const retrySelection = await runtime2.useModel(import_core4.ModelType.OBJECT_LARGE, {
-        prompt: feedbackPrompt
-      });
-      return withModelRetry({
-        runtime: runtime2,
-        input: retrySelection,
-        validationFn,
-        message,
-        state,
-        createFeedbackPromptFn,
-        callback,
-        failureMsg,
-        retryCount: retryCount + 1
-      });
-    }
-    if (callback && failureMsg) {
-      await callback({
-        text: failureMsg,
-        thought: "Failed to parse response after multiple retries. Requesting clarification from user.",
-        actions: ["REPLY"]
-      });
-    }
-    return null;
-  }
-}
-function getMaxRetries(runtime2) {
-  try {
-    const rawSettings = runtime2.getSetting("mcp");
-    const settings = rawSettings;
-    if (settings && typeof settings.maxRetries === "number") {
-      const configValue = settings.maxRetries;
-      if (!Number.isNaN(configValue) && configValue >= 0) {
-        import_core4.logger.debug(`[WITH-MODEL-RETRY] Using configured selection retries: ${configValue}`);
-        return configValue;
-      }
-    }
-  } catch (error) {
-    import_core4.logger.debug({ error: error instanceof Error ? error.message : String(error) }, "[WITH-MODEL-RETRY] Error reading selection retries config");
-  }
-  return DEFAULT_MAX_RETRIES;
-}
-
-// src/templates/toolSelectionTemplate.ts
-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.
-
-## CRITICAL INSTRUCTIONS
-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
-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.
-
-## 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.
-- 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
-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)
-
-## EXAMPLE RESPONSE
-{
-  "serverName": "github",
-  "toolName": "get_file_contents",
-  "reasoning": "The user wants to retrieve the README from the facebook/react repository.",
-  "noToolAvailable": false
+    }
+  };
+  return import_core2.composePromptFromState({
+    state: enhancedState,
+    template: toolReasoningTemplate
+  });
 }
 
-## 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.
-
-REMEMBER: This output will be parsed directly as JSON. If the format is incorrect, the operation will fail.
-`;
-var toolSelectionArgumentTemplate = `
-{{recentMessages}}
-
-# TASK: Generate a Strictly Valid JSON Object 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.
-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 !!! 
-
-## 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.
-- 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
-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.
+// src/utils/selection.ts
+var import_core4 = require("@elizaos/core");
 
-## EXAMPLE RESPONSE
-{
-  "toolArguments": {
-    "owner": "facebook",
-    "repo": "react",
-    "path": "README.md",
-    "branch": "main"
-  },
-  "reasoning": "The user wants to see the README from the facebook/react repository based on our conversation."
+// src/utils/json.ts
+var import_ajv = __toESM(require("ajv"));
+var import_json5 = __toESM(require("json5"));
+function parseJSON(input) {
+  let cleanedInput = input.replace(/^```(?:json)?\s*|\s*```$/g, "").trim();
+  const firstBrace = cleanedInput.indexOf("{");
+  const lastBrace = cleanedInput.lastIndexOf("}");
+  if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) {
+    throw new Error("No valid JSON object found in input");
+  }
+  cleanedInput = cleanedInput.substring(firstBrace, lastBrace + 1);
+  return import_json5.default.parse(cleanedInput);
+}
+var ajv = new import_ajv.default({
+  allErrors: true,
+  strict: false
+});
+function formatAjvErrors(errors) {
+  return errors.map((err) => {
+    const path = err.instancePath ? `${err.instancePath.replace(/^\//, "")}` : "value";
+    return `${path}: ${err.message ?? "validation failed"}`;
+  }).join(", ");
+}
+function validateJsonSchema(data, schema) {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (!valid) {
+    const errors = validate.errors ?? [];
+    const errorMessage = formatAjvErrors(errors);
+    return { success: false, error: errorMessage };
+  }
+  return { success: true, data };
 }
-
-REMEMBER: Your response will be parsed directly as JSON. If it fails to parse, the operation will fail completely.
-`;
 
 // src/utils/schemas.ts
 var toolSelectionNameSchema = {
@@ -1274,7 +1148,7 @@ function validateToolSelectionName(parsed, state) {
     return { success: false, error: basicResult.error };
   }
   const data = basicResult.data;
-  const mcpData = state.values.mcp || {};
+  const mcpData = state.values.mcp ?? {};
   const server = mcpData[data.serverName];
   if (!server || server.status !== "connected") {
     return {
@@ -1309,19 +1183,46 @@ function validateToolSelectionArgument(parsed, toolInputSchema) {
 function validateResourceSelection(selection) {
   return validateJsonSchema(selection, ResourceSelectionSchema);
 }
+function createToolSelectionFeedbackPrompt(originalResponse, errorMessage, composedState, userMessage) {
+  let toolsDescription = "";
+  const mcpData = composedState.values.mcp;
+  if (mcpData) {
+    for (const [serverName, server] of Object.entries(mcpData)) {
+      if (server.status !== "connected")
+        continue;
+      const tools = server.tools;
+      if (tools) {
+        for (const [toolName, tool] of Object.entries(tools)) {
+          toolsDescription += `Tool: ${toolName} (Server: ${serverName})
+`;
+          toolsDescription += `Description: ${tool.description ?? "No description available"}
+
+`;
+        }
+      }
+    }
+  }
+  return createFeedbackPrompt(originalResponse, errorMessage, "tool", toolsDescription, userMessage);
+}
 function createResourceSelectionFeedbackPrompt(originalResponse, errorMessage, composedState, userMessage) {
   let resourcesDescription = "";
-  for (const [serverName, server] of Object.entries(composedState.values.mcp || {})) {
-    if (server.status !== "connected")
-      continue;
-    for (const [uri, resource] of Object.entries(server.resources || {})) {
-      resourcesDescription += `Resource: ${uri} (Server: ${serverName})
+  const mcpData = composedState.values.mcp;
+  if (mcpData) {
+    for (const [serverName, server] of Object.entries(mcpData)) {
+      if (server.status !== "connected")
+        continue;
+      const resources = server.resources;
+      if (resources) {
+        for (const [uri, resource] of Object.entries(resources)) {
+          resourcesDescription += `Resource: ${uri} (Server: ${serverName})
 `;
-      resourcesDescription += `Name: ${resource.name || "No name available"}
+          resourcesDescription += `Name: ${resource.name ?? "No name available"}
 `;
-      resourcesDescription += `Description: ${resource.description || "No description available"}
+          resourcesDescription += `Description: ${resource.description ?? "No description available"}
 
 `;
+        }
+      }
     }
   }
   return createFeedbackPrompt(originalResponse, errorMessage, "resource", resourcesDescription, userMessage);
@@ -1339,38 +1240,90 @@ ${itemsDescription}
 User request: ${userMessage}`;
 }
 
+// src/utils/wrapper.ts
+var import_core3 = require("@elizaos/core");
+async function withModelRetry({
+  runtime,
+  message,
+  state,
+  callback,
+  input,
+  validationFn,
+  createFeedbackPromptFn,
+  failureMsg,
+  retryCount = 0
+}) {
+  const maxRetries = getMaxRetries(runtime);
+  const parsedJson = typeof input === "string" ? parseJSON(input) : input;
+  const validationResult = validationFn(parsedJson);
+  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, {
+      prompt: feedbackPrompt
+    });
+    return withModelRetry({
+      runtime,
+      input: retrySelection,
+      validationFn,
+      message,
+      state,
+      createFeedbackPromptFn,
+      callback,
+      failureMsg,
+      retryCount: retryCount + 1
+    });
+  }
+  if (callback && failureMsg) {
+    await callback({
+      text: failureMsg,
+      actions: ["REPLY"]
+    });
+  }
+  return null;
+}
+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;
+    }
+  }
+  return DEFAULT_MAX_RETRIES;
+}
+
 // src/utils/selection.ts
 async function createToolSelectionName({
-  runtime: runtime2,
+  runtime,
   state,
   message,
   callback,
   mcpProvider
 }) {
-  const toolSelectionPrompt = import_core5.composePromptFromState({
+  const toolSelectionPrompt = import_core4.composePromptFromState({
     state: { ...state, values: { ...state.values, mcpProvider } },
     template: toolSelectionNameTemplate
   });
-  import_core5.logger.debug(`[SELECTION] Tool Selection Name Prompt:
-${toolSelectionPrompt}`);
-  const toolSelectionName = await runtime2.useModel(import_core5.ModelType.TEXT_LARGE, {
+  const toolSelectionName = await runtime.useModel(import_core4.ModelType.TEXT_LARGE, {
     prompt: toolSelectionPrompt
   });
-  import_core5.logger.debug(`[SELECTION] Tool Selection Name Response:
-${toolSelectionName}`);
   return await withModelRetry({
-    runtime: runtime2,
+    runtime,
     message,
     state,
     callback,
     input: toolSelectionName,
     validationFn: (parsed) => validateToolSelectionName(parsed, state),
-    createFeedbackPromptFn: (originalResponse, errorMessage, state2, userMessage) => createToolSelectionFeedbackPrompt(originalResponse, errorMessage, state2, userMessage),
+    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."
   });
 }
 async function createToolSelectionArgument({
-  runtime: runtime2,
+  runtime,
   state,
   message,
   callback,
@@ -1378,14 +1331,19 @@ async function createToolSelectionArgument({
   toolSelectionName
 }) {
   if (!toolSelectionName) {
-    import_core5.logger.warn("[SELECTION] Tool selection name is not provided. Cannot create tool selection argument.");
-    return null;
+    throw new Error("Tool selection name is required to create tool selection argument");
   }
   const { serverName, toolName } = toolSelectionName;
-  const toolInputSchema = mcpProvider.data.mcp[serverName].tools[toolName].inputSchema;
-  import_core5.logger.trace(`[SELECTION] Tool Input Schema:
-${JSON.stringify({ toolInputSchema }, null, 2)}`);
-  const toolSelectionArgumentPrompt = import_core5.composePromptFromState({
+  const serverData = mcpProvider.data.mcp[serverName];
+  if (!serverData) {
+    throw new Error(`Server "${serverName}" not found in MCP provider data`);
+  }
+  const toolData = serverData.tools[toolName];
+  if (!toolData) {
+    throw new Error(`Tool "${toolName}" not found on server "${serverName}"`);
+  }
+  const toolInputSchema = toolData.inputSchema ?? {};
+  const toolSelectionArgumentPrompt = import_core4.composePromptFromState({
     state: {
       ...state,
       values: {
@@ -1396,81 +1354,20 @@ ${JSON.stringify({ toolInputSchema }, null, 2)}`);
     },
     template: toolSelectionArgumentTemplate
   });
-  import_core5.logger.debug(`[SELECTION] Tool Selection Prompt:
-${toolSelectionArgumentPrompt}`);
-  const toolSelectionArgument = await runtime2.useModel(import_core5.ModelType.TEXT_LARGE, {
+  const toolSelectionArgument = await runtime.useModel(import_core4.ModelType.TEXT_LARGE, {
     prompt: toolSelectionArgumentPrompt
   });
-  import_core5.logger.debug(`[SELECTION] Tool Selection Argument Response:
-${toolSelectionArgument}`);
   return await withModelRetry({
-    runtime: runtime2,
+    runtime,
     message,
     state,
     callback,
     input: toolSelectionArgument,
-    validationFn: (parsed) => validateToolSelectionArgument(parsed, state),
-    createFeedbackPromptFn: (originalResponse, errorMessage, state2, userMessage) => createToolSelectionFeedbackPrompt(originalResponse, errorMessage, state2, userMessage),
+    validationFn: (parsed) => validateToolSelectionArgument(parsed, toolInputSchema),
+    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."
   });
 }
-function createToolSelectionFeedbackPrompt(originalResponse, errorMessage, state, userMessage) {
-  let toolsDescription = "";
-  for (const [serverName, server] of Object.entries(state.values.mcp || {})) {
-    if (server.status !== "connected")
-      continue;
-    for (const [toolName, tool] of Object.entries(server.tools || {})) {
-      toolsDescription += `Tool: ${toolName} (Server: ${serverName})
-`;
-      toolsDescription += `Description: ${tool.description || "No description available"}
-
-`;
-    }
-  }
-  const feedbackPrompt = createFeedbackPrompt2(originalResponse, errorMessage, "tool", toolsDescription, userMessage);
-  import_core5.logger.debug(`[SELECTION] Tool Selection Feedback Prompt:
-${feedbackPrompt}`);
-  return feedbackPrompt;
-}
-function createFeedbackPrompt2(originalResponse, errorMessage, itemType, itemsDescription, userMessage) {
-  return `Error parsing JSON: ${errorMessage}
-  
-  Your original response:
-  ${originalResponse}
-  
-  Please try again with valid JSON for ${itemType} selection.
-  Available ${itemType}s:
-  ${itemsDescription}
-  
-  User request: ${userMessage}`;
-}
-
-// src/utils/handler.ts
-async function handleNoToolAvailable(callback, toolSelection) {
-  const responseText = "I don't have a specific tool that can help with that request. Let me try to assist you directly instead.";
-  const thoughtText = "No appropriate MCP tool available for this request. Falling back to direct assistance.";
-  if (callback && toolSelection?.noToolAvailable) {
-    await callback({
-      text: responseText,
-      thought: thoughtText,
-      actions: ["REPLY"]
-    });
-  }
-  return {
-    text: responseText,
-    values: {
-      success: true,
-      noToolAvailable: true,
-      fallbackToDirectAssistance: true
-    },
-    data: {
-      actionName: "CALL_MCP_TOOL",
-      noToolAvailable: true,
-      reason: toolSelection?.reasoning || "No appropriate tool available"
-    },
-    success: true
-  };
-}
 
 // src/actions/callToolAction.ts
 var callToolAction = {
@@ -1488,36 +1385,34 @@ var callToolAction = {
     "INVOKE_MCP_TOOL"
   ],
   description: "Calls a tool from an MCP server to perform a specific task",
-  validate: async (runtime2, _message, _state) => {
-    const mcpService = runtime2.getService(MCP_SERVICE_NAME);
+  validate: async (runtime, _message, _state) => {
+    const mcpService = runtime.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);
   },
-  handler: async (runtime2, message, _state, _options, callback) => {
-    const composedState = await runtime2.composeState(message, ["RECENT_MESSAGES", "MCP"]);
-    const mcpService = runtime2.getService(MCP_SERVICE_NAME);
+  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: runtime2,
+        runtime,
         state: composedState,
         message,
         callback,
         mcpProvider
       });
       if (!toolSelectionName || toolSelectionName.noToolAvailable) {
-        import_core6.logger.warn("[NO_TOOL_AVAILABLE] No appropriate tool available for the request");
         return await handleNoToolAvailable(callback, toolSelectionName);
       }
-      const { serverName, toolName, reasoning } = toolSelectionName;
-      import_core6.logger.info(`[CALLING] Calling tool "${serverName}/${toolName}" on server with reasoning: "${reasoning}"`);
+      const { serverName, toolName } = toolSelectionName;
       const toolSelectionArgument = await createToolSelectionArgument({
-        runtime: runtime2,
+        runtime,
         state: composedState,
         message,
         callback,
@@ -1525,14 +1420,11 @@ var callToolAction = {
         toolSelectionName
       });
       if (!toolSelectionArgument) {
-        import_core6.logger.warn("[NO_TOOL_SELECTION_ARGUMENT] No appropriate tool selection argument available");
         return await handleNoToolAvailable(callback, toolSelectionName);
       }
-      import_core6.logger.info(`[SELECTED] Tool Selection result:
-${JSON.stringify(toolSelectionArgument, null, 2)}`);
       const result = await mcpService.callTool(serverName, toolName, toolSelectionArgument.toolArguments);
-      const { toolOutput, hasAttachments, attachments } = processToolResult(result, serverName, toolName, runtime2, message.entityId);
-      const replyMemory = await handleToolResponse(runtime2, message, serverName, toolName, toolSelectionArgument.toolArguments, toolOutput, hasAttachments, attachments, composedState, mcpProvider, callback);
+      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: {
@@ -1547,15 +1439,15 @@ ${JSON.stringify(toolSelectionArgument, null, 2)}`);
           actionName: "CALL_MCP_TOOL",
           serverName,
           toolName,
-          toolArguments: toolSelectionArgument.toolArguments,
+          toolArgumentsJson: JSON.stringify(toolSelectionArgument.toolArguments),
           reasoning: toolSelectionName.reasoning,
           output: toolOutput,
-          attachments: attachments || []
+          attachmentCount: attachments?.length ?? 0
         },
         success: true
       };
     } catch (error) {
-      return await handleMcpError(composedState, mcpProvider, error, runtime2, message, "tool", callback);
+      return await handleMcpError(composedState, mcpProvider, error, runtime, message, "tool", callback);
     }
   },
   examples: [
@@ -1587,69 +1479,25 @@ Climate change refers to long-term shifts in temperatures and weather patterns.
 };
 
 // src/actions/readResourceAction.ts
-var import_core7 = require("@elizaos/core");
-
-// src/templates/resourceSelectionTemplate.ts
-var resourceSelectionTemplate = `
-{{{mcpProvider.text}}}
-
-{{{recentMessages}}}
-
-# Prompt
-
-You are an intelligent assistant helping select the right resource to address a 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
-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
-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}
-
-!!! YOUR RESPONSE MUST BE A VALID JSON OBJECT ONLY !!! 
-
-STRICT FORMAT REQUIREMENTS:
-- NO code block formatting (NO backticks or \`\`\`)
-- NO comments (NO // or /* */)
-- 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."
-}
-
-REMEMBER: Your response will be parsed directly as JSON. If it fails to parse, the operation will fail completely!
-`;
-
-// src/actions/readResourceAction.ts
+var import_core5 = require("@elizaos/core");
 function createResourceSelectionPrompt(composedState, userMessage) {
-  const mcpData = composedState.values.mcp || {};
+  const mcpData = composedState.values.mcp ?? {};
   const serverNames = Object.keys(mcpData);
   let resourcesDescription = "";
   for (const serverName of serverNames) {
     const server = mcpData[serverName];
     if (server.status !== "connected")
       continue;
-    const resourceUris = Object.keys(server.resources || {});
+    const resourceUris = Object.keys(server.resources ?? {});
     for (const uri of resourceUris) {
       const resource = server.resources[uri];
       resourcesDescription += `Resource: ${uri} (Server: ${serverName})
 `;
-      resourcesDescription += `Name: ${resource.name || "No name available"}
+      resourcesDescription += `Name: ${resource.name ?? "No name available"}
 `;
-      resourcesDescription += `Description: ${resource.description || "No description available"}
+      resourcesDescription += `Description: ${resource.description ?? "No description available"}
 `;
-      resourcesDescription += `MIME Type: ${resource.mimeType || "Not specified"}
+      resourcesDescription += `MIME Type: ${resource.mimeType ?? "Not specified"}
 
 `;
     }
@@ -1662,7 +1510,7 @@ function createResourceSelectionPrompt(composedState, userMessage) {
       userMessage
     }
   };
-  return import_core7.composePromptFromState({
+  return import_core5.composePromptFromState({
     state: enhancedState,
     template: resourceSelectionTemplate
   });
@@ -1680,44 +1528,42 @@ var readResourceAction = {
     "ACCESS_MCP_RESOURCE"
   ],
   description: "Reads a resource from an MCP server",
-  validate: async (runtime2, _message, _state) => {
-    const mcpService = runtime2.getService(MCP_SERVICE_NAME);
+  validate: async (runtime, _message, _state) => {
+    const mcpService = runtime.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);
   },
-  handler: async (runtime2, message, _state, _options, callback) => {
-    const composedState = await runtime2.composeState(message, ["RECENT_MESSAGES", "MCP"]);
-    const mcpService = runtime2.getService(MCP_SERVICE_NAME);
+  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 {
       await sendInitialResponse(callback);
-      const resourceSelectionPrompt = createResourceSelectionPrompt(composedState, message.content.text || "");
-      const resourceSelection = await runtime2.useModel(import_core7.ModelType.TEXT_SMALL, {
+      const resourceSelectionPrompt = createResourceSelectionPrompt(composedState, message.content.text ?? "");
+      const resourceSelection = await runtime.useModel(import_core5.ModelType.TEXT_SMALL, {
         prompt: resourceSelectionPrompt
       });
       const parsedSelection = await withModelRetry({
-        runtime: runtime2,
+        runtime,
         state: composedState,
         message,
         callback,
         input: resourceSelection,
         validationFn: (data) => validateResourceSelection(data),
-        createFeedbackPromptFn: (originalResponse, errorMessage, state, userMessage) => createResourceSelectionFeedbackPrompt(originalResponse, errorMessage, state, userMessage),
+        createFeedbackPromptFn: (originalResponse, errorMessage, state, userMessage) => createResourceSelectionFeedbackPrompt(typeof originalResponse === "string" ? originalResponse : JSON.stringify(originalResponse), errorMessage, state, userMessage),
         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.";
-        const thoughtText = "No appropriate MCP resource available for this request. Falling back to direct assistance.";
         if (callback && parsedSelection?.noResourceAvailable) {
           await callback({
             text: responseText,
-            thought: thoughtText,
             actions: ["REPLY"]
           });
         }
@@ -1731,17 +1577,15 @@ var readResourceAction = {
           data: {
             actionName: "READ_MCP_RESOURCE",
             noResourceAvailable: true,
-            reason: parsedSelection?.reasoning || "No appropriate resource available"
+            reason: parsedSelection?.reasoning ?? "No appropriate resource available"
           },
           success: true
         };
       }
-      const { serverName, uri, reasoning } = parsedSelection;
-      import_core7.logger.debug(`Selected resource "${uri}" on server "${serverName}" because: ${reasoning}`);
+      const { serverName, uri } = parsedSelection;
       const result = await mcpService.readResource(serverName, uri);
-      import_core7.logger.debug(`Read resource ${uri} from server ${serverName}`);
       const { resourceContent, resourceMeta } = processResourceResult(result, uri);
-      await handleResourceAnalysis(runtime2, message, uri, serverName, resourceContent, resourceMeta, callback);
+      await handleResourceAnalysis(runtime, message, uri, serverName, resourceContent, resourceMeta, callback);
       return {
         text: `Successfully read resource: ${uri}`,
         values: {
@@ -1754,14 +1598,14 @@ var readResourceAction = {
           actionName: "READ_MCP_RESOURCE",
           serverName,
           uri,
-          reasoning,
+          reasoning: parsedSelection?.reasoning,
           resourceMeta,
-          contentLength: resourceContent?.length || 0
+          contentLength: resourceContent?.length ?? 0
         },
         success: true
       };
     } catch (error) {
-      return await handleMcpError(composedState, mcpProvider, error, runtime2, message, "resource", callback);
+      return await handleMcpError(composedState, mcpProvider, error, runtime, message, "resource", callback);
     }
   },
   examples: [
@@ -1769,7 +1613,7 @@ var readResourceAction = {
       {
         name: "{{user}}",
         content: {
-          text: "Can you get the documentation about installing ElizaOS?"
+          text: "Can you get the documentation about installing elizaOS?"
         }
       },
       {
@@ -1782,7 +1626,7 @@ var readResourceAction = {
       {
         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.`,
+          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"]
         }
       }
@@ -1794,25 +1638,52 @@ var readResourceAction = {
 var provider = {
   name: "MCP",
   description: "Information about connected MCP servers, tools, and resources",
-  get: async (runtime2, _message, _state) => {
-    const mcpService = runtime2.getService(MCP_SERVICE_NAME);
+  get: async (runtime, _message, _state) => {
+    const mcpService = runtime.getService(MCP_SERVICE_NAME);
     if (!mcpService) {
       return {
-        values: { mcp: {} },
-        data: { mcp: {} },
+        values: {},
+        data: {},
         text: "No MCP servers are available."
       };
     }
-    return mcpService.getProviderData();
+    const providerData = mcpService.getProviderData();
+    return {
+      values: { mcpServers: JSON.stringify(providerData.values.mcp) },
+      data: { mcpServerCount: Object.keys(providerData.data.mcp).length },
+      text: providerData.text
+    };
   }
 };
 
 // src/service.ts
-var import_core8 = require("@elizaos/core");
+var import_core6 = require("@elizaos/core");
 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");
-class McpService extends import_core8.Service {
+// src/tool-compatibility/index.ts
+function createMcpToolCompatibilitySync(runtime) {
+  const modelInfo = detectModelProvider(runtime);
+  switch (modelInfo.provider) {
+    case "openai": {
+      const { OpenAIMcpCompatibility: OpenAIMcpCompatibility2 } = (init_openai(), __toCommonJS(exports_openai));
+      return new OpenAIMcpCompatibility2(modelInfo);
+    }
+    case "anthropic": {
+      const { AnthropicMcpCompatibility: AnthropicMcpCompatibility2 } = (init_anthropic(), __toCommonJS(exports_anthropic));
+      return new AnthropicMcpCompatibility2(modelInfo);
+    }
+    case "google": {
+      const { GoogleMcpCompatibility: GoogleMcpCompatibility2 } = (init_google(), __toCommonJS(exports_google));
+      return new GoogleMcpCompatibility2(modelInfo);
+    }
+    default:
+      return null;
+  }
+}
+
+// src/service.ts
+class McpService extends import_core6.Service {
   static serviceType = MCP_SERVICE_NAME;
   capabilityDescription = "Enables the agent to interact with MCP (Model Context Protocol) servers";
   connections = new Map;
@@ -1826,13 +1697,12 @@ class McpService extends import_core8.Service {
   toolCompatibility = null;
   compatibilityInitialized = false;
   initializationPromise = null;
-  constructor(runtime2) {
-    super(runtime2);
-    import_core8.logger.info("[McpService] Constructor called, starting initialization...");
+  constructor(runtime) {
+    super(runtime);
     this.initializationPromise = this.initializeMcpServers();
   }
-  static async start(runtime2) {
-    const service = new McpService(runtime2);
+  static async start(runtime) {
+    const service = new McpService(runtime);
     if (service.initializationPromise) {
       await service.initializationPromise;
     }
@@ -1857,71 +1727,36 @@ class McpService extends import_core8.Service {
     this.connectionStates.clear();
   }
   async initializeMcpServers() {
-    import_core8.logger.info("[McpService] Starting MCP server initialization...");
-    try {
-      const mcpSettings = this.getMcpSettings();
-      const serverCount = mcpSettings?.servers ? Object.keys(mcpSettings.servers).length : 0;
-      const serverNames = mcpSettings?.servers ? Object.keys(mcpSettings.servers) : [];
-      import_core8.logger.info(`[McpService] Getting MCP settings... hasSettings=${!!mcpSettings} hasServers=${!!mcpSettings?.servers} serverCount=${serverCount} servers=${JSON.stringify(serverNames)}`);
-      if (!mcpSettings || !mcpSettings.servers) {
-        import_core8.logger.info("[McpService] No MCP servers configured.");
-        this.mcpProvider = buildMcpProviderData([]);
-        return;
-      }
-      if (Object.keys(mcpSettings.servers).length === 0) {
-        import_core8.logger.info("[McpService] MCP settings exist but no servers configured.");
-        this.mcpProvider = buildMcpProviderData([]);
-        return;
-      }
-      import_core8.logger.info(`[McpService] Connecting to ${Object.keys(mcpSettings.servers).length} MCP servers: ${JSON.stringify(Object.keys(mcpSettings.servers))}`);
-      const connectionStartTime = Date.now();
-      await this.updateServerConnections(mcpSettings.servers);
-      const connectionDuration = Date.now() - connectionStartTime;
-      const servers = this.getServers();
-      const connectedServers = servers.filter((s) => s.status === "connected");
-      const failedServers = servers.filter((s) => s.status !== "connected");
-      if (connectedServers.length > 0) {
-        const toolCounts = connectedServers.map((s) => `${s.name}:${s.tools?.length || 0}tools`).join(", ");
-        import_core8.logger.info(`[McpService] ✓ Successfully connected ${connectedServers.length}/${servers.length} servers in ${connectionDuration}ms: ${toolCounts}`);
-      }
-      if (failedServers.length > 0) {
-        const failedDetails = failedServers.map((s) => `${s.name}(${s.error || "unknown error"})`).join(", ");
-        import_core8.logger.warn(`[McpService] ⚠️  Failed to connect to ${failedServers.length}/${servers.length} servers: ${failedDetails}`);
-      }
-      if (connectedServers.length === 0 && servers.length > 0) {
-        import_core8.logger.error(`[McpService] ❌ ALL MCP servers failed to connect! MCP tools will NOT be available.`);
-      }
-      this.mcpProvider = buildMcpProviderData(servers);
-      const mcpDataKeys = Object.keys(this.mcpProvider.data?.mcp || {});
-      import_core8.logger.info(`[McpService] MCP provider data built: ${mcpDataKeys.length} server(s) available`);
-    } catch (error) {
-      import_core8.logger.error({ error: error instanceof Error ? error.message : String(error) }, "❌ Failed to initialize MCP servers - MCP tools will NOT be available");
+    const mcpSettings = this.getMcpSettings();
+    if (!mcpSettings || !mcpSettings.servers || Object.keys(mcpSettings.servers).length === 0) {
       this.mcpProvider = buildMcpProviderData([]);
+      return;
     }
+    await this.updateServerConnections(mcpSettings.servers);
+    const servers = this.getServers();
+    this.mcpProvider = buildMcpProviderData(servers);
   }
   getMcpSettings() {
     const rawSettings = this.runtime.getSetting("mcp");
-    let settings = rawSettings;
-    import_core8.logger.info(`[McpService] getSetting("mcp") result: type=${typeof rawSettings} isNull=${rawSettings === null} hasServers=${!!settings?.servers}`);
-    if (!settings || !settings.servers) {
-      const characterSettings = this.runtime.character?.settings;
-      if (characterSettings?.mcp) {
-        import_core8.logger.info("[McpService] Found MCP settings in character.settings.mcp (fallback)");
-        settings = characterSettings.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 (!settings || !settings.servers) {
-      const runtimeSettings = this.runtime.settings;
-      if (runtimeSettings?.mcp) {
-        import_core8.logger.info("[McpService] Found MCP settings in runtime.settings.mcp (fallback)");
-        settings = runtimeSettings.mcp;
+      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) {
+          settings = characterMcpSettings;
+        }
       }
     }
     if (settings && typeof settings === "object" && settings.servers) {
-      import_core8.logger.info(`[McpService] MCP settings found with ${Object.keys(settings.servers).length} server(s)`);
       return settings;
     }
-    import_core8.logger.info("[McpService] No valid MCP settings found");
     return;
   }
   async updateServerConnections(serverConfigs) {
@@ -1930,30 +1765,18 @@ class McpService extends import_core8.Service {
     for (const name of currentNames) {
       if (!newNames.has(name)) {
         await this.deleteConnection(name);
-        import_core8.logger.info(`Deleted MCP server: ${name}`);
       }
     }
     const connectionPromises = Object.entries(serverConfigs).map(async ([name, config]) => {
       const currentConnection = this.connections.get(name);
       if (!currentConnection) {
-        try {
-          await this.initializeConnection(name, config);
-          import_core8.logger.info(`✓ Connected to MCP server: ${name}`);
-        } catch (error) {
-          import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `✗ Failed to connect to new MCP server ${name}`);
-        }
+        await this.initializeConnection(name, config);
       } else if (JSON.stringify(config) !== currentConnection.server.config) {
-        try {
-          await this.deleteConnection(name);
-          await this.initializeConnection(name, config);
-          import_core8.logger.info(`✓ Reconnected MCP server with updated config: ${name}`);
-        } catch (error) {
-          import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `✗ Failed to reconnect MCP server ${name}`);
-        }
+        await this.deleteConnection(name);
+        await this.initializeConnection(name, config);
       }
     });
     await Promise.allSettled(connectionPromises);
-    import_core8.logger.info(`[McpService] All server connection attempts completed`);
   }
   async initializeConnection(name, config) {
     await this.deleteConnection(name);
@@ -1963,58 +1786,47 @@ class McpService extends import_core8.Service {
       consecutivePingFailures: 0
     };
     this.connectionStates.set(name, state);
-    try {
-      const client = new import_client.Client({ name: "ElizaOS", version: "1.0.0" }, { capabilities: {} });
-      const transport = config.type === "stdio" ? await this.buildStdioClientTransport(name, config) : await this.buildHttpClientTransport(name, config);
-      const connection = {
-        server: {
-          name,
-          config: JSON.stringify(config),
-          status: "connecting"
-        },
-        client,
-        transport
-      };
-      this.connections.set(name, connection);
-      this.setupTransportHandlers(name, connection, state);
-      await client.connect(transport);
-      const capabilities = client.getServerCapabilities();
-      import_core8.logger.debug(`[${name}] Server capabilities:`, JSON.stringify(capabilities || {}));
-      const tools = await this.fetchToolsList(name);
-      const resources = capabilities?.resources ? await this.fetchResourcesList(name) : [];
-      const resourceTemplates = capabilities?.resources ? await this.fetchResourceTemplatesList(name) : [];
-      connection.server = {
-        status: "connected",
+    const client = new import_client.Client({ name: "elizaOS", version: "1.0.0" }, { capabilities: {} });
+    const transport = config.type === "stdio" ? await this.buildStdioClientTransport(name, config) : await this.buildHttpClientTransport(name, config);
+    const connection = {
+      server: {
         name,
         config: JSON.stringify(config),
-        error: "",
-        tools,
-        resources,
-        resourceTemplates
-      };
-      state.status = "connected";
-      state.lastConnected = new Date;
-      state.reconnectAttempts = 0;
-      state.consecutivePingFailures = 0;
-      this.startPingMonitoring(name);
-      import_core8.logger.info(`Successfully connected to MCP server: ${name}`);
-    } catch (error) {
-      state.status = "disconnected";
-      state.lastError = error instanceof Error ? error : new Error(String(error));
-      this.handleDisconnection(name, error);
-      throw error;
-    }
+        status: "connecting"
+      },
+      client,
+      transport
+    };
+    this.connections.set(name, connection);
+    this.setupTransportHandlers(name, connection, state);
+    await client.connect(transport);
+    const capabilities = client.getServerCapabilities();
+    const tools = await this.fetchToolsList(name);
+    const resources = capabilities?.resources ? await this.fetchResourcesList(name) : [];
+    const resourceTemplates = capabilities?.resources ? await this.fetchResourceTemplatesList(name) : [];
+    connection.server = {
+      status: "connected",
+      name,
+      config: JSON.stringify(config),
+      error: "",
+      tools,
+      resources,
+      resourceTemplates
+    };
+    state.status = "connected";
+    state.lastConnected = new Date;
+    state.reconnectAttempts = 0;
+    state.consecutivePingFailures = 0;
+    this.startPingMonitoring(name);
   }
-  setupTransportHandlers(name, connection, state) {
+  setupTransportHandlers(name, connection, _state) {
     const config = JSON.parse(connection.server.config);
     const isHttpTransport = config.type !== "stdio";
     connection.transport.onerror = async (error) => {
-      const errorMessage = error?.message || String(error);
+      const errorMessage = error?.message ?? String(error);
       const isExpectedTimeout = isHttpTransport && (errorMessage === "undefined" || errorMessage === "" || errorMessage.includes("SSE error") || errorMessage.includes("timeout"));
-      if (isExpectedTimeout) {
-        import_core8.logger.debug({ serverName: name }, `SSE connection timeout for "${name}" (expected, will reconnect)`);
-      } else {
-        import_core8.logger.error({ error, serverName: name }, `Transport error for "${name}"`);
+      if (!isExpectedTimeout) {
+        import_core6.logger.error({ error, serverName: name }, `Transport error for "${name}"`);
         connection.server.status = "disconnected";
         this.appendErrorMessage(connection, error.message);
       }
@@ -2023,10 +1835,7 @@ class McpService extends import_core8.Service {
       }
     };
     connection.transport.onclose = async () => {
-      if (isHttpTransport) {
-        import_core8.logger.debug({ serverName: name }, `SSE connection closed for "${name}" (stateless, will reconnect on demand)`);
-      } else {
-        import_core8.logger.warn({ serverName: name }, `Transport closed for "${name}"`);
+      if (!isHttpTransport) {
         connection.server.status = "disconnected";
         this.handleDisconnection(name, new Error("Transport closed"));
       }
@@ -2039,7 +1848,6 @@ class McpService extends import_core8.Service {
     const config = JSON.parse(connection.server.config);
     const isHttpTransport = config.type !== "stdio";
     if (isHttpTransport) {
-      import_core8.logger.debug(`[McpService] Skipping ping monitoring for HTTP server: ${name}`);
       return;
     }
     const state = this.connectionStates.get(name);
@@ -2049,7 +1857,7 @@ class McpService extends import_core8.Service {
       clearInterval(state.pingInterval);
     state.pingInterval = setInterval(() => {
       this.sendPing(name).catch((err) => {
-        import_core8.logger.warn({ error: err instanceof Error ? err.message : String(err), serverName: name }, `Ping failed for ${name}`);
+        import_core6.logger.warn({ error: err.message, serverName: name }, `Ping failed for ${name}`);
         this.handlePingFailure(name, err);
       });
     }, this.pingConfig.intervalMs);
@@ -2072,7 +1880,6 @@ class McpService extends import_core8.Service {
       return;
     state.consecutivePingFailures++;
     if (state.consecutivePingFailures >= this.pingConfig.failuresBeforeDisconnect) {
-      import_core8.logger.warn(`Ping failures exceeded for ${name}, disconnecting and attempting reconnect.`);
       this.handleDisconnection(name, error);
     }
   }
@@ -2087,19 +1894,17 @@ class McpService extends import_core8.Service {
     if (state.reconnectTimeout)
       clearTimeout(state.reconnectTimeout);
     if (state.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-      import_core8.logger.error(`Max reconnect attempts reached for ${name}. Giving up.`);
       return;
     }
-    const delay = INITIAL_RETRY_DELAY * Math.pow(BACKOFF_MULTIPLIER, state.reconnectAttempts);
+    const delay = INITIAL_RETRY_DELAY * BACKOFF_MULTIPLIER ** state.reconnectAttempts;
     state.reconnectTimeout = setTimeout(async () => {
       state.reconnectAttempts++;
-      import_core8.logger.info(`Attempting to reconnect to ${name} (attempt ${state.reconnectAttempts})...`);
-      const config = this.connections.get(name)?.server.config;
+      const connection = this.connections.get(name);
+      const config = connection?.server?.config;
       if (config) {
         try {
           await this.initializeConnection(name, JSON.parse(config));
         } catch (err) {
-          import_core8.logger.error({ error: err instanceof Error ? err.message : String(err), serverName: name }, `Reconnect attempt failed for ${name}`);
           this.handleDisconnection(name, err);
         }
       }
@@ -2108,12 +1913,8 @@ class McpService extends import_core8.Service {
   async deleteConnection(name) {
     const connection = this.connections.get(name);
     if (connection) {
-      try {
-        await connection.transport.close();
-        await connection.client.close();
-      } catch (error) {
-        import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `Failed to close transport for ${name}`);
-      }
+      await connection.transport.close();
+      await connection.client.close();
       this.connections.delete(name);
     }
     const state = this.connectionStates.get(name);
@@ -2134,7 +1935,7 @@ class McpService extends import_core8.Service {
     }
     return new import_stdio.StdioClientTransport({
       command: config.command,
-      args: config.args,
+      args: config.args ? [...config.args] : undefined,
       env: {
         ...config.env,
         ...process.env.PATH ? { PATH: process.env.PATH } : {}
@@ -2147,9 +1948,6 @@ class McpService extends import_core8.Service {
     if (!config.url) {
       throw new Error(`Missing URL for HTTP MCP server ${name}`);
     }
-    if (config.type === "sse") {
-      import_core8.logger.warn(`Server "${name}": "sse" transport type is deprecated. Use "streamable-http" or "http" instead for the modern Streamable HTTP transport.`);
-    }
     return new import_sse.SSEClientTransport(new URL(config.url));
   }
   appendErrorMessage(connection, error) {
@@ -2158,62 +1956,38 @@ ${error}` : error;
     connection.server.error = newError;
   }
   async fetchToolsList(serverName) {
-    try {
-      const connection = this.getServerConnection(serverName);
-      if (!connection) {
-        return [];
-      }
-      const response = await connection.client.listTools();
-      const tools = (response?.tools || []).map((tool) => {
-        let processedTool = { ...tool };
-        if (tool.inputSchema) {
-          try {
-            if (!this.compatibilityInitialized) {
-              this.initializeToolCompatibility();
-            }
-            processedTool.inputSchema = this.applyToolCompatibility(tool.inputSchema);
-            import_core8.logger.debug(`Applied tool compatibility for: ${tool.name} on server: ${serverName}`);
-          } catch (error) {
-            import_core8.logger.warn({ error, toolName: tool.name, serverName }, `Tool compatibility failed for ${tool.name} on ${serverName}`);
-          }
-        }
-        return processedTool;
-      });
-      import_core8.logger.info(`Fetched ${tools.length} tools for ${serverName}`);
-      for (const tool of tools) {
-        import_core8.logger.info(`[${serverName}] ${tool.name}: ${tool.description}`);
-      }
-      return tools;
-    } catch (error) {
-      import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName }, `Failed to fetch tools for ${serverName}`);
+    const connection = this.getServerConnection(serverName);
+    if (!connection) {
       return [];
     }
+    const response = await connection.client.listTools();
+    const tools = (response?.tools ?? []).map((tool) => {
+      const processedTool = { ...tool };
+      if (tool.inputSchema) {
+        if (!this.compatibilityInitialized) {
+          this.initializeToolCompatibility();
+        }
+        processedTool.inputSchema = this.applyToolCompatibility(tool.inputSchema);
+      }
+      return processedTool;
+    });
+    return tools;
   }
   async fetchResourcesList(serverName) {
-    try {
-      const connection = this.getServerConnection(serverName);
-      if (!connection) {
-        return [];
-      }
-      const response = await connection.client.listResources();
-      return response?.resources || [];
-    } catch (error) {
-      import_core8.logger.warn({ error: error instanceof Error ? error.message : String(error), serverName }, `No resources found for ${serverName}`);
+    const connection = this.getServerConnection(serverName);
+    if (!connection) {
       return [];
     }
+    const response = await connection.client.listResources();
+    return response?.resources ?? [];
   }
   async fetchResourceTemplatesList(serverName) {
-    try {
-      const connection = this.getServerConnection(serverName);
-      if (!connection) {
-        return [];
-      }
-      const response = await connection.client.listResourceTemplates();
-      return response?.resourceTemplates || [];
-    } catch (error) {
-      import_core8.logger.warn({ error: error instanceof Error ? error.message : String(error), serverName }, `No resource templates found for ${serverName}`);
+    const connection = this.getServerConnection(serverName);
+    if (!connection) {
       return [];
     }
+    const response = await connection.client.listResourceTemplates();
+    return response?.resourceTemplates ?? [];
   }
   getServers() {
     return Array.from(this.connections.values()).filter((conn) => !conn.server.disabled).map((conn) => conn.server);
@@ -2230,13 +2004,14 @@ ${error}` : error;
       throw new Error(`Server "${serverName}" is disabled`);
     }
     let timeout = DEFAULT_MCP_TIMEOUT_SECONDS;
-    try {
-      const config = JSON.parse(connection.server.config);
-      timeout = config.timeoutInMillis || DEFAULT_MCP_TIMEOUT_SECONDS;
-    } catch (error) {
-      import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName }, `Failed to parse timeout configuration for server ${serverName}`);
+    const config = JSON.parse(connection.server.config);
+    if (config.type === "stdio" && config.timeoutInMillis) {
+      timeout = config.timeoutInMillis;
     }
-    const result = await connection.client.callTool({ name: toolName, arguments: toolArguments }, undefined, { timeout });
+    const result = await connection.client.callTool({
+      name: toolName,
+      arguments: toolArguments ? { ...toolArguments } : undefined
+    }, undefined, { timeout });
     if (!result.content) {
       throw new Error("Invalid tool result: missing content array");
     }
@@ -2254,19 +2029,12 @@ ${error}` : error;
   }
   async restartConnection(serverName) {
     const connection = this.connections.get(serverName);
-    const config = connection?.server.config;
+    const config = connection?.server?.config;
     if (config) {
-      import_core8.logger.info(`Restarting ${serverName} MCP server...`);
       connection.server.status = "connecting";
       connection.server.error = "";
-      try {
-        await this.deleteConnection(serverName);
-        await this.initializeConnection(serverName, JSON.parse(config));
-        import_core8.logger.info(`${serverName} MCP server connected`);
-      } catch (error) {
-        import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName }, `Failed to restart connection for ${serverName}`);
-        throw new Error(`Failed to connect to ${serverName} MCP server`);
-      }
+      await this.deleteConnection(serverName);
+      await this.initializeConnection(serverName, JSON.parse(config));
     }
   }
   initializeToolCompatibility() {
@@ -2274,11 +2042,6 @@ ${error}` : error;
       return;
     this.toolCompatibility = createMcpToolCompatibilitySync(this.runtime);
     this.compatibilityInitialized = true;
-    if (this.toolCompatibility) {
-      import_core8.logger.info(`Tool compatibility enabled`);
-    } else {
-      import_core8.logger.info(`No tool compatibility needed`);
-    }
   }
   applyToolCompatibility(toolSchema) {
     if (!this.compatibilityInitialized) {
@@ -2287,12 +2050,7 @@ ${error}` : error;
     if (!this.toolCompatibility || !toolSchema) {
       return toolSchema;
     }
-    try {
-      return this.toolCompatibility.transformToolSchema(toolSchema);
-    } catch (error) {
-      import_core8.logger.warn({ error }, `Tool compatibility transformation failed`);
-      return toolSchema;
-    }
+    return this.toolCompatibility.transformToolSchema(toolSchema);
   }
 }
 
@@ -2301,7 +2059,7 @@ var mcpPlugin = {
   name: "mcp",
   description: "Plugin for connecting to MCP (Model Context Protocol) servers",
   init: async (_config, _runtime) => {
-    import_core9.logger.info("Initializing MCP plugin...");
+    import_core7.logger.info("Initializing MCP plugin...");
   },
   services: [McpService],
   actions: [callToolAction, readResourceAction],
@@ -2309,4 +2067,4 @@ var mcpPlugin = {
 };
 var src_default = mcpPlugin;
 
-//# debugId=362D3DF72359421664756E2164756E21
+//# debugId=67D36987F069B88A64756E2164756E21