@intangle/mcp-server 2.3.9 → 2.5.0

package/dist/index.js

@@ -90,7 +90,9 @@ try {
             }
         }
     }
-    async function makeApiCall(endpoint, data) {
+    // Default timeout for API calls (90 seconds)
+    const API_TIMEOUT_MS = 90_000;
+    async function makeApiCall(endpoint, data, timeoutMs) {
         // Ensure we have client info before making requests
         ensureClientInfo();
         // Build headers with client info if available
@@ -108,15 +110,31 @@ try {
         if (mcpClientVersion) {
             headers["X-MCP-Client-Version"] = mcpClientVersion;
         }
-        const response = await fetch(`${API_BASE_URL}/api/mcp/${endpoint}`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(data),
-        });
-        if (!response.ok) {
-            throw new Error(`API call failed: ${response.status} ${response.statusText}`);
+        // Apply timeout to prevent hanging requests
+        const controller = new AbortController();
+        const effectiveTimeout = timeoutMs || API_TIMEOUT_MS;
+        const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
+        try {
+            const response = await fetch(`${API_BASE_URL}/api/mcp/${endpoint}`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(data),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`API call failed: ${response.status} ${response.statusText}`);
+            }
+            return response.json();
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`API call to ${endpoint} timed out after ${effectiveTimeout / 1000}s`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
         }
-        return response.json();
     }
     const server = new Server({
         name: "intangle-context",
@@ -185,17 +203,41 @@ try {
         if (!args.add && !args.update && !args.delete && !args.link && !args.unlink) {
             throw new Error("At least one operation must be provided");
         }
+        // Ensure all add items have a type field to prevent classification timeout
+        const add = args.add;
+        if (add?.items && Array.isArray(add.items)) {
+            for (const item of add.items) {
+                if (!item.type) {
+                    log(`WARNING: Item "${item.title}" missing type field, defaulting to "context" to prevent classification timeout`);
+                    item.type = "context";
+                }
+            }
+        }
         // Pass through to API with new structure
         return makeApiCall("update-memory", {
             space_id: args.space_id,
             project_id: args.project_id,
-            add: args.add,
+            add,
             update: args.update,
             delete: args.delete,
             link: args.link,
             unlink: args.unlink,
         });
     }
+    async function handleMessage(args) {
+        if (!args.type || !args.content) {
+            throw new Error("type and content are required");
+        }
+        // Inject session_id from environment variable
+        const sessionId = process.env.INTANGLE_SESSION_ID;
+        if (!sessionId) {
+            throw new Error("INTANGLE_SESSION_ID environment variable is required for the message tool");
+        }
+        return makeApiCall("message", {
+            ...args,
+            session_id: sessionId,
+        });
+    }
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         try {
@@ -228,6 +270,9 @@ try {
                 case "update_space":
                     result = await handleUpdateSpace(args);
                     break;
+                case "message":
+                    result = await handleMessage(args);
+                    break;
                 default:
                     throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
             }

package/dist/tool-definitions.js

@@ -302,6 +302,44 @@ export const TOOLS = [
             required: ["space_id"]
         }
     },
+    {
+        name: "message",
+        title: "Send Message",
+        description: "Send a message to the Intangle assistant for user interaction. Use type 'approval' to request approval (blocks until user responds), 'question' to ask the user a question (blocks until answered), 'notification' for informational updates (returns immediately), 'completion' to signal task completion (returns immediately), or 'error' to report errors (returns immediately).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["approval", "question", "notification", "completion", "error"],
+                    description: "Message type. 'approval' and 'question' block until the user responds. 'notification', 'completion', and 'error' return immediately."
+                },
+                content: {
+                    type: "string",
+                    description: "The message content to display to the user"
+                },
+                metadata: {
+                    type: "object",
+                    description: "Optional context about the message",
+                    properties: {
+                        file: {
+                            type: "string",
+                            description: "Related file path"
+                        },
+                        action: {
+                            type: "string",
+                            description: "Action being performed"
+                        },
+                        details: {
+                            type: "string",
+                            description: "Additional details"
+                        }
+                    }
+                }
+            },
+            required: ["type", "content"]
+        }
+    },
     // DISABLED: memory_action tool is broken and causing errors.
     // Pending OHM protocol fix. Use update_space, search, or fetch_items instead.
     // {

package/index.ts

@@ -118,7 +118,10 @@ try {
     }
   }
 
-  async function makeApiCall(endpoint: string, data: any) {
+  // Default timeout for API calls (90 seconds)
+  const API_TIMEOUT_MS = 90_000
+
+  async function makeApiCall(endpoint: string, data: any, timeoutMs?: number) {
     // Ensure we have client info before making requests
     ensureClientInfo()
 
@@ -139,19 +142,36 @@ try {
       headers["X-MCP-Client-Version"] = mcpClientVersion
     }
 
-    const response = await fetch(`${API_BASE_URL}/api/mcp/${endpoint}`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(data),
-    })
+    // Apply timeout to prevent hanging requests
+    const controller = new AbortController()
+    const effectiveTimeout = timeoutMs || API_TIMEOUT_MS
+    const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout)
 
-    if (!response.ok) {
-      throw new Error(
-        `API call failed: ${response.status} ${response.statusText}`
-      )
-    }
+    try {
+      const response = await fetch(`${API_BASE_URL}/api/mcp/${endpoint}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data),
+        signal: controller.signal as AbortSignal,
+      })
+
+      if (!response.ok) {
+        throw new Error(
+          `API call failed: ${response.status} ${response.statusText}`
+        )
+      }
 
-    return response.json()
+      return response.json()
+    } catch (error: unknown) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(
+          `API call to ${endpoint} timed out after ${effectiveTimeout / 1000}s`
+        )
+      }
+      throw error
+    } finally {
+      clearTimeout(timeoutId)
+    }
   }
 
   const server = new Server(
@@ -258,11 +278,22 @@ try {
       )
     }
 
+    // Ensure all add items have a type field to prevent classification timeout
+    const add = args.add
+    if (add?.items && Array.isArray(add.items)) {
+      for (const item of add.items) {
+        if (!item.type) {
+          log(`WARNING: Item "${item.title}" missing type field, defaulting to "context" to prevent classification timeout`)
+          item.type = "context"
+        }
+      }
+    }
+
     // Pass through to API with new structure
     return makeApiCall("update-memory", {
       space_id: args.space_id,
       project_id: args.project_id,
-      add: args.add,
+      add,
       update: args.update,
       delete: args.delete,
       link: args.link,
@@ -270,6 +301,25 @@ try {
     })
   }
 
+  async function handleMessage(args: any) {
+    if (!args.type || !args.content) {
+      throw new Error("type and content are required")
+    }
+
+    // Inject session_id from environment variable
+    const sessionId = process.env.INTANGLE_SESSION_ID
+    if (!sessionId) {
+      throw new Error(
+        "INTANGLE_SESSION_ID environment variable is required for the message tool"
+      )
+    }
+
+    return makeApiCall("message", {
+      ...args,
+      session_id: sessionId,
+    })
+  }
+
   server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
     const { name, arguments: args } = request.params
 
@@ -304,6 +354,9 @@ try {
         case "update_space":
           result = await handleUpdateSpace(args)
           break
+        case "message":
+          result = await handleMessage(args)
+          break
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
       }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@intangle/mcp-server",
-	"version": "2.3.9",
+	"version": "2.5.0",
 	"description": "Model Context Protocol server for Intangle - AI context that persists across conversations",
 	"main": "dist/index.js",
 	"type": "module",

package/tool-definitions.ts

@@ -341,6 +341,46 @@ export const TOOLS = [
       required: ["space_id"]
     }
   },
+  {
+    name: "message",
+    title: "Send Message",
+    description:
+      "Send a message to the Intangle assistant for user interaction. Use type 'approval' to request approval (blocks until user responds), 'question' to ask the user a question (blocks until answered), 'notification' for informational updates (returns immediately), 'completion' to signal task completion (returns immediately), or 'error' to report errors (returns immediately).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["approval", "question", "notification", "completion", "error"],
+          description:
+            "Message type. 'approval' and 'question' block until the user responds. 'notification', 'completion', and 'error' return immediately."
+        },
+        content: {
+          type: "string",
+          description: "The message content to display to the user"
+        },
+        metadata: {
+          type: "object",
+          description: "Optional context about the message",
+          properties: {
+            file: {
+              type: "string",
+              description: "Related file path"
+            },
+            action: {
+              type: "string",
+              description: "Action being performed"
+            },
+            details: {
+              type: "string",
+              description: "Additional details"
+            }
+          }
+        }
+      },
+      required: ["type", "content"]
+    }
+  },
   // DISABLED: memory_action tool is broken and causing errors.
   // Pending OHM protocol fix. Use update_space, search, or fetch_items instead.
   // {