graph-indexer 3.0.1 → 3.1.1

package/src/mcp/server.mjs

@@ -10,6 +10,32 @@
 import readline from 'node:readline';
 import { TOOLS, LEGACY_TOOLS, SERVER_INSTRUCTIONS, callTool } from './tools.mjs';
 
+const MAX_ITEMS = 100;          // an array argument with no maxItems of its own
+const MAX_STRING = 200_000;     // a string argument (an issue pasted as a query is long, not this long)
+
+/**
+ * The arguments as the tool's schema bounds them: numbers clamped to minimum/maximum, arrays cut
+ * to maxItems (else MAX_ITEMS), strings to MAX_STRING. A client is not trusted to respect the schema,
+ * and `depth: 1e9` or ten thousand queries would otherwise hold the server.
+ */
+export function boundArgs(schema, raw) {
+    const args = raw && typeof raw === 'object' && !Array.isArray(raw) ? { ...raw } : {};
+    const props = schema?.properties ?? {};
+    const str = (v) => (typeof v === 'string' && v.length > MAX_STRING ? v.slice(0, MAX_STRING) : v);
+    for (const [k, v] of Object.entries(args)) {
+        const p = props[k];
+        if (typeof v === 'number' && p && (p.type === 'integer' || p.type === 'number')) {
+            let n = Number.isFinite(v) ? v : (p.default ?? p.minimum ?? 0);
+            if (p.type === 'integer') n = Math.trunc(n);
+            if (p.minimum != null) n = Math.max(p.minimum, n);
+            if (p.maximum != null) n = Math.min(p.maximum, n);
+            args[k] = n;
+        } else if (Array.isArray(v)) args[k] = v.slice(0, p?.maxItems ?? MAX_ITEMS).map(str);
+        else args[k] = str(v);
+    }
+    return args;
+}
+
 export const SUPPORTED_VERSIONS = ['2026-07-28', '2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
 const LATEST_HANDSHAKE = '2025-11-25';
 const META_VERSION = 'io.modelcontextprotocol/protocolVersion';
@@ -64,13 +90,17 @@ export class McpServer {
             this.#error(id, -32022, `Unsupported protocol version: ${reqVersion}`, { supported: SUPPORTED_VERSIONS, requested: reqVersion });
             return;
         }
+        // 2026-07-28 results say whether they are complete (or need more input from the client);
+        // a client of that version ignores a result without it
+        const stateless = this.#requestVersion(params) === '2026-07-28' || method === 'server/discover';
+        const done = (res) => this.#result(id, stateless ? { resultType: 'complete', ...res } : res);
         try {
             switch (method) {
                 case 'initialize': {
                     const requested = params?.protocolVersion;
                     const version = SUPPORTED_VERSIONS.includes(requested) && requested !== '2026-07-28' ? requested : LATEST_HANDSHAKE;
                     this.negotiated = version;
-                    this.#result(id, {
+                    done({
                         protocolVersion: version,
                         capabilities: { tools: { listChanged: false } },
                         serverInfo: { ...this.info, title: 'graph-indexer — code graph & search' },
@@ -79,7 +109,7 @@ export class McpServer {
                     return;
                 }
                 case 'server/discover':
-                    this.#result(id, {
+                    done({
                         supportedVersions: SUPPORTED_VERSIONS,
                         capabilities: { tools: { listChanged: false } },
                         instructions: SERVER_INSTRUCTIONS,
@@ -89,22 +119,22 @@ export class McpServer {
                     });
                     return;
                 case 'ping':
-                    this.#result(id, {});
+                    done({});
                     return;
                 case 'tools/list': {
                     const res = { tools: TOOLS.map(({ name, title, description, inputSchema, annotations, _meta }) => ({ name, title, description, inputSchema, annotations, ...(_meta ? { _meta } : {}) })) };
                     if (this.#requestVersion(params) === '2026-07-28') Object.assign(res, { ttlMs: 3_600_000, cacheScope: 'private' });
-                    this.#result(id, res);
+                    done(res);
                     return;
                 }
                 case 'tools/call': {
                     const name = params?.name;
                     const tool = TOOLS.find(t => t.name === name) ?? LEGACY_TOOLS.find(t => t.name === name);
                     if (!tool) { this.#error(id, -32602, `Unknown tool: ${name}`); return; }
-                    const args = params?.arguments ?? {};
+                    const args = boundArgs(tool.inputSchema, params?.arguments);
                     const missing = (tool.inputSchema.required ?? []).filter(k => args[k] === undefined || args[k] === null || args[k] === '');
                     if (missing.length) {
-                        this.#result(id, { content: [{ type: 'text', text: `Missing required argument(s): ${missing.join(', ')}.` }], isError: true });
+                        done({ content: [{ type: 'text', text: `Missing required argument(s): ${missing.join(', ')}.` }], isError: true });
                         return;
                     }
                     this.inflight++;
@@ -112,18 +142,18 @@ export class McpServer {
                         const note = await this.#awaitReady();
                         await this.intel.ensureFresh();
                         const text = await callTool(this.intel, name, args);
-                        this.#result(id, { content: [{ type: 'text', text: note ? `${note}\n${text}` : text }] });
+                        done({ content: [{ type: 'text', text: note ? `${note}\n${text}` : text }] });
                     } catch (err) {
                         this.log(`tool ${name} failed: ${err.stack || err.message}`);
-                        this.#result(id, { content: [{ type: 'text', text: `graph-indexer error in ${name}: ${err.message}` }], isError: true });
+                        done({ content: [{ type: 'text', text: `graph-indexer error in ${name}: ${err.message}` }], isError: true });
                     } finally { this.inflight--; }
                     return;
                 }
-                case 'resources/list': this.#result(id, { resources: [] }); return;
-                case 'resources/templates/list': this.#result(id, { resourceTemplates: [] }); return;
-                case 'prompts/list': this.#result(id, { prompts: [] }); return;
-                case 'logging/setLevel': this.#result(id, {}); return;
-                case 'completion/complete': this.#result(id, { completion: { values: [], hasMore: false } }); return;
+                case 'resources/list': done({ resources: [] }); return;
+                case 'resources/templates/list': done({ resourceTemplates: [] }); return;
+                case 'prompts/list': done({ prompts: [] }); return;
+                case 'logging/setLevel': done({}); return;
+                case 'completion/complete': done({ completion: { values: [], hasMore: false } }); return;
                 default:
                     this.#error(id, -32601, `Method not found: ${method}`);
             }