tachibot-mcp 2.9.0 → 2.10.0

package/dist/src/tools/grok-tools.js

@@ -12,6 +12,7 @@ import { getGrokApiKey, hasGrokApiKey } from "../utils/api-keys.js";
 import { stripFormatting } from "../utils/format-stripper.js";
 import { FORMAT_INSTRUCTION } from "../utils/format-constants.js";
 import { tryOpenRouterGateway, isGatewayEnabled } from "../utils/openrouter-gateway.js";
+import { withHeartbeat } from "../utils/streaming-helper.js";
 // Note: renderOutput is applied centrally in server.ts safeAddTool() - no need to import here
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -131,7 +132,7 @@ export const grokReasonTool = {
         context: z.string().optional().describe("Additional context for the problem"),
         useHeavy: z.boolean().optional().describe("Use expensive Grok 4 Heavy model ($3/$15) for complex tasks")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const { problem, approach = "first-principles", context, useHeavy } = args;
         const approachPrompts = {
             analytical: "Break down the problem systematically and analyze each component",
@@ -156,8 +157,10 @@ ${FORMAT_INSTRUCTION}`
         const model = useHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_1_FAST_REASONING;
         const maxTokens = useHeavy ? 100000 : 16384; // 100k for heavy, 16k for normal reasoning
         log?.info(`Using Grok model: ${model} for deep reasoning (max tokens: ${maxTokens}, cost: ${useHeavy ? 'expensive $3/$15' : 'cheap $0.20/$0.50'})`);
-        // Use llm-orchestration context - input may contain code patterns
-        return stripFormatting(await callGrok(messages, model, 0.7, maxTokens, true, 'llm-orchestration'));
+        // Use heartbeat to prevent MCP timeout during long reasoning operations
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGrok(messages, model, 0.7, maxTokens, true, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -174,7 +177,7 @@ export const grokCodeTool = {
         language: z.string().optional().describe("Programming language (e.g., 'typescript', 'python')"),
         requirements: z.string().optional().describe("Specific requirements or focus areas")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const { task, code, language, requirements } = args;
         const taskPrompts = {
             analyze: "Analyze this code for logic, structure, and potential issues",
@@ -198,8 +201,10 @@ ${FORMAT_INSTRUCTION}`
             }
         ];
         log?.info(`Using Grok 4.1 Fast Non-Reasoning (2M context, tool-calling optimized, $0.20/$0.50)`);
-        // Use code-analysis context - code content naturally contains patterns
-        return stripFormatting(await callGrok(messages, GrokModel.GROK_4_1_FAST, 0.2, 4000, true, 'code-analysis'));
+        // Use heartbeat to prevent MCP timeout
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_1_FAST, 0.2, 4000, true, 'code-analysis'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -215,7 +220,7 @@ export const grokDebugTool = {
         error: z.string().optional().describe("Error message or stack trace"),
         context: z.string().optional().describe("Additional context about the environment or conditions")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const { issue, code, error, context } = args;
         let prompt = `Debug this issue: ${issue}\n`;
         if (error) {
@@ -244,8 +249,10 @@ ${FORMAT_INSTRUCTION}`
             }
         ];
         log?.info(`Using Grok 4.1 Fast Non-Reasoning for debugging (tool-calling optimized, $0.20/$0.50)`);
-        // Use code-analysis context - debug content may contain error patterns
-        return stripFormatting(await callGrok(messages, GrokModel.GROK_4_1_FAST, 0.3, 3000, true, 'code-analysis'));
+        // Use heartbeat to prevent MCP timeout
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_1_FAST, 0.3, 3000, true, 'code-analysis'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -262,7 +269,7 @@ export const grokArchitectTool = {
             .optional()
             .describe("Expected scale - must be one of: small, medium, large, enterprise")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const { requirements, constraints, scale } = args;
         const messages = [
             {
@@ -279,8 +286,10 @@ ${FORMAT_INSTRUCTION}`
             }
         ];
         log?.info(`Using Grok 4.1 Fast Reasoning for architecture (latest model, $0.20/$0.50)`);
-        // Use llm-orchestration context - architecture content may contain technical patterns
-        return stripFormatting(await callGrok(messages, GrokModel.GROK_4_1_FAST_REASONING, 0.6, 4000, true, 'llm-orchestration'));
+        // Use heartbeat to prevent MCP timeout
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_1_FAST_REASONING, 0.6, 4000, true, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -296,7 +305,7 @@ export const grokBrainstormTool = {
         numIdeas: z.number().optional().describe("Number of ideas to generate (default: 5)"),
         forceHeavy: z.boolean().optional().describe("Use expensive Grok 4 Heavy model ($3/$15) for deeper creativity")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const { topic, constraints, numIdeas = 5, forceHeavy = false } = args; // Changed: Default to cheap model
         const messages = [
             {
@@ -313,8 +322,10 @@ ${FORMAT_INSTRUCTION}`
         // Use GROK_4_1_FAST_REASONING for creative brainstorming (needs reasoning for creativity), GROK_4_HEAVY only if explicitly requested
         const model = forceHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_1_FAST_REASONING;
         log?.info(`Brainstorming with Grok model: ${model} (Heavy: ${forceHeavy}, cost: ${forceHeavy ? 'expensive $3/$15' : 'cheap $0.20/$0.50 - latest 4.1'})`);
-        // Use llm-orchestration context - brainstorm content may contain LLM-generated patterns
-        return stripFormatting(await callGrok(messages, model, 0.95, 4000, true, 'llm-orchestration')); // High temperature for creativity
+        // Use heartbeat to prevent MCP timeout
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGrok(messages, model, 0.95, 4000, true, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**

package/dist/src/tools/openai-tools.js

@@ -12,6 +12,7 @@ import { tryOpenRouterGateway, isGatewayEnabled } from "../utils/openrouter-gate
 import { OPENAI_MODELS } from "../config/model-constants.js";
 import { FORMAT_INSTRUCTION } from "../utils/format-constants.js";
 import { stripFormatting } from "../utils/format-stripper.js";
+import { withHeartbeat } from "../utils/streaming-helper.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 config({ path: path.resolve(__dirname, '../../../.env') });
@@ -476,7 +477,7 @@ export const openaiGpt5ReasonTool = {
             .default("analytical")
             .describe("Reasoning mode - must be one of: mathematical, scientific, logical, analytical")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const modePrompts = {
             mathematical: "Focus on mathematical proofs, calculations, and formal logic",
             scientific: "Apply scientific method and empirical reasoning",
@@ -497,8 +498,9 @@ ${FORMAT_INSTRUCTION}`
                 content: args.query
             }
         ];
-        // Use GPT-5.2-thinking with high reasoning effort for complex reasoning
-        return await callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.7, 4000, "high");
+        // Use heartbeat to prevent MCP timeout during reasoning
+        const reportFn = reportProgress ?? (async () => { });
+        return await withHeartbeat(() => callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.7, 4000, "high"), reportFn);
     }
 };
 /**
@@ -565,7 +567,7 @@ export const openaiCodeReviewTool = {
             .optional()
             .describe("Focus areas - array of: security, performance, readability, bugs, best-practices")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const focusText = args.focusAreas
             ? `Focus especially on: ${args.focusAreas.join(', ')}`
             : "Review all aspects: security, performance, readability, bugs, and best practices";
@@ -584,7 +586,9 @@ ${FORMAT_INSTRUCTION}`
                 content: `Review this code:\n\`\`\`${args.language || ''}\n${args.code}\n\`\`\``
             }
         ];
-        return await callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.3, 4000, "medium");
+        // Use heartbeat to prevent MCP timeout
+        const reportFn = reportProgress ?? (async () => { });
+        return await withHeartbeat(() => callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.3, 4000, "medium"), reportFn);
     }
 };
 /**

package/dist/src/tools/openrouter-tools.js

@@ -5,6 +5,7 @@
 import { z } from "zod";
 import { FORMAT_INSTRUCTION } from "../utils/format-constants.js";
 import { stripFormatting } from "../utils/format-stripper.js";
+import { withHeartbeat } from "../utils/streaming-helper.js";
 // NOTE: dotenv is loaded in server.ts before any imports
 // No need to reload here - just read from process.env
 // OpenRouter API configuration
@@ -114,7 +115,7 @@ export const qwenCoderTool = {
         language: z.string().optional().describe("Programming language (e.g., 'typescript', 'python')"),
         useFree: z.boolean().optional().default(false).describe("Use free tier model instead of premium")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const taskPrompts = {
             generate: "Generate new code according to requirements",
             review: "Review code for quality, bugs, and improvements",
@@ -138,7 +139,9 @@ ${FORMAT_INSTRUCTION}`;
             { role: "user", content: userPrompt }
         ];
         const model = args.useFree === true ? OpenRouterModel.QWEN3_30B : OpenRouterModel.QWEN3_CODER;
-        return await callOpenRouter(messages, model, 0.2, 8000);
+        // Use heartbeat to prevent MCP timeout
+        const reportFn = reportProgress ?? (async () => { });
+        return await withHeartbeat(() => callOpenRouter(messages, model, 0.2, 8000), reportFn);
     }
 };
 /**
@@ -274,7 +277,7 @@ export const qwenAlgoTool = {
             .default("general")
             .describe("Analysis focus - must be one of: optimize, complexity, data-structure, memory, general")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const focusPrompts = {
             optimize: "Focus on performance optimization, bottlenecks, and algorithmic improvements.",
             complexity: "Focus on time/space complexity analysis (best, average, worst case).",
@@ -296,7 +299,9 @@ ${FORMAT_INSTRUCTION}`
                     : args.problem
             }
         ];
-        return await callOpenRouter(messages, OpenRouterModel.QWQ_32B, 0.3, 8000);
+        // Use heartbeat to prevent MCP timeout
+        const reportFn = reportProgress ?? (async () => { });
+        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.QWQ_32B, 0.3, 8000), reportFn);
     }
 };
 /**
@@ -355,7 +360,7 @@ export const kimiThinkingTool = {
             .describe("Reasoning approach - must be one of: step-by-step, analytical, creative, systematic"),
         maxSteps: z.number().optional().default(3).describe("Maximum reasoning steps (default: 3)")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const approachPrompts = {
             "step-by-step": "Break down the problem into clear steps and solve systematically",
             analytical: "Analyze the problem deeply, considering multiple perspectives and implications",
@@ -375,12 +380,13 @@ ${FORMAT_INSTRUCTION}`
                 content: args.problem
             }
         ];
-        // Optimized for speed: lower tokens (3k), temp (0.4), top_p (0.9), penalties to reduce verbosity
-        return await callOpenRouter(messages, OpenRouterModel.KIMI_K2_THINKING, 0.4, 3000, {
+        // Use heartbeat to prevent MCP timeout during reasoning
+        const reportFn = reportProgress ?? (async () => { });
+        return await withHeartbeat(() => callOpenRouter(messages, OpenRouterModel.KIMI_K2_THINKING, 0.4, 3000, {
             top_p: 0.9,
             presence_penalty: 0.1,
             frequency_penalty: 0.2
-        });
+        }), reportFn);
     }
 };
 /**

package/dist/src/utils/streaming-helper.js

@@ -0,0 +1,108 @@
+/**
+ * Streaming Helper - Progress Heartbeats for Long-Running MCP Tools
+ *
+ * Prevents MCP timeout (~60s) by sending periodic progress notifications.
+ * Uses standard MCP notifications/progress which should work with all clients.
+ */
+/**
+ * Create a heartbeat that sends progress notifications at regular intervals.
+ * Useful for keeping MCP connections alive during long-running operations.
+ */
+export function createHeartbeat(options) {
+    const { intervalMs = 5000, reportProgress, onError } = options;
+    let progress = 0;
+    let stopped = false;
+    const interval = setInterval(async () => {
+        if (stopped)
+            return;
+        // Increment progress, cap at 90% (leave room for completion)
+        progress = Math.min(progress + 10, 90);
+        try {
+            await reportProgress({ progress, total: 100 });
+        }
+        catch (error) {
+            // Client may have disconnected - stop heartbeat
+            if (onError && error instanceof Error) {
+                onError(error);
+            }
+            stopped = true;
+            clearInterval(interval);
+        }
+    }, intervalMs);
+    return {
+        stop: () => {
+            stopped = true;
+            clearInterval(interval);
+        },
+        complete: async () => {
+            stopped = true;
+            clearInterval(interval);
+            try {
+                await reportProgress({ progress: 100, total: 100 });
+            }
+            catch {
+                // Ignore completion errors - client may have disconnected
+            }
+        }
+    };
+}
+/**
+ * Execute a function with automatic progress heartbeats.
+ * Heartbeat starts immediately, stops when function completes (success or error).
+ *
+ * @example
+ * ```typescript
+ * const result = await withHeartbeat(
+ *   () => callExternalAPI(prompt),
+ *   context.reportProgress
+ * );
+ * ```
+ */
+export async function withHeartbeat(fn, reportProgress, intervalMs = 5000) {
+    const heartbeat = createHeartbeat({ intervalMs, reportProgress });
+    try {
+        const result = await fn();
+        await heartbeat.complete();
+        return result;
+    }
+    catch (error) {
+        heartbeat.stop();
+        throw error;
+    }
+}
+/**
+ * Wrapper for streaming API responses with heartbeat support.
+ * Sends progress while waiting for streaming response to complete.
+ *
+ * @param stream - AsyncIterable of chunks (e.g., from OpenAI streaming API)
+ * @param reportProgress - Progress reporter from MCP context
+ * @param onChunk - Optional callback for each chunk (for streamContent)
+ */
+export async function withStreamingHeartbeat(stream, reportProgress, onChunk) {
+    const heartbeat = createHeartbeat({ reportProgress });
+    const chunks = [];
+    try {
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+            if (onChunk) {
+                await onChunk(chunk);
+            }
+        }
+        await heartbeat.complete();
+        return chunks;
+    }
+    catch (error) {
+        heartbeat.stop();
+        throw error;
+    }
+}
+/**
+ * Check if reportProgress is available in the context.
+ * FastMCP always provides it, but this is a safety check.
+ */
+export function hasProgressSupport(context) {
+    return (typeof context === 'object' &&
+        context !== null &&
+        'reportProgress' in context &&
+        typeof context.reportProgress === 'function');
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "tachibot-mcp",
   "mcpName": "io.github.byPawel/tachibot-mcp",
   "displayName": "TachiBot MCP - Universal AI Orchestrator",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "type": "module",
   "main": "dist/src/server.js",
   "bin": {