@heuresis/mcp 1.0.0-rc.14 → 1.0.0-rc.15

package/dist/cloudTools.js

@@ -545,18 +545,29 @@ export async function linkConcepts(client, args) {
     if (args.fromId === args.toId) {
         return { error: 'Self-loop edges are not allowed.' };
     }
-    const from = unwrap(await client
+    // These are .maybeSingle() lookups whose null result is MEANINGFUL ("not
+    // found" / "no duplicate") — do NOT wrap them in unwrap(). unwrap() throws on
+    // a null `data`, so the dup-check below blew up with "Empty result from
+    // cloud" on EVERY first-time link, meaning no non-partition edge (derived-
+    // from / k-ref / semantic-adjacency, incl. add_kref) could ever be created.
+    const fromRes = await client
         .from('nodes')
         .select('id, workspace_id')
         .eq('id', args.fromId)
-        .maybeSingle());
+        .maybeSingle();
+    if (fromRes.error)
+        throw new Error(fromRes.error.message);
+    const from = fromRes.data;
     if (!from)
         return { error: `No concept with id ${args.fromId}` };
-    const to = unwrap(await client
+    const toRes = await client
         .from('nodes')
         .select('id, workspace_id')
         .eq('id', args.toId)
-        .maybeSingle());
+        .maybeSingle();
+    if (toRes.error)
+        throw new Error(toRes.error.message);
+    const to = toRes.data;
     if (!to)
         return { error: `No concept with id ${args.toId}` };
     if (from.workspace_id !== to.workspace_id) {
@@ -564,14 +575,18 @@ export async function linkConcepts(client, args) {
             error: 'Cannot link concepts from different workspaces.',
         };
     }
-    // Reject duplicate edges of the same kind on the same pair.
-    const dup = unwrap(await client
+    // Reject duplicate edges of the same kind on the same pair. A null here is
+    // the normal "no existing edge" case — handle it directly, never unwrap().
+    const dupRes = await client
         .from('edges')
         .select('id')
         .eq('from_id', from.id)
         .eq('to_id', to.id)
         .eq('kind', args.kind)
-        .maybeSingle());
+        .maybeSingle();
+    if (dupRes.error)
+        throw new Error(dupRes.error.message);
+    const dup = dupRes.data;
     if (dup) {
         return { id: dup.id, fromId: from.id, toId: to.id, kind: args.kind, duplicate: true };
     }

package/dist/index.js

@@ -209,7 +209,22 @@ async function runServer() {
             inputSchema: zodToJsonSchema(t.inputSchema),
         })),
     }));
-    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    // The heavy operator/LLM tools are serialized: several fired in parallel
+    // overwhelm the backend and trip the 60s timeout (observed: parallel
+    // expand_concept runs timing out). Read/write tools still run concurrently.
+    const OPERATOR_TOOLS = new Set([
+        'run_operator',
+        'run_operator_and_commit',
+        'expand_concept',
+    ]);
+    let operatorChain = Promise.resolve();
+    const runExclusive = (fn) => {
+        const result = operatorChain.then(fn, fn);
+        // Keep the chain alive regardless of this call's outcome.
+        operatorChain = result.then(() => undefined, () => undefined);
+        return result;
+    };
+    server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
         const tool = tools.find((t) => t.name === req.params.name);
         if (!tool) {
             return {
@@ -219,8 +234,39 @@ async function runServer() {
                 ],
             };
         }
+        // Heartbeat — emit progress notifications so MCP clients that honor them
+        // keep resetting their request timeout. Operator/LLM runs routinely exceed
+        // the 60s default, where the response would time out even though the work
+        // already committed (which also drove duplicate retries). No-op when the
+        // client supplied no progressToken.
+        const progressToken = req.params._meta?.progressToken;
+        let heartbeat;
+        if (progressToken !== undefined) {
+            let ticks = 0;
+            heartbeat = setInterval(() => {
+                ticks += 1;
+                try {
+                    void extra
+                        .sendNotification({
+                        method: 'notifications/progress',
+                        params: {
+                            progressToken,
+                            progress: ticks,
+                            message: `still working… (~${ticks * 15}s)`,
+                        },
+                    })
+                        .catch(() => { });
+                }
+                catch {
+                    /* a heartbeat failure must never break the call */
+                }
+            }, 15_000);
+        }
         try {
-            const result = await tool.handler(req.params.arguments ?? {});
+            const invoke = () => tool.handler(req.params.arguments ?? {});
+            const result = OPERATOR_TOOLS.has(tool.name)
+                ? await runExclusive(invoke)
+                : await invoke();
             const text = JSON.stringify(result, null, 2);
             if (text.length > MAX_RESULT_CHARS) {
                 return {
@@ -246,6 +292,10 @@ async function runServer() {
                 content: [{ type: 'text', text: `Error: ${msg}` }],
             };
         }
+        finally {
+            if (heartbeat)
+                clearInterval(heartbeat);
+        }
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/zod-to-json-schema.js

@@ -59,6 +59,16 @@ function leafSchema(schema) {
         // Nested object — recurse via the public path.
         return zodToJsonSchema(cur);
     }
+    else if (cur instanceof z.ZodRecord) {
+        // Open-ended string→value map (e.g. an operator's `args`). It MUST declare
+        // type:object — otherwise MCP clients don't JSON-parse the value, they send
+        // it as a raw string, and the server's validator rejects it ("Expected
+        // object, received string"). That silently disabled every parameterized
+        // operator (run_operator / run_operator_and_commit: free-text angle,
+        // contradiction improving/worsening, combine combineWithIds).
+        out.type = 'object';
+        out.additionalProperties = true;
+    }
     else {
         // Unknown / unsupported — fall back to "any".
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heuresis/mcp",
-  "version": "1.0.0-rc.14",
+  "version": "1.0.0-rc.15",
   "mcpName": "io.github.ToremLabs/heuresis",
   "description": "Cloud-authenticated Model Context Protocol server for a Heuresis workspace. Logs into the user's Heuresis account and lets any MCP client (Claude Desktop, Claude Code, Cursor, custom agents) read and write the same workspace the webapp uses. 31 data tools, 3 operator tools (Branch/Matrix/C-K/ASIT/TRIZ/Free/Combine/Explore), and live Realtime change subscriptions.",
   "type": "module",