mcp-medic 1.2.1 → 1.2.2

package/dist/protocol/connect.js

@@ -82,6 +82,37 @@ function normalizeTools(result) {
         };
     });
 }
+function normalizeResources(result) {
+    if (!Array.isArray(result.resources))
+        throw new Error('resources/list response has no resources array');
+    return result.resources.map((resource, index) => {
+        if (!resource || typeof resource !== 'object' || typeof resource.uri !== 'string') {
+            throw new Error(`resources/list returned an invalid resource at index ${index}`);
+        }
+        const value = resource;
+        return {
+            uri: value.uri,
+            ...(typeof value.name === 'string' ? { name: value.name } : {}),
+            ...(typeof value.description === 'string' ? { description: value.description } : {}),
+            ...(typeof value.mimeType === 'string' ? { mimeType: value.mimeType } : {}),
+        };
+    });
+}
+function normalizePrompts(result) {
+    if (!Array.isArray(result.prompts))
+        throw new Error('prompts/list response has no prompts array');
+    return result.prompts.map((prompt, index) => {
+        if (!prompt || typeof prompt !== 'object' || typeof prompt.name !== 'string') {
+            throw new Error(`prompts/list returned an invalid prompt at index ${index}`);
+        }
+        const value = prompt;
+        return {
+            name: value.name,
+            ...(typeof value.description === 'string' ? { description: value.description } : {}),
+            ...(Array.isArray(value.arguments) ? { arguments: value.arguments } : {}),
+        };
+    });
+}
 async function refreshTokenIfNeeded(config, options) {
     const headers = { ...(config.headers ?? {}) };
     if (!config.tokenRefreshUrl) {
@@ -409,6 +440,11 @@ export async function connect(config, timeoutMs, options) {
         else {
             return failed(config, 'failed', 'spawn', `unsupported transport: ${String(config.transport)}`);
         }
+        // Requests are numbered sequentially in the order they're actually sent
+        // (notifications don't consume an id) — tracked locally rather than
+        // hardcoded, since which optional capability calls happen below depends
+        // on what the server declares.
+        let nextExpectedId = 1;
         let initialize;
         try {
             const response = await withTimeout(transport.request('initialize', {
@@ -416,7 +452,7 @@ export async function connect(config, timeoutMs, options) {
                 capabilities: {},
                 clientInfo: CLIENT_INFO,
             }), timeoutMs, 'initialize handshake');
-            initialize = validateResponse(response, 1);
+            initialize = validateResponse(response, nextExpectedId++);
             if (!initialize.capabilities || typeof initialize.capabilities !== 'object') {
                 throw new Error('initialize response has no capabilities object');
             }
@@ -450,21 +486,51 @@ export async function connect(config, timeoutMs, options) {
         catch (error) {
             return failed(config, messageOf(error).includes('timed out') ? 'timeout' : 'failed', 'capability-negotiation', messageOf(error), error, { protocolVersion, serverInfo });
         }
+        let tools;
         try {
-            const tools = normalizeTools(validateResponse(await withTimeout(transport.request('tools/list'), timeoutMs, 'tools/list'), 2));
-            return {
-                server: config,
-                status: 'connected',
-                capabilities,
-                tools,
-                protocolVersion,
-                serverInfo,
-                latencyMs: Date.now() - started,
-            };
+            tools = normalizeTools(validateResponse(await withTimeout(transport.request('tools/list'), timeoutMs, 'tools/list'), nextExpectedId++));
         }
         catch (error) {
             return failed(config, messageOf(error).includes('timed out') ? 'timeout' : 'failed', 'list-tools', messageOf(error), error, { protocolVersion, serverInfo });
         }
+        // Resources and prompts are optional MCP capabilities: only inspect them
+        // if the server actually declared support in its initialize response.
+        // Passive enumeration only (resources/list, prompts/list) — never
+        // resources/read or prompts/get, which would be real invocation.
+        // A failure here is never fatal to the connection: tools is the one
+        // capability mcp-medic requires, so a broken resources/prompts listing
+        // is reported alongside a still-successful connection.
+        let resources;
+        let prompts;
+        const capabilityErrors = {};
+        if (capabilities.resources && typeof capabilities.resources === 'object') {
+            try {
+                resources = normalizeResources(validateResponse(await withTimeout(transport.request('resources/list'), timeoutMs, 'resources/list'), nextExpectedId++));
+            }
+            catch (error) {
+                capabilityErrors.resources = messageOf(error);
+            }
+        }
+        if (capabilities.prompts && typeof capabilities.prompts === 'object') {
+            try {
+                prompts = normalizePrompts(validateResponse(await withTimeout(transport.request('prompts/list'), timeoutMs, 'prompts/list'), nextExpectedId++));
+            }
+            catch (error) {
+                capabilityErrors.prompts = messageOf(error);
+            }
+        }
+        return {
+            server: config,
+            status: 'connected',
+            capabilities,
+            tools,
+            ...(resources !== undefined ? { resources } : {}),
+            ...(prompts !== undefined ? { prompts } : {}),
+            ...(Object.keys(capabilityErrors).length > 0 ? { capabilityErrors } : {}),
+            protocolVersion,
+            serverInfo,
+            latencyMs: Date.now() - started,
+        };
     }
     catch (error) {
         return failed(config, 'failed', 'handshake', messageOf(error), error);

package/dist/report.js

@@ -13,6 +13,20 @@ export function formatReportHuman(report, options = {}) {
             const statusText = compatible ? '✓ compatible' : '✗ incompatible';
             lines.push(`  Protocol: requested ${requested}, server negotiated ${negotiated ?? '(none)'} — ${statusText}`);
         }
+        if (conn.tools) {
+            const parts = [`${conn.tools.length} tool(s)`];
+            if (conn.resources)
+                parts.push(`${conn.resources.length} resource(s)`);
+            if (conn.prompts)
+                parts.push(`${conn.prompts.length} prompt(s)`);
+            lines.push(`  Capabilities: ${parts.join(', ')}`);
+        }
+        if (conn.capabilityErrors?.resources) {
+            lines.push(`  resources/list: ${conn.capabilityErrors.resources}`);
+        }
+        if (conn.capabilityErrors?.prompts) {
+            lines.push(`  prompts/list: ${conn.capabilityErrors.prompts}`);
+        }
         if (conn.error) {
             lines.push(`  ${conn.error.stage}: ${conn.error.message}`);
         }

package/dist/types.d.ts

@@ -19,6 +19,17 @@ export interface MCPToolDefinition {
     description?: string;
     inputSchema: unknown;
 }
+export interface MCPResourceDefinition {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface MCPPromptDefinition {
+    name: string;
+    description?: string;
+    arguments?: unknown[];
+}
 export interface ProtocolVersionInfo {
     /** The protocolVersion this client sent in `initialize`. */
     requested: string;
@@ -36,6 +47,16 @@ export interface MCPConnection {
     status: 'connected' | 'failed' | 'timeout';
     capabilities?: Record<string, unknown>;
     tools?: MCPToolDefinition[];
+    /** Populated only if the server's `initialize` response declared a `resources` capability. */
+    resources?: MCPResourceDefinition[];
+    /** Populated only if the server's `initialize` response declared a `prompts` capability. */
+    prompts?: MCPPromptDefinition[];
+    /** Best-effort failures from optional capability inspection (resources/prompts) — these
+     * never fail the overall connection, since `tools` is the one capability mcp-medic requires. */
+    capabilityErrors?: {
+        resources?: string;
+        prompts?: string;
+    };
     /** Set once an `initialize` response was received, even if negotiation was incompatible or a later stage failed. */
     protocolVersion?: ProtocolVersionInfo;
     serverInfo?: MCPServerInfo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-medic",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Diagnose broken MCP (Model Context Protocol) server configs before they break your agent silently.",
   "type": "module",
   "main": "dist/index.js",