tachibot-mcp 2.9.0 → 2.10.1

package/dist/src/prompt-engineer-lite.js

@@ -29,7 +29,15 @@ export class PromptEngineerLite {
             ['meta_prompting', (q) => `First, write a better prompt for "${q}" that would get a more useful response. Then, answer using that improved prompt.`],
             // Debate
             ['adversarial', (q) => `For "${q}": First argue strongly FOR this position with best evidence. Then argue strongly AGAINST with counterarguments. Finally, synthesize a balanced view.`],
-            ['persona_simulation', (q) => `Simulate expert debate on "${q}": Have a skeptic raise concerns, an optimist highlight benefits, a pragmatist focus on implementation, and a visionary explore possibilities. Synthesize insights.`]
+            ['persona_simulation', (q) => `Simulate expert debate on "${q}": Have a skeptic raise concerns, an optimist highlight benefits, a pragmatist focus on implementation, and a visionary explore possibilities. Synthesize insights.`],
+            // Judgment (Council of Experts)
+            ['council_of_experts', (q) => `Multi-model council analysis for "${q}":
+1. GATHER PERSPECTIVES: Consider this from multiple expert angles (researcher, engineer, skeptic, innovator)
+2. EXTRACT BEST ELEMENTS: What's the most valuable insight from each perspective?
+3. IDENTIFY CONSENSUS: Where do all perspectives agree?
+4. RESOLVE CONFLICTS: Where perspectives differ, weigh the tradeoffs
+5. SYNTHESIZE VERDICT: Combine the best elements into a unified, actionable answer
+Output format: Perspectives → Best Elements → Consensus → Conflicts → Final Synthesis`]
         ]);
         // Compact technique mapping (aliases to canonical names)
         this.techniqueMap = {
@@ -65,7 +73,11 @@ export class PromptEngineerLite {
             'principles': 'constitutional',
             'improve_prompt': 'meta_prompting',
             'critic': 'adversarial',
-            'debate': 'persona_simulation'
+            'debate': 'persona_simulation',
+            // Judgment aliases
+            'judge': 'council_of_experts',
+            'council': 'council_of_experts',
+            'expert_council': 'council_of_experts'
         };
     }
     applyTechnique(tool, technique, query, prev) {
@@ -118,7 +130,9 @@ export class PromptEngineerLite {
             'meta_prompting': 'Improve prompt',
             // Debate
             'adversarial': 'Pro/Con',
-            'persona_simulation': 'Expert debate'
+            'persona_simulation': 'Expert debate',
+            // Judgment
+            'council_of_experts': 'Council judge'
         };
         const key = this.techniqueMap[technique] || technique;
         return desc[key] || technique;

package/dist/src/server.js

@@ -144,19 +144,27 @@ function safeAddTool(tool) {
                     }
                 }
                 // Apply ANSI rendering to string results (centralized - no need to edit each tool!)
-                // Just render everything - the ~50-100ms for large outputs is fine for CLI
+                // Return as TextContent for Claude Code Desktop compatibility
+                // Plain strings work in CLI but Desktop needs { type: "text", text: "..." }
                 if (typeof result === 'string') {
                     try {
                         const model = inferModelFromTool(tool.name);
                         // Tools returning null handle their own rendering - skip extra badge
                         // (e.g., nextThought renders its own BigText header)
+                        let renderedText;
                         if (model === null) {
-                            return renderOutput(result); // No model badge
+                            renderedText = renderOutput(result); // No model badge
                         }
-                        return renderOutput(result, model);
+                        else {
+                            renderedText = renderOutput(result, model);
+                        }
+                        // Return as TextContent object for Claude Code Desktop compatibility
+                        // Adds ~12 tokens fixed overhead, negligible for typical responses
+                        return { type: "text", text: renderedText };
                     }
                     catch {
-                        return result; // Fallback to raw only on parse errors
+                        // Fallback to TextContent with raw result on parse errors
+                        return { type: "text", text: result };
                     }
                 }
                 return result;

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

@@ -9,6 +9,7 @@ import { GEMINI_MODELS } from "../config/model-constants.js";
 import { tryOpenRouterGateway, isGatewayEnabled } from "../utils/openrouter-gateway.js";
 import { stripFormatting } from "../utils/format-stripper.js";
 import { FORMAT_INSTRUCTION } from "../utils/format-constants.js";
+import { withHeartbeat } from "../utils/streaming-helper.js";
 // Note: renderOutput is applied centrally in server.ts safeAddTool() - no need to import here
 // NOTE: dotenv is loaded in server.ts before any imports
 // No need to reload here - just read from process.env
@@ -163,7 +164,7 @@ export const geminiQueryTool = {
             .default("gemini-3")
             .describe("Model variant - must be one of: gemini-3 (default), pro, flash")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         let model = GEMINI_MODELS.GEMINI_3_PRO; // Default to Gemini 3
         if (args.model === "flash") {
             model = GEMINI_MODELS.FLASH;
@@ -172,7 +173,9 @@ export const geminiQueryTool = {
             model = GEMINI_MODELS.PRO;
         }
         // Skip validation - queries may contain code or LLM-generated content
-        return stripFormatting(await callGemini(args.prompt, model, undefined, 0.7, 'llm-orchestration'));
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGemini(args.prompt, model, undefined, 0.7, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -190,13 +193,14 @@ export const geminiBrainstormTool = {
         claudeThoughts: z.string().optional().describe("Claude's initial thoughts to build upon"),
         maxRounds: z.number().optional().default(1).describe("Number of brainstorming rounds (default: 1)")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const systemPrompt = `Creative brainstorming partner.
 ${args.claudeThoughts ? `Building on: ${args.claudeThoughts}` : ''}
 Generate: multiple approaches, unconventional ideas, challenges, feasibility.
 ${FORMAT_INSTRUCTION}`;
         // Skip validation for internal calls - input validated at MCP layer
-        const response = await callGemini(args.prompt, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.9, 'llm-orchestration');
+        const reportFn = reportProgress ?? (async () => { });
+        const response = await withHeartbeat(() => callGemini(args.prompt, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.9, 'llm-orchestration'), reportFn);
         // If multiple rounds requested, we could iterate here
         // For now, return the single response
         return stripFormatting(response);
@@ -212,9 +216,9 @@ export const geminiAnalyzeCodeTool = {
     parameters: z.object({
         code: z.string().describe("The actual source code to analyze (REQUIRED - put your code here)"),
         language: z.string().optional().describe("Programming language (e.g., 'typescript', 'python')"),
-        focus: z.enum(["quality", "security", "performance", "bugs", "general"]).optional().default("general").describe("Analysis focus area - must be one of: quality, security, performance, bugs, general")
+        focus: z.string().optional().default("general").describe("Analysis focus (e.g., quality, security, performance, bugs, general)")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const focusPrompts = {
             quality: "Focus on code quality, readability, and best practices",
             security: "Focus on security vulnerabilities and potential exploits",
@@ -222,12 +226,14 @@ export const geminiAnalyzeCodeTool = {
             bugs: "Focus on finding bugs, logic errors, and edge cases",
             general: "Provide a comprehensive analysis covering all aspects"
         };
+        const focusText = focusPrompts[args.focus || 'general'] || `Focus on: ${args.focus}`;
         const systemPrompt = `Expert code reviewer. ${args.language || ''} code.
-${focusPrompts[args.focus || 'general']}.
+${focusText}.
 ${FORMAT_INSTRUCTION}`;
         // Skip validation - code analysis naturally contains patterns that trigger false positives
-        return stripFormatting(await callGemini(`Analyze this code:\n\n\`\`\`${args.language || ''}\n${args.code}\n\`\`\``, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.3, 'llm-orchestration' // skipValidation for code content
-        ));
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGemini(`Analyze this code:\n\n\`\`\`${args.language || ''}\n${args.code}\n\`\`\``, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.3, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -239,12 +245,12 @@ export const geminiAnalyzeTextTool = {
     description: "Text analysis. Put the TEXT in the 'text' parameter, NOT in 'type'.",
     parameters: z.object({
         text: z.string().describe("The text to analyze (REQUIRED - put your text here)"),
-        type: z.enum(["sentiment", "summary", "entities", "key-points", "general"])
+        type: z.string()
             .optional()
             .default("general")
-            .describe("Analysis type - must be one of: sentiment, summary, entities, key-points, general")
+            .describe("Analysis type (e.g., sentiment, summary, entities, key-points, general)")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const analysisPrompts = {
             sentiment: "Analyze the sentiment (positive, negative, neutral) with confidence scores",
             summary: "Provide a concise summary of the main points",
@@ -252,11 +258,13 @@ export const geminiAnalyzeTextTool = {
             "key-points": "Identify and list the key points and main arguments",
             general: "Provide comprehensive text analysis including sentiment, key points, and entities"
         };
-        const systemPrompt = `Text analysis expert. ${analysisPrompts[args.type || 'general']}.
+        const analysisText = analysisPrompts[args.type || 'general'] || `Perform ${args.type} analysis`;
+        const systemPrompt = `Text analysis expert. ${analysisText}.
 ${FORMAT_INSTRUCTION}`;
         // Skip validation - text analysis may contain patterns from LLM discussions
-        return stripFormatting(await callGemini(`Analyze this text:\n\n${args.text}`, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.3, 'llm-orchestration' // skipValidation for internal calls
-        ));
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGemini(`Analyze this text:\n\n${args.text}`, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.3, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -277,7 +285,7 @@ export const geminiSummarizeTool = {
             .default("paragraph")
             .describe("Output format - must be one of: paragraph, bullet-points, outline")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const lengthGuides = {
             brief: "1-2 sentences capturing the essence",
             moderate: "1-2 paragraphs with main points",
@@ -297,8 +305,9 @@ Focus on:
 - Conclusions and implications
 ${FORMAT_INSTRUCTION}`;
         // Skip validation for internal summarization calls
-        return stripFormatting(await callGemini(`Summarize this content:\n\n${args.content}`, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.3, 'llm-orchestration' // skipValidation
-        ));
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGemini(`Summarize this content:\n\n${args.content}`, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.3, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -314,7 +323,7 @@ export const geminiImagePromptTool = {
         mood: z.string().optional().describe("Mood or atmosphere (e.g., 'serene', 'dramatic')"),
         details: z.string().optional().describe("Additional details to include")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const systemPrompt = `You are an expert at creating detailed image generation prompts.
 Transform the user's description into a detailed, effective prompt for image generation.
 
@@ -333,7 +342,9 @@ ${args.style ? `Style: ${args.style}` : ''}
 ${args.mood ? `Mood: ${args.mood}` : ''}
 ${args.details ? `Additional details: ${args.details}` : ''}`;
         // Skip validation for creative content generation
-        return stripFormatting(await callGemini(userPrompt, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.7, 'llm-orchestration'));
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callGemini(userPrompt, GEMINI_MODELS.GEMINI_3_PRO, systemPrompt, 0.7, 'llm-orchestration'), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -353,7 +364,7 @@ export const geminiSearchTool = {
         dynamicThreshold: z.number().min(0).max(1).optional().default(0.7)
             .describe("Confidence threshold for dynamic mode (0-1)")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         if (!GEMINI_API_KEY) {
             return `[Gemini API key not configured. Add GOOGLE_API_KEY to .env file]`;
         }

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);
@@ -125,13 +126,13 @@ export const grokReasonTool = {
     description: "Deep reasoning. Put your PROBLEM or QUESTION in the 'problem' parameter.",
     parameters: z.object({
         problem: z.string().describe("The problem or question to reason about (REQUIRED - put your question here)"),
-        approach: z.enum(["analytical", "creative", "systematic", "first-principles"])
+        approach: z.string()
             .optional()
-            .describe("Reasoning approach - must be one of: analytical, creative, systematic, first-principles"),
+            .describe("Reasoning approach (e.g., analytical, creative, systematic, first-principles)"),
         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);
     }
 };
 /**
@@ -168,13 +171,13 @@ export const grokCodeTool = {
     name: "grok_code",
     description: "Code analysis. Put the CODE in the 'code' parameter, NOT in 'task'.",
     parameters: z.object({
-        task: z.enum(["analyze", "optimize", "debug", "review", "refactor"])
-            .describe("Code task - must be one of: analyze, optimize, debug, review, refactor"),
+        task: z.string()
+            .describe("Code task (e.g., analyze, optimize, debug, review, refactor)"),
         code: z.string().describe("The actual source code to analyze (REQUIRED - put your code here)"),
         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);
     }
 };
 /**
@@ -258,11 +265,11 @@ export const grokArchitectTool = {
     parameters: z.object({
         requirements: z.string().describe("The architecture requirements or design question (REQUIRED - put your question here)"),
         constraints: z.string().optional().describe("Technical or business constraints to consider"),
-        scale: z.enum(["small", "medium", "large", "enterprise"])
+        scale: z.string()
             .optional()
-            .describe("Expected scale - must be one of: small, medium, large, enterprise")
+            .describe("Expected scale (e.g., 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') });
@@ -471,12 +472,12 @@ export const openaiGpt5ReasonTool = {
     parameters: z.object({
         query: z.string().describe("The question or problem to reason about (REQUIRED - put your question here)"),
         context: z.string().optional().describe("Additional context for the reasoning task"),
-        mode: z.enum(["mathematical", "scientific", "logical", "analytical"])
+        mode: z.string()
             .optional()
             .default("analytical")
-            .describe("Reasoning mode - must be one of: mathematical, scientific, logical, analytical")
+            .describe("Reasoning mode (e.g., 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);
     }
 };
 /**
@@ -512,9 +514,9 @@ export const openAIBrainstormTool = {
         problem: z.string().describe("The problem or topic to brainstorm about (REQUIRED - put your question here)"),
         constraints: z.string().optional().describe("Any constraints to consider in brainstorming"),
         quantity: z.number().optional().describe("Number of ideas to generate (default: 5)"),
-        style: z.enum(["innovative", "practical", "wild", "systematic"])
+        style: z.string()
             .optional()
-            .describe("Brainstorming style - must be one of: innovative, practical, wild, systematic"),
+            .describe("Brainstorming style (e.g., innovative, practical, wild, systematic)"),
         model: z.enum(["gpt-5.2", "gpt-5.2-pro"])
             .optional()
             .describe("Model to use - gpt-5.2 (default) or gpt-5.2-pro (more expensive)"),
@@ -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);
     }
 };
 /**
@@ -151,10 +154,10 @@ export const qwqReasoningTool = {
     parameters: z.object({
         problem: z.string().describe("The problem to reason about (REQUIRED - put your question here)"),
         context: z.string().optional().describe("Additional context for the reasoning task"),
-        approach: z.enum(["step-by-step", "mathematical", "logical", "creative"])
+        approach: z.string()
             .optional()
             .default("step-by-step")
-            .describe("Reasoning approach - must be one of: step-by-step, mathematical, logical, creative"),
+            .describe("Reasoning approach (e.g., step-by-step, mathematical, logical, creative)"),
         useFree: z.boolean().optional().default(true).describe("Use free tier model (default: true)")
     }),
     execute: async (args, { log }) => {
@@ -191,10 +194,10 @@ export const qwenGeneralTool = {
     description: "General-purpose assistance with Qwen3. Put your QUERY in the 'query' parameter.",
     parameters: z.object({
         query: z.string().describe("Your question or request (REQUIRED - put your question here)"),
-        mode: z.enum(["chat", "analysis", "creative", "technical"])
+        mode: z.string()
             .optional()
             .default("chat")
-            .describe("Interaction mode - must be one of: chat, analysis, creative, technical"),
+            .describe("Interaction mode (e.g., chat, analysis, creative, technical)"),
         useFree: z.boolean().optional().default(true).describe("Use free tier model (default: true)")
     }),
     execute: async (args, { log }) => {
@@ -269,12 +272,12 @@ export const qwenAlgoTool = {
     parameters: z.object({
         problem: z.string().describe("The algorithm problem or code to analyze (REQUIRED - put your question/code here)"),
         context: z.string().optional().describe("Additional context: current performance, constraints"),
-        focus: z.enum(["optimize", "complexity", "data-structure", "memory", "general"])
+        focus: z.string()
             .optional()
             .default("general")
-            .describe("Analysis focus - must be one of: optimize, complexity, data-structure, memory, general")
+            .describe("Analysis focus (e.g., optimize, complexity, data-structure, memory, correctness, 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);
     }
 };
 /**
@@ -349,13 +354,13 @@ export const kimiThinkingTool = {
     parameters: z.object({
         problem: z.string().describe("The problem to reason about (REQUIRED - put your question here)"),
         context: z.string().optional().describe("Additional context for the reasoning task"),
-        approach: z.enum(["step-by-step", "analytical", "creative", "systematic"])
+        approach: z.string()
             .optional()
             .default("step-by-step")
-            .describe("Reasoning approach - must be one of: step-by-step, analytical, creative, systematic"),
+            .describe("Reasoning approach (e.g., 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/tools/perplexity-tools.js

@@ -7,6 +7,7 @@ import { z } from "zod";
 import { getPerplexityApiKey } from "../utils/api-keys.js";
 import { stripFormatting } from "../utils/format-stripper.js";
 import { FORMAT_INSTRUCTION } from "../utils/format-constants.js";
+import { withHeartbeat } from "../utils/streaming-helper.js";
 // Perplexity API configuration
 const PERPLEXITY_API_URL = "https://api.perplexity.ai";
 // Available Perplexity models (2025 latest)
@@ -14,7 +15,7 @@ export var PerplexityModel;
 (function (PerplexityModel) {
     // Models from Perplexity API docs
     PerplexityModel["SONAR_PRO"] = "sonar";
-    PerplexityModel["SONAR_REASONING_PRO"] = "sonar-reasoning";
+    PerplexityModel["SONAR_REASONING_PRO"] = "sonar-reasoning-pro";
     PerplexityModel["SONAR_DEEP_RESEARCH"] = "sonar-deep-research";
     PerplexityModel["SONAR"] = "sonar";
     PerplexityModel["SONAR_SMALL"] = "sonar-small";
@@ -90,7 +91,7 @@ export const perplexityAskTool = {
             .optional()
             .describe("How recent the results should be - must be one of: hour, day, week, month, year")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         // Get current date for accurate recency context
         const now = new Date();
         const currentDate = now.toLocaleDateString('en-US', {
@@ -109,7 +110,9 @@ export const perplexityAskTool = {
                 content: args.query
             }
         ];
-        return stripFormatting(await callPerplexity(messages, PerplexityModel.SONAR_PRO, args.searchDomain, args.searchRecency));
+        const reportFn = reportProgress ?? (async () => { });
+        const result = await withHeartbeat(() => callPerplexity(messages, PerplexityModel.SONAR_PRO, args.searchDomain, args.searchRecency), reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -122,12 +125,13 @@ export const perplexityResearchTool = {
     parameters: z.object({
         topic: z.string().describe("The research topic (REQUIRED - put your topic here)"),
         questions: z.array(z.string()).optional().describe("Specific questions to research"),
-        depth: z.enum(["quick", "standard", "deep"])
+        depth: z.string()
             .optional()
-            .describe("Research depth - must be one of: quick, standard, deep")
+            .describe("Research depth (e.g., quick, standard, deep)")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const { topic, questions, depth = "standard" } = args;
+        const reportFn = reportProgress ?? (async () => { });
         // Get current date for accurate research context
         const now = new Date();
         const currentDate = now.toLocaleDateString('en-US', {
@@ -151,36 +155,40 @@ export const perplexityResearchTool = {
                     `What are the future predictions for ${topic}?`,
                     `What are the best practices and recommendations for ${topic}?`] :
                 researchQuestions;
-        let research = `# Research Report: ${topic}\n\n`;
-        // Conduct research for each question
-        for (const question of questionsToAsk) {
-            const messages = [
+        // Wrap entire research process in heartbeat since it makes multiple calls
+        const result = await withHeartbeat(async () => {
+            let research = `# Research Report: ${topic}\n\n`;
+            // Conduct research for each question
+            for (const question of questionsToAsk) {
+                const messages = [
+                    {
+                        role: "system",
+                        content: `Research expert. Today: ${currentDate}. Factual info with sources.${FORMAT_INSTRUCTION}`
+                    },
+                    {
+                        role: "user",
+                        content: question
+                    }
+                ];
+                const answer = await callPerplexity(messages, PerplexityModel.SONAR_PRO);
+                research += `## ${question}\n\n${answer}\n\n`;
+            }
+            // Add synthesis
+            const synthesisMessages = [
                 {
                     role: "system",
-                    content: `Research expert. Today: ${currentDate}. Factual info with sources.${FORMAT_INSTRUCTION}`
+                    content: `Research synthesizer. Concise summary of key findings.${FORMAT_INSTRUCTION}`
                 },
                 {
                     role: "user",
-                    content: question
+                    content: `Synthesize these research findings into key insights:\n\n${research}`
                 }
             ];
-            const answer = await callPerplexity(messages, PerplexityModel.SONAR_PRO);
-            research += `## ${question}\n\n${answer}\n\n`;
-        }
-        // Add synthesis
-        const synthesisMessages = [
-            {
-                role: "system",
-                content: `Research synthesizer. Concise summary of key findings.${FORMAT_INSTRUCTION}`
-            },
-            {
-                role: "user",
-                content: `Synthesize these research findings into key insights:\n\n${research}`
-            }
-        ];
-        const synthesis = await callPerplexity(synthesisMessages, PerplexityModel.SONAR_PRO);
-        research += `## Synthesis\n\n${synthesis}`;
-        return stripFormatting(research);
+            const synthesis = await callPerplexity(synthesisMessages, PerplexityModel.SONAR_PRO);
+            research += `## Synthesis\n\n${synthesis}`;
+            return research;
+        }, reportFn);
+        return stripFormatting(result);
     }
 };
 /**
@@ -193,12 +201,13 @@ export const perplexityReasonTool = {
     parameters: z.object({
         problem: z.string().describe("The problem to reason about (REQUIRED - put your question here)"),
         context: z.string().optional().describe("Additional context for the reasoning task"),
-        approach: z.enum(["analytical", "creative", "systematic", "comparative"])
+        approach: z.string()
             .optional()
-            .describe("Reasoning approach - must be one of: analytical, creative, systematic, comparative")
+            .describe("Reasoning approach (e.g., analytical, creative, systematic, comparative)")
     }),
-    execute: async (args, { log }) => {
+    execute: async (args, { log, reportProgress }) => {
         const { problem, context, approach = "analytical" } = args;
+        const reportFn = reportProgress ?? (async () => { });
         // Get current date for accurate reasoning context
         const now = new Date();
         const currentDate = now.toLocaleDateString('en-US', {
@@ -224,7 +233,8 @@ ${context ? `Context: ${context}` : ''}${FORMAT_INSTRUCTION}`
                 content: problem
             }
         ];
-        return stripFormatting(await callPerplexity(messages, PerplexityModel.SONAR_REASONING_PRO));
+        const result = await withHeartbeat(() => callPerplexity(messages, PerplexityModel.SONAR_REASONING_PRO), reportFn);
+        return stripFormatting(result);
     }
 };
 /**

package/dist/src/tools/prompt-technique-tools.js

@@ -109,6 +109,9 @@ const TECHNIQUES = {
         { name: "adversarial", alias: "critic", description: "Argue FOR then AGAINST, find counterarguments, synthesize" },
         { name: "persona_simulation", alias: "debate", description: "Simulate experts debating (single prompt, not real multi-agent)" },
     ],
+    judgment: [
+        { name: "council_of_experts", alias: "judge", description: "Multi-model council: gather diverse perspectives, extract best elements, synthesize final verdict" },
+    ],
 };
 // All technique names for validation
 const ALL_TECHNIQUE_NAMES = Object.values(TECHNIQUES)
@@ -128,9 +131,9 @@ function generateToken() {
  */
 export const listPromptTechniquesTool = {
     name: "list_prompt_techniques",
-    description: "Discover available prompt engineering techniques. Shows all 21 techniques organized by category.",
+    description: "Discover available prompt engineering techniques. Shows all 22 techniques organized by category.",
     parameters: z.object({
-        filter: z.enum(["all", "creative", "research", "analytical", "reflective", "reasoning", "verification", "meta", "debate"])
+        filter: z.enum(["all", "creative", "research", "analytical", "reflective", "reasoning", "verification", "meta", "debate", "judgment"])
             .optional()
             .default("all")
             .describe("Filter by category (default: all)")

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.1",
   "type": "module",
   "main": "dist/src/server.js",
   "bin": {