@muxoai/platform 1.4.1 → 1.4.2

package/dist/mcp.js

@@ -2,9 +2,9 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { ROOT_DIR } from "./config.js";
-import { APPROVED_PLAN_STATUSES, DEFAULT_TOOL_SECURITY_SCHEMES, MUXO_MCP_SERVER_INSTRUCTIONS, MUXO_MCP_TOOLS, OPENAI_COMPANY_KNOWLEDGE_TOOLS, PUBLIC_MCP_TOOL_NAMES, PUBLIC_TOOL_SECURITY_SCHEMES, attachMcpHarnessGuidance, MuxoToolError, buildApprovalUrl, buildOnboardTeamGuide, clampWaitSeconds, errorPayloadFrom, findMcpSkill, securitySchemesForTool, } from "./mcp-schema.js";
+import { APPROVED_PLAN_STATUSES, DEFAULT_LEGACY_MCP_PROTOCOL_VERSION, DEFAULT_TOOL_SECURITY_SCHEMES, LATEST_MCP_PROTOCOL_VERSION, MCP_ERR_HEADER_MISMATCH, MCP_ERR_MISSING_REQUIRED_CLIENT_CAPABILITY, MCP_ERR_UNSUPPORTED_PROTOCOL_VERSION, MUXO_MCP_RESOURCE_TEMPLATES, MUXO_MCP_SERVER_INSTRUCTIONS, MUXO_MCP_TOOLS, MUXO_UI_MCP_APP_URI, MUXO_UI_RESOURCES, MUXO_UI_WIDGET_URI, OPENAI_COMPANY_KNOWLEDGE_TOOLS, PUBLIC_MCP_TOOL_NAMES, PUBLIC_TOOL_SECURITY_SCHEMES, SUPPORTED_MCP_PROTOCOL_VERSIONS, UI_RENDERED_MCP_TOOL_NAMES, attachMcpHarnessGuidance, MuxoToolError, buildApprovalUrl, buildMcpDiscoverResult, buildMcpErrorResultMeta, buildMcpToolDescriptor, buildMcpToolResultMeta, buildOnboardTeamGuide, clampWaitSeconds, completeMcpArgument, decodeMcpHeaderValue, errorPayloadFrom, extractOpenAiClientMeta, findMcpSkill, isSupportedMcpProtocolVersion, renderMuxoUiWidgetHtml, securitySchemesForTool, validateMcpHttpHeadersAndMeta, } from "./mcp-schema.js";
 import { MUXO_VERSION } from "./version.js";
-export { DEFAULT_TOOL_SECURITY_SCHEMES, MUXO_MCP_SERVER_INSTRUCTIONS, MUXO_MCP_TOOLS, OPENAI_COMPANY_KNOWLEDGE_TOOLS, PUBLIC_MCP_TOOL_NAMES, PUBLIC_TOOL_SECURITY_SCHEMES, attachMcpHarnessGuidance, securitySchemesForTool, };
+export { DEFAULT_LEGACY_MCP_PROTOCOL_VERSION, DEFAULT_TOOL_SECURITY_SCHEMES, LATEST_MCP_PROTOCOL_VERSION, MCP_ERR_HEADER_MISMATCH, MCP_ERR_MISSING_REQUIRED_CLIENT_CAPABILITY, MCP_ERR_UNSUPPORTED_PROTOCOL_VERSION, MUXO_MCP_RESOURCE_TEMPLATES, MUXO_MCP_SERVER_INSTRUCTIONS, MUXO_MCP_TOOLS, MUXO_UI_MCP_APP_URI, MUXO_UI_RESOURCES, MUXO_UI_WIDGET_URI, OPENAI_COMPANY_KNOWLEDGE_TOOLS, PUBLIC_MCP_TOOL_NAMES, PUBLIC_TOOL_SECURITY_SCHEMES, SUPPORTED_MCP_PROTOCOL_VERSIONS, UI_RENDERED_MCP_TOOL_NAMES, attachMcpHarnessGuidance, buildMcpDiscoverResult, buildMcpErrorResultMeta, buildMcpToolDescriptor, buildMcpToolResultMeta, completeMcpArgument, decodeMcpHeaderValue, extractOpenAiClientMeta, isSupportedMcpProtocolVersion, renderMuxoUiWidgetHtml, securitySchemesForTool, validateMcpHttpHeadersAndMeta, };
 function sha256Digest(content) {
     const hash = crypto
         .createHash("sha256")
@@ -43,7 +43,7 @@ function readSkillFileOrDefault(relPath, fallback) {
 export function getMuxoMcpSkills() {
     const muxoSkillMd = readSkillFileOrDefault("muxo/SKILL.md", `---
 name: muxo
-description: Route governed Muxo work between the hosted MCP-backed app and the local Muxo CLI across Connected Apps (Composio), Instant Tools, Cloud Infrastructure (Stripe Projects), Supermemory v5, and Microsoft Agent Governance.
+description: Route governed Muxo work between the hosted MCP-backed app and the local Muxo CLI across Muxo Connected Apps, Instant Tools, Cloud Infrastructure (Stripe Projects), Supermemory v5, and Microsoft Agent Governance.
 ---
 
 # Muxo
@@ -168,12 +168,18 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
                 provider: args.provider ? String(args.provider) : undefined,
                 syncLive: args.sync_live !== false,
             });
-        case "start_connection":
-            return engine.startConnection(ctx, {
+        case "start_connection": {
+            const conn = await engine.startConnection(ctx, {
                 provider: String(args.provider || ""),
                 lane: args.lane,
                 callbackUrl: args.callback_url ? String(args.callback_url) : undefined,
             });
+            return {
+                ok: true,
+                ...conn,
+                connection: conn,
+            };
+        }
         case "wait_for_connection":
             return engine.waitForConnection(ctx, {
                 provider: String(args.provider || ""),
@@ -273,6 +279,35 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
                     source: rawParamRules ? "mcp_harness" : "deterministic",
                 });
             }
+            if (action === "reset_guardrails") {
+                return engine.resetWorkspaceGuardrails(ctx);
+            }
+            if (action === "check_policy" || action === "simulate_policy") {
+                const toolSlug = String(args.tool_slug || args.slug || args.tool_id || query || prompt || "instant.web.search").trim();
+                const input = (args.input || args.arguments) || {};
+                return engine.checkToolPolicy(ctx, { toolSlug, input });
+            }
+            if (action === "kill_switch") {
+                const enabled = typeof args.enabled === "boolean"
+                    ? args.enabled
+                    : typeof args.active === "boolean"
+                        ? args.active
+                        : !/\b(resume|unpause|disable|off|false)\b/i.test(prompt || query || "");
+                const reason = prompt ||
+                    query ||
+                    (enabled ? "Paused via MCP get_run_context" : undefined);
+                const updated = engine.setKillSwitch(ctx, enabled, reason);
+                const govOverview = engine.getGovernanceOverview(ctx);
+                return {
+                    ok: true,
+                    action: "kill_switch",
+                    killSwitchActive: Boolean(updated.policy.killSwitchActive),
+                    killSwitchReason: updated.policy.killSwitchReason || null,
+                    policy: updated.policy,
+                    llmPolicyBrief: govOverview.llmPolicyBrief,
+                    explanation: govOverview.explanation,
+                };
+            }
             if (action === "scan_context") {
                 const textToScan = String(args.content || prompt || query || "");
                 return engine.scanForContextPoisoning(ctx.workspace.id, textToScan);
@@ -403,6 +438,39 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
                 source: rawParamRules ? "mcp_harness" : "deterministic",
             });
         }
+        case "reset_guardrails":
+            return engine.resetWorkspaceGuardrails(ctx);
+        case "check_policy":
+        case "simulate_policy":
+            return engine.checkToolPolicy(ctx, {
+                toolSlug: String(args.tool_slug || args.slug || args.tool_id || args.query || "instant.web.search"),
+                input: (args.input || args.arguments) || {},
+            });
+        case "kill_switch": {
+            const enabled = typeof args.enabled === "boolean"
+                ? args.enabled
+                : typeof args.active === "boolean"
+                    ? args.active
+                    : true;
+            const reason = args.reason
+                ? String(args.reason)
+                : args.prompt
+                    ? String(args.prompt)
+                    : undefined;
+            const updated = engine.setKillSwitch(ctx, enabled, reason);
+            const govOverview = engine.getGovernanceOverview(ctx);
+            return {
+                ok: true,
+                action: "kill_switch",
+                killSwitchActive: Boolean(updated.policy.killSwitchActive),
+                killSwitchReason: updated.policy.killSwitchReason || null,
+                policy: updated.policy,
+                llmPolicyBrief: govOverview.llmPolicyBrief,
+                explanation: govOverview.explanation,
+            };
+        }
+        case "scan_context":
+            return engine.scanForContextPoisoning(ctx.workspace.id, String(args.content || args.prompt || args.query || ""));
         case "governance_status":
             return engine.getGovernanceOverview(ctx);
         case "verify_receipt_chain":
@@ -424,7 +492,7 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
             const toolHits = toolsRes.tools.map((t) => ({
                 id: `tool:${t.slug}`,
                 title: `${t.name} (${t.slug})`,
-                url: t.providerUrl || `https://docs.muxo.ai/tools/${encodeURIComponent(t.slug)}`,
+                url: t.providerUrl || `https://docs.muxo.ai/catalogue#${encodeURIComponent(t.providerSlug || t.slug)}`,
                 snippet: `${t.description} [lane=${t.lane}, risk=${t.riskLevel}, cost=${t.creditCost}cr]`,
             }));
             const memHits = (memRes.memories || []).slice(0, 5).map((m) => ({
@@ -464,7 +532,7 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
                 title: tool.name,
                 text: JSON.stringify(tool, null, 2),
                 url: tool.providerUrl ||
-                    `https://docs.muxo.ai/tools/${encodeURIComponent(tool.slug)}`,
+                    `https://docs.muxo.ai/catalogue#${encodeURIComponent(tool.providerSlug || tool.slug)}`,
                 metadata: {
                     slug: tool.slug,
                     lane: tool.lane,
@@ -485,41 +553,90 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
         method.startsWith("notifications/")) {
         return null;
     }
+    const headerAndMetaCheck = validateMcpHttpHeadersAndMeta({}, rpc);
+    if (!headerAndMetaCheck.ok) {
+        return {
+            jsonrpc: "2.0",
+            id,
+            error: headerAndMetaCheck.error,
+        };
+    }
     try {
+        if (method === "server/discover") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: buildMcpDiscoverResult(MUXO_VERSION),
+            };
+        }
         if (method === "initialize") {
-            const requestedProtocol = typeof params.protocolVersion === "string" &&
-                params.protocolVersion.trim()
-                ? params.protocolVersion.trim()
-                : "2025-06-18";
+            const requestedProtocol = headerAndMetaCheck.protocolVersion;
+            const serverInfo = {
+                name: "muxo-mcp-server",
+                title: "Muxo Unified Agent Runtime & Governance MCP Server",
+                version: MUXO_VERSION,
+            };
             return {
                 jsonrpc: "2.0",
                 id,
                 result: {
+                    resultType: "complete",
                     protocolVersion: requestedProtocol,
+                    supportedVersions: [...SUPPORTED_MCP_PROTOCOL_VERSIONS],
                     instructions: MUXO_MCP_SERVER_INSTRUCTIONS,
-                    serverInfo: {
-                        name: "muxo-mcp-server",
-                        version: MUXO_VERSION,
-                    },
+                    serverInfo,
                     capabilities: {
                         tools: { listChanged: false },
-                        resources: { listChanged: false },
+                        resources: { listChanged: false, subscribe: false },
                         prompts: { listChanged: false },
+                        completions: {},
                         extensions: {
                             "io.modelcontextprotocol/skills": {},
+                            "io.modelcontextprotocol/apps": {},
                         },
                     },
+                    _meta: {
+                        "io.modelcontextprotocol/serverInfo": serverInfo,
+                        "io.modelcontextprotocol/instructions": MUXO_MCP_SERVER_INSTRUCTIONS,
+                    },
                 },
             };
         }
         if (method === "ping") {
-            return { jsonrpc: "2.0", id, result: {} };
+            return { jsonrpc: "2.0", id, result: { resultType: "complete" } };
+        }
+        if (method === "completion/complete") {
+            const catalogTools = await engine.searchTools({ lane: "all", limit: 100 });
+            const completion = completeMcpArgument(params, catalogTools.tools.map((t) => t.slug));
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    resultType: "complete",
+                    completion,
+                },
+            };
+        }
+        if (method === "subscriptions/listen") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    resultType: "complete",
+                    events: [],
+                    ttlMs: 30_000,
+                    cacheScope: "private",
+                },
+            };
         }
         if (method === "prompts/list") {
             return {
                 jsonrpc: "2.0",
                 id,
                 result: {
+                    resultType: "complete",
+                    ttlMs: 300_000,
+                    cacheScope: "public",
                     prompts: [
                         {
                             name: "context",
@@ -551,6 +668,12 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                             description: "Inspect the workspace's 9-module Microsoft Agent Governance posture, Bi-Temporal Knowledge Graph, and Ed25519 AgenticReceipt hash chain.",
                             arguments: [],
                         },
+                        {
+                            name: "policy_guardrails",
+                            title: "Workspace Policy, Parameter Guardrails & Risk Matrix",
+                            description: "Load the structured LLM Policy & Governance Brief (riskLaneMatrix, conditional parameterRules with compliance guidance, budget caps, kill switch status, and control-plane commands).",
+                            arguments: [],
+                        },
                     ],
                 },
             };
@@ -565,6 +688,7 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
                         description: "Ready-to-attach Muxo workspace memory, active defaults, and safety guardrails.",
                         messages: [
                             {
@@ -578,6 +702,36 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     },
                 };
             }
+            if (promptName === "policy_guardrails") {
+                const gov = engine.getGovernanceOverview(ctx);
+                const sections = [
+                    gov.llmPolicyBrief.llmSystemDirective,
+                    `### Structured LLM Policy Brief (JSON)\n\`\`\`json\n${JSON.stringify(gov.llmPolicyBrief, null, 2)}\n\`\`\``,
+                ];
+                if (promptArgs.tool_slug) {
+                    const sim = await engine.checkToolPolicy(ctx, {
+                        toolSlug: String(promptArgs.tool_slug),
+                    });
+                    sections.push(`### Dry-Run Policy Check for \`${sim.toolSlug}\`\n\`\`\`json\n${JSON.stringify(sim, null, 2)}\n\`\`\``);
+                }
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        description: "Workspace policy, conditional parameter guardrails, and risk-lane matrix for AI agents",
+                        messages: [
+                            {
+                                role: "user",
+                                content: {
+                                    type: "text",
+                                    text: sections.join("\n\n"),
+                                },
+                            },
+                        ],
+                    },
+                };
+            }
             if (promptName === "governed_execution") {
                 const task = String(promptArgs.task || "the user's requested operation");
                 const runCtx = await engine.getRunContext(ctx);
@@ -585,6 +739,7 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
                         description: "Governed Muxo execution workflow prompt",
                         messages: [
                             {
@@ -608,6 +763,7 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
                         description: "Workspace governance, bi-temporal graph, and receipt chain audit",
                         messages: [
                             {
@@ -640,10 +796,10 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                 jsonrpc: "2.0",
                 id,
                 result: {
-                    tools: MUXO_MCP_TOOLS.map((t) => ({
-                        ...t,
-                        securitySchemes: securitySchemesForTool(t.name),
-                    })),
+                    resultType: "complete",
+                    ttlMs: 300_000,
+                    cacheScope: "public",
+                    tools: MUXO_MCP_TOOLS.map((t) => buildMcpToolDescriptor(t)),
                 },
             };
         }
@@ -655,10 +811,12 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
             const structuredContent = output && typeof output === "object" && !Array.isArray(output)
                 ? output
                 : { data: output };
+            const resultMeta = buildMcpToolResultMeta(toolName, params);
             return {
                 jsonrpc: "2.0",
                 id,
                 result: {
+                    resultType: "complete",
                     structuredContent,
                     content: [
                         {
@@ -666,6 +824,7 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                             text: JSON.stringify(output, null, 2),
                         },
                     ],
+                    ...(resultMeta ? { _meta: resultMeta } : {}),
                     isError: false,
                 },
             };
@@ -688,7 +847,12 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
             return {
                 jsonrpc: "2.0",
                 id,
-                result: { skills },
+                result: {
+                    resultType: "complete",
+                    ttlMs: 300_000,
+                    cacheScope: "public",
+                    skills,
+                },
             };
         }
         if (method === "skills/get") {
@@ -711,6 +875,9 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                 jsonrpc: "2.0",
                 id,
                 result: {
+                    resultType: "complete",
+                    ttlMs: 300_000,
+                    cacheScope: "public",
                     skill: {
                         uri: skill.uri,
                         frontmatter: skill.frontmatter,
@@ -733,6 +900,18 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                 },
             };
         }
+        if (method === "resources/templates/list") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    resultType: "complete",
+                    ttlMs: 300_000,
+                    cacheScope: "public",
+                    resourceTemplates: MUXO_MCP_RESOURCE_TEMPLATES,
+                },
+            };
+        }
         if (method === "resources/list") {
             const skillResources = getMuxoMcpSkills().flatMap((s) => s.files.map((f) => ({
                 uri: f.uri,
@@ -777,6 +956,12 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     description: "9-module Microsoft Agent Governance status, plain-English guardrails, Bayesian trust score, and OWASP ASI-06 scan status.",
                     mimeType: "application/json",
                 },
+                {
+                    uri: "muxo://policy/brief",
+                    name: "LLM Policy, Risk Matrix & Parameter Guardrails Brief",
+                    description: "Structured LLM policy digest with riskLaneMatrix, conditional parameterRules compliance guidance, learned memory defaults, and control-plane commands.",
+                    mimeType: "application/json",
+                },
                 {
                     uri: "muxo://receipts/chain",
                     name: "Cryptographic AgenticReceipt Hash Chain",
@@ -787,11 +972,36 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
             return {
                 jsonrpc: "2.0",
                 id,
-                result: { resources: [...skillResources, ...dynamicResources] },
+                result: {
+                    resultType: "complete",
+                    ttlMs: 60_000,
+                    cacheScope: "private",
+                    resources: [...MUXO_UI_RESOURCES, ...skillResources, ...dynamicResources],
+                },
             };
         }
         if (method === "resources/read") {
             const uri = String(params.uri || "").trim();
+            const uiResource = MUXO_UI_RESOURCES.find((r) => r.uri === uri);
+            if (uiResource) {
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        ttlMs: 300_000,
+                        cacheScope: "public",
+                        contents: [
+                            {
+                                uri: uiResource.uri,
+                                mimeType: uiResource.mimeType,
+                                text: renderMuxoUiWidgetHtml(),
+                                _meta: uiResource._meta,
+                            },
+                        ],
+                    },
+                };
+            }
             if (uri === "muxo://profile" || uri === "supermemory://profile") {
                 const overview = await engine.getMemoryOverview(ctx);
                 const profile = engine.getProfile(ctx);
@@ -810,6 +1020,9 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
                         contents: [
                             {
                                 uri,
@@ -838,6 +1051,9 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
                         contents: [
                             {
                                 uri,
@@ -854,6 +1070,9 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
                         contents: [
                             {
                                 uri,
@@ -870,6 +1089,9 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
                         contents: [
                             {
                                 uri,
@@ -886,6 +1108,9 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
                         contents: [
                             {
                                 uri,
@@ -896,12 +1121,34 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     },
                 };
             }
+            if (uri === "muxo://policy/brief") {
+                const gov = engine.getGovernanceOverview(ctx);
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
+                        contents: [
+                            {
+                                uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify(gov.llmPolicyBrief, null, 2),
+                            },
+                        ],
+                    },
+                };
+            }
             if (uri === "muxo://receipts/chain") {
                 const chain = engine.verifyReceiptChain(ctx);
                 return {
                     jsonrpc: "2.0",
                     id,
                     result: {
+                        resultType: "complete",
+                        ttlMs: 60_000,
+                        cacheScope: "private",
                         contents: [
                             {
                                 uri,
@@ -912,6 +1159,142 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     },
                 };
             }
+            if (uri.startsWith("muxo://tools/")) {
+                const slug = decodeURIComponent(uri.slice("muxo://tools/".length)).trim();
+                try {
+                    const inspected = await dispatchMcpToolCall(engine, ctx, "inspect_tool", {
+                        tool_slug: slug,
+                    });
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        result: {
+                            resultType: "complete",
+                            ttlMs: 300_000,
+                            cacheScope: "public",
+                            contents: [
+                                {
+                                    uri,
+                                    mimeType: "application/json",
+                                    text: JSON.stringify(inspected, null, 2),
+                                },
+                            ],
+                        },
+                    };
+                }
+                catch {
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        error: {
+                            code: -32602,
+                            message: `Resource not found: ${uri}`,
+                        },
+                    };
+                }
+            }
+            if (uri.startsWith("muxo://plans/")) {
+                const planId = decodeURIComponent(uri.slice("muxo://plans/".length)).trim();
+                try {
+                    const planRecord = await dispatchMcpToolCall(engine, ctx, "get_plan", {
+                        plan_id: planId,
+                    });
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        result: {
+                            resultType: "complete",
+                            ttlMs: 30_000,
+                            cacheScope: "private",
+                            contents: [
+                                {
+                                    uri,
+                                    mimeType: "application/json",
+                                    text: JSON.stringify(planRecord, null, 2),
+                                },
+                            ],
+                        },
+                    };
+                }
+                catch {
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        error: {
+                            code: -32602,
+                            message: `Resource not found: ${uri}`,
+                        },
+                    };
+                }
+            }
+            if (uri.startsWith("muxo://runs/")) {
+                const runId = decodeURIComponent(uri.slice("muxo://runs/".length)).trim();
+                try {
+                    const runRecord = await dispatchMcpToolCall(engine, ctx, "get_run", {
+                        run_id: runId,
+                    });
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        result: {
+                            resultType: "complete",
+                            ttlMs: 30_000,
+                            cacheScope: "private",
+                            contents: [
+                                {
+                                    uri,
+                                    mimeType: "application/json",
+                                    text: JSON.stringify(runRecord, null, 2),
+                                },
+                            ],
+                        },
+                    };
+                }
+                catch {
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        error: {
+                            code: -32602,
+                            message: `Resource not found: ${uri}`,
+                        },
+                    };
+                }
+            }
+            if (uri.startsWith("muxo://receipts/")) {
+                const receiptId = decodeURIComponent(uri.slice("muxo://receipts/".length)).trim();
+                try {
+                    const receiptRecord = await dispatchMcpToolCall(engine, ctx, "get_receipt", {
+                        receipt_id: receiptId,
+                    });
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        result: {
+                            resultType: "complete",
+                            ttlMs: 60_000,
+                            cacheScope: "private",
+                            contents: [
+                                {
+                                    uri,
+                                    mimeType: "application/json",
+                                    text: JSON.stringify(receiptRecord, null, 2),
+                                },
+                            ],
+                        },
+                    };
+                }
+                catch {
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        error: {
+                            code: -32602,
+                            message: `Resource not found: ${uri}`,
+                        },
+                    };
+                }
+            }
             const allFiles = getMuxoMcpSkills().flatMap((s) => s.files);
             const found = allFiles.find((f) => f.uri === uri);
             if (!found) {
@@ -928,6 +1311,9 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                 jsonrpc: "2.0",
                 id,
                 result: {
+                    resultType: "complete",
+                    ttlMs: 300_000,
+                    cacheScope: "public",
                     contents: [
                         {
                             uri: found.uri,
@@ -949,10 +1335,12 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
     }
     catch (err) {
         const errPayload = errorPayloadFrom(err, "MCP tool execution failed");
+        const errMeta = buildMcpErrorResultMeta(err, engine?.config?.baseUrl || "https://api.muxo.ai");
         return {
             jsonrpc: "2.0",
             id,
             result: {
+                resultType: "complete",
                 structuredContent: errPayload,
                 content: [
                     {
@@ -960,6 +1348,7 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                         text: JSON.stringify(errPayload, null, 2),
                     },
                 ],
+                ...(errMeta ? { _meta: errMeta } : {}),
                 isError: true,
             },
         };