tachibot-mcp 2.0.6 → 2.1.0

package/dist/src/utils/api-keys.js

@@ -0,0 +1,20 @@
+/**
+ * Centralized API Key Resolution
+ * Single source of truth for all API key lookups (SRP)
+ */
+// Grok/xAI - supports both XAI_API_KEY (new) and GROK_API_KEY (legacy)
+export const getGrokApiKey = () => process.env.XAI_API_KEY || process.env.GROK_API_KEY;
+export const hasGrokApiKey = () => !!(process.env.XAI_API_KEY || process.env.GROK_API_KEY);
+// Other providers (single key each)
+export const getOpenAIApiKey = () => process.env.OPENAI_API_KEY;
+export const hasOpenAIApiKey = () => !!process.env.OPENAI_API_KEY;
+export const getPerplexityApiKey = () => process.env.PERPLEXITY_API_KEY;
+export const hasPerplexityApiKey = () => !!process.env.PERPLEXITY_API_KEY;
+export const getGeminiApiKey = () => process.env.GOOGLE_API_KEY;
+export const hasGeminiApiKey = () => !!process.env.GOOGLE_API_KEY;
+export const getOpenRouterApiKey = () => process.env.OPENROUTER_API_KEY;
+export const hasOpenRouterApiKey = () => !!process.env.OPENROUTER_API_KEY;
+export const getQwenApiKey = () => process.env.QWEN_API_KEY;
+export const hasQwenApiKey = () => !!process.env.QWEN_API_KEY;
+export const getDeepSeekApiKey = () => process.env.DEEPSEEK_API_KEY;
+export const hasDeepSeekApiKey = () => !!process.env.DEEPSEEK_API_KEY;

package/dist/src/utils/openrouter-gateway.js

@@ -0,0 +1,117 @@
+/**
+ * OpenRouter Gateway Utility
+ * Routes API calls through OpenRouter when USE_OPENROUTER_GATEWAY=true
+ */
+import { config } from 'dotenv';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+config({ path: path.resolve(__dirname, '../../../.env') });
+// Gateway configuration - NOT cached, read fresh each time
+const OPENROUTER_URL = 'https://openrouter.ai/api/v1/chat/completions';
+// Models that should NEVER use gateway (direct API only)
+const NO_GATEWAY_MODELS = new Set([
+    'sonar-pro',
+    'sonar-reasoning-pro',
+    'sonar',
+]);
+// Grok model mapping - our names → OpenRouter names
+const GROK_MODEL_MAP = {
+    'grok-4-1-fast-reasoning': 'x-ai/grok-4.1-fast',
+    'grok-4-1-fast-non-reasoning': 'x-ai/grok-4.1-fast',
+    'grok-4-fast-reasoning': 'x-ai/grok-4-fast',
+    'grok-4-fast-non-reasoning': 'x-ai/grok-4-fast',
+    'grok-code-fast-1': 'x-ai/grok-4-fast',
+    'grok-4-0709': 'x-ai/grok-4',
+    'grok-3': 'x-ai/grok-3',
+};
+/**
+ * Check if gateway mode is enabled
+ * Reads env vars fresh each time (not cached at module load)
+ */
+export function isGatewayEnabled() {
+    const enabled = process.env.USE_OPENROUTER_GATEWAY === 'true';
+    const hasKey = !!process.env.OPENROUTER_API_KEY;
+    return enabled && hasKey;
+}
+/**
+ * Map model name to OpenRouter format
+ * Returns null if model should skip gateway (use direct API)
+ */
+export function mapModelToOpenRouter(model) {
+    // Perplexity models - NEVER use gateway, direct API only
+    if (model.startsWith('sonar') || NO_GATEWAY_MODELS.has(model)) {
+        return null;
+    }
+    // Already has provider prefix (qwen/, moonshotai/, etc.) - pass through
+    if (model.includes('/')) {
+        return model;
+    }
+    // Grok models need explicit mapping (names differ from OpenRouter)
+    if (GROK_MODEL_MAP[model]) {
+        return GROK_MODEL_MAP[model];
+    }
+    // Add provider prefix based on model name
+    if (model.startsWith('gpt-')) {
+        return `openai/${model}`;
+    }
+    if (model.startsWith('gemini-')) {
+        return `google/${model}`;
+    }
+    if (model.startsWith('grok-')) {
+        return `x-ai/${model}`; // Fallback for unmapped grok models
+    }
+    // Unknown model - pass through as-is
+    return model;
+}
+/**
+ * Try to route request through OpenRouter gateway
+ * Returns response string if gateway used, null if gateway disabled/failed
+ */
+export async function tryOpenRouterGateway(model, messages, options = {}) {
+    // Check if gateway is enabled
+    if (!isGatewayEnabled()) {
+        return null;
+    }
+    // Map model - returns null if model should skip gateway
+    const mappedModel = mapModelToOpenRouter(model);
+    if (!mappedModel) {
+        return null; // Skip gateway, use direct API
+    }
+    console.error(`🔀 [OpenRouter Gateway] Routing ${model} → ${mappedModel}`);
+    try {
+        const response = await fetch(OPENROUTER_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${process.env.OPENROUTER_API_KEY}`,
+                'HTTP-Referer': 'https://tachibot-mcp.local',
+                'X-Title': 'TachiBot MCP Server'
+            },
+            body: JSON.stringify({
+                model: mappedModel,
+                messages,
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.max_tokens ?? 4000,
+                stream: false
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error(`🔀 [OpenRouter Gateway] Error: ${error}`);
+            return null; // Fall back to direct API
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content;
+        if (typeof content !== 'string') {
+            console.error('🔀 [OpenRouter Gateway] Invalid response format');
+            return null;
+        }
+        return content;
+    }
+    catch (error) {
+        console.error('🔀 [OpenRouter Gateway] Error:', error instanceof Error ? error.message : String(error));
+        return null; // Fall back to direct API
+    }
+}

package/dist/src/validators/interpolation-validator.js

@@ -117,6 +117,10 @@ export class InterpolationValidator {
         }
     }
     validateStringInterpolations(content, stepNames, variables, path, errors, currentStepIndex, stepOrder) {
+        // Safety check: return early if content is null/undefined
+        if (!content || typeof content !== 'string') {
+            return;
+        }
         const matches = content.matchAll(this.interpolationRegex);
         for (const match of matches) {
             const fullMatch = match[0]; // e.g., "${step1.output}"

package/dist/src/validators/tool-registry-validator.js

@@ -62,7 +62,7 @@ export class ToolRegistryValidator {
             // Grok
             'grok_reason', 'grok_code', 'grok_debug', 'grok_architect', 'grok_brainstorm', 'grok_search',
             // OpenAI
-            'openai_compare', 'openai_brainstorm', 'openai_gpt5_reason', 'openai_code_review', 'openai_explain',
+            'openai_brainstorm', 'openai_reason', 'openai_code_review', 'openai_explain',
             // Gemini
             'gemini_brainstorm', 'gemini_analyze_code', 'gemini_analyze_text',
             // Qwen

package/dist/src/validators/tool-types.js

@@ -29,7 +29,6 @@ export const KNOWN_TOOLS = [
     'openai_brainstorm',
     'openai_analyze',
     'openai_reason',
-    'openai_compare',
     'gpt5',
     'gpt5_mini',
     'gpt5_nano',

package/dist/src/workflows/custom-workflows.js

@@ -122,22 +122,23 @@ export class CustomWorkflowEngine {
                     {
                         name: "Gemini Ideas",
                         tool: "gemini_brainstorm",
+                        input: { prompt: "${query}" },
                         maxTokens: 500,
                     },
                     {
                         name: "GPT-5 Creative",
                         tool: "gpt5_mini",
-                        input: { prompt: "Build on previous ideas with creative twists" },
+                        input: { prompt: "Build on these ideas with creative twists for: ${query}\n\nPrevious ideas: ${Gemini Ideas.output}" },
                     },
                     {
                         name: "Perplexity Research",
                         tool: "perplexity_research",
-                        input: { prompt: "Find real-world examples and evidence" },
+                        input: { prompt: "Find real-world examples and evidence for: ${query}" },
                     },
                     {
                         name: "Final Synthesis",
                         tool: "focus",
-                        input: { prompt: "Combine all ideas into top 5 recommendations" },
+                        input: { prompt: "Synthesize all brainstorming results into top 5 creative recommendations for: ${query}\n\nIdeas to combine:\n${Gemini Ideas.output}\n${GPT-5 Creative.output}\n${Perplexity Research.output}" },
                     },
                 ],
             },

package/dist/src/workflows/engine/VariableInterpolator.js

@@ -18,6 +18,14 @@ export class VariableInterpolator {
      * Interpolates variables and step outputs in template strings
      */
     async interpolate(template, context) {
+        // Safety check: return empty string if template is null/undefined
+        if (template === null || template === undefined) {
+            return '';
+        }
+        // Ensure template is a string
+        if (typeof template !== 'string') {
+            return String(template);
+        }
         const mergedContext = {
             ...context.variables,
             ...Object.fromEntries(context.fileReferences)
@@ -76,14 +84,33 @@ export class VariableInterpolator {
                     return { match: fullMatch, replacement: filename };
                 }
                 else if (property === 'output') {
-                    // Handle ${step.output} by returning summary
-                    console.error(`✓ Interpolated '${key}': using summary (${value.summary.length} chars)`);
-                    return { match: fullMatch, replacement: value.summary };
+                    // Handle ${step.output} by returning FULL content (not summary!)
+                    // This is the primary interpolation method - must have complete output for chaining
+                    const content = await value.getContent();
+                    console.error(`✓ Interpolated '${key}': loaded full content (${content.length} chars)`);
+                    return { match: fullMatch, replacement: content };
                 }
                 else {
                     throw new Error(`Unknown FileReference property: ${property}`);
                 }
             }
+            // Handle objects that aren't FileReferences (convert to JSON or extract summary)
+            if (typeof value === 'object' && value !== null) {
+                // Check if it has a summary property (duck typing for FileReference-like objects)
+                if ('summary' in value && typeof value.summary === 'string') {
+                    console.error(`✓ Interpolated '${key}': using summary from object (${value.summary.length} chars)`);
+                    return { match: fullMatch, replacement: value.summary };
+                }
+                // Check if it has a content property
+                if ('content' in value && typeof value.content === 'string') {
+                    console.error(`✓ Interpolated '${key}': using content from object (${value.content.length} chars)`);
+                    return { match: fullMatch, replacement: value.content };
+                }
+                // Fallback: JSON stringify the object
+                const jsonStr = JSON.stringify(value, null, 2);
+                console.error(`✓ Interpolated '${key}': stringified object (${jsonStr.length} chars)`);
+                return { match: fullMatch, replacement: jsonStr };
+            }
             // Handle primitive values
             console.error(`✓ Interpolated '${key}': type=${typeof value}, length=${String(value).length}`);
             return { match: fullMatch, replacement: String(value) };

package/dist/src/workflows/engine/WorkflowExecutionEngine.js

@@ -137,7 +137,7 @@ async function executeWorkflowImpl(parent, workflowName, input, options) {
             console.error(`🔍 Available variables: [${Object.keys(variables).join(', ')}]`);
             console.error(`🔍 Available stepOutputs: [${Object.keys(stepOutputs).join(', ')}]`);
             // Extract variables that this step wants to use
-            const inputStr = JSON.stringify(step.input);
+            const inputStr = step.input ? JSON.stringify(step.input) : '';
             const usedVars = [...inputStr.matchAll(/\$\{([^}]+)\}/g)].map(m => m[1]);
             if (usedVars.length > 0) {
                 console.error(`🔍 Variables needed by this step: [${usedVars.join(', ')}]`);
@@ -210,7 +210,7 @@ async function executeWorkflowImpl(parent, workflowName, input, options) {
             if (workflow.settings?.optimization?.enabled && typeof stepInput === "string") {
                 const optimized = await tokenOptimizer.optimize({
                     prompt: stepInput,
-                    model: model || "gpt-5-mini",
+                    model: model || "gpt-5.1-codex-mini",
                     maxTokens: resolvedParams.maxTokens,
                 });
                 if (optimized.fromCache) {

package/dist/src/workflows/engine/WorkflowOutputFormatter.js

@@ -11,7 +11,8 @@ export class WorkflowOutputFormatter {
         const synthesisStep = execution.outputs.find(step => step.step === 'auto-synthesis');
         if (synthesisStep) {
             // Auto-synthesis ran - return only the synthesis output to prevent MCP 25k limit
-            return synthesisStep.output;
+            // DEFENSIVE: Ensure output is a string
+            return this.ensureString(synthesisStep.output);
         }
         switch (format) {
             case "json":
@@ -22,7 +23,7 @@ export class WorkflowOutputFormatter {
                     status: execution.status,
                     steps: execution.outputs.map(out => ({
                         step: out.step,
-                        summary: out.output,
+                        summary: this.ensureString(out.output),
                         filePath: out.filePath
                     }))
                 };
@@ -33,6 +34,28 @@ export class WorkflowOutputFormatter {
                 return this.formatSummary(execution);
         }
     }
+    /**
+     * Ensures a value is converted to a string (handles FileReference and objects)
+     */
+    ensureString(value) {
+        if (value === null || value === undefined) {
+            return '[No output]';
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value === 'object') {
+            // Handle FileReference objects - extract summary or content
+            if ('summary' in value && typeof value.summary === 'string') {
+                return value.summary;
+            }
+            if ('content' in value && typeof value.content === 'string') {
+                return value.content;
+            }
+            return JSON.stringify(value, null, 2);
+        }
+        return String(value);
+    }
     /**
      * Formats detailed output with all step information
      */
@@ -54,7 +77,7 @@ export class WorkflowOutputFormatter {
             if (step.input && step.input !== '[cached]') {
                 output += `**Input:**\n${step.input}...\n\n`;
             }
-            output += `${step.output}\n\n`;
+            output += `${this.ensureString(step.output)}\n\n`;
             if (step.filePath) {
                 output += `📄 *Full output saved to: ${step.filePath}*\n\n`;
             }
@@ -73,7 +96,7 @@ export class WorkflowOutputFormatter {
             .filter(out => out.filePath)
             .map(out => `  - ${out.step}: ${out.filePath}`)
             .join('\n');
-        let result = lastOutput?.output || "Workflow completed";
+        let result = lastOutput ? this.ensureString(lastOutput.output) : "Workflow completed";
         if (savedFiles) {
             result += `\n\n**Files saved:**\n${savedFiles}\n\n`;
             result += `Use Read tool to access full content for detailed analysis.`;

package/dist/src/workflows/fallback-strategies.js

@@ -60,9 +60,9 @@ export class FallbackStrategies {
             },
             execute: async (context) => {
                 return {
-                    alternativeTool: 'gpt-5-nano',
+                    alternativeTool: 'gpt5_mini',
                     fallbackUsed: 'cheaper-model',
-                    warning: 'Falling back to GPT-5 Nano for cost efficiency'
+                    warning: 'Falling back to gpt-5.1-codex-mini (cost-efficient coding model)'
                 };
             }
         });

package/dist/src/workflows/model-router.js

@@ -9,6 +9,15 @@ export class ModelRouter {
                     reasoning: 10,
                     useFor: ['primary reasoning', 'code', 'analysis']
                 }],
+            ['gemini-3-pro-preview', {
+                    id: 'gemini-3-pro-preview',
+                    cost: 10,
+                    quality: 10,
+                    speed: 8,
+                    reasoning: 10,
+                    context: '1M tokens',
+                    useFor: ['latest Gemini (Nov 2025)', 'enhanced structured outputs', 'multimodal', 'complex analysis']
+                }],
             ['gemini-2.5-pro', {
                     id: 'gemini-2.5-pro',
                     cost: 10,
@@ -43,20 +52,20 @@ export class ModelRouter {
                     reasoning: 10,
                     useFor: ['complex reasoning with evidence']
                 }],
-            ['grok-4.1', {
-                    id: 'grok-4.1',
+            ['grok-4-1-fast-reasoning', {
+                    id: 'grok-4-1-fast-reasoning',
                     cost: 9,
                     quality: 10,
                     speed: 7,
                     reasoning: 10,
                     useFor: ['enhanced reasoning', 'creativity', 'emotional intelligence', 'first-principles']
                 }],
-            ['grok-4.1-fast', {
-                    id: 'grok-4.1-fast',
+            ['grok-4-1-fast-non-reasoning', {
+                    id: 'grok-4-1-fast-non-reasoning',
                     cost: 9,
                     quality: 10,
-                    speed: 8,
-                    reasoning: 10,
+                    speed: 9,
+                    reasoning: 8,
                     useFor: ['tool-calling', 'agentic workflows', 'code analysis', 'fast reasoning']
                 }],
             ['grok-4', {
@@ -150,14 +159,14 @@ export class ModelRouter {
             return 'lmstudio-local';
         }
         const taskTypeMap = {
-            'code': task.complexity > 0.7 ? 'qwen3-coder-480b' : 'grok-4.1-fast',
+            'code': task.complexity > 0.7 ? 'qwen3-coder-480b' : 'grok-4-1-fast-non-reasoning',
             'research': 'perplexity-sonar-pro',
             'reasoning': task.complexity > 0.5 ? 'gpt5' : 'gpt5_mini',
             'scout': 'multi-model',
             'verifier': task.complexity > 0.5 ? 'gpt5' : 'gpt5_mini',
             'challenger': 'gpt5_mini',
             'auditor': 'perplexity-sonar-pro',
-            'architect': 'grok-4.1',
+            'architect': 'grok-4-1-fast-reasoning',
             'commit_guardian': 'gemini-2.5-flash'
         };
         return taskTypeMap[task.type] || this.selectByConstraints(task, constraints);
@@ -195,9 +204,9 @@ export class ModelRouter {
     selectModelsForVerification(variant) {
         const variants = {
             'quick_verify': ['gpt5_mini', 'gemini-2.5-flash', 'qwen3-30b'],
-            'deep_verify': ['gpt5', 'qwq-32b', 'gpt5_reason', 'gemini-2.5-pro', 'qwen3-coder-480b'],
-            'fact_check': ['perplexity-sonar-pro', 'gpt5', 'gemini-2.5-pro'],
-            'code_verify': ['qwen3-coder-480b', 'gpt5', 'gemini-2.5-pro'],
+            'deep_verify': ['gpt5', 'qwq-32b', 'gpt5_reason', 'gemini-3-pro-preview', 'qwen3-coder-480b'],
+            'fact_check': ['perplexity-sonar-pro', 'gpt5', 'gemini-3-pro-preview'],
+            'code_verify': ['qwen3-coder-480b', 'gpt5', 'gemini-3-pro-preview'],
             'security_verify': ['gpt5', 'qwen3-coder-480b', 'grok-4']
         };
         return variants[variant] || variants['quick_verify'];

package/dist/src/workflows/tool-mapper.js

@@ -2,12 +2,13 @@
  * Tool Mapper - Maps workflow tool names to actual MCP tool implementations
  * Enables workflows to call real tools instead of returning placeholders
  */
-import { callGemini, GeminiModel } from "../tools/gemini-tools.js";
+import { callGemini } from "../tools/gemini-tools.js";
 import { getAllPerplexityTools } from "../tools/perplexity-tools.js";
 import { callOpenAI } from "../tools/openai-tools.js";
 import { callGrok, GrokModel } from "../tools/grok-tools.js";
-import { GPT51_MODELS, TOOL_DEFAULTS, } from "../config/model-constants.js";
+import { OPENAI_MODELS, TOOL_DEFAULTS, GEMINI_MODELS, } from "../config/model-constants.js";
 import { validateToolInput } from "../utils/input-validator.js";
+import { hasGrokApiKey } from "../utils/api-keys.js";
 // Lazy load OpenRouter for Qwen models
 let callOpenRouter = null;
 let OpenRouterModel = null;
@@ -74,7 +75,8 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
         if (typeof input === "string")
             return input;
         // Try all common parameter names (order matters!)
-        return input.requirements || // qwen_coder, task-specific
+        return input.thought || // think tool reflection
+            input.requirements || // qwen_coder, task-specific
             input.problem || // brainstorm, reasoning tools
             input.query || // search/ask tools
             input.topic || // research tools
@@ -121,7 +123,7 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
         maxTokens: 2000,
         temperature: 0.7,
     };
-    const { model = ('model' in toolDefaults ? toolDefaults.model : GPT51_MODELS.CODEX_MINI), maxTokens = options.maxTokens ?? toolDefaults.maxTokens ?? 2000, temperature = options.temperature ?? toolDefaults.temperature ?? 0.7, systemPrompt, } = options;
+    const { model = ('model' in toolDefaults ? toolDefaults.model : OPENAI_MODELS.CODEX_MINI), maxTokens = options.maxTokens ?? toolDefaults.maxTokens ?? 2000, temperature = options.temperature ?? toolDefaults.temperature ?? 0.7, systemPrompt, } = options;
     // Helper to convert to messages array format
     const toMessages = (text, system) => {
         const messages = [];
@@ -144,7 +146,7 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
             case "gemini_brainstorm":
             case "gemini_analyze_code":
             case "gemini_analyze_text":
-                actualModel = model === "flash" ? GeminiModel.FLASH : GeminiModel.PRO;
+                actualModel = model === "flash" ? GEMINI_MODELS.FLASH : GEMINI_MODELS.GEMINI_3_PRO;
                 return buildResult(await callGemini(prompt, actualModel, systemPrompt, temperature, options.skipValidation || false), actualModel);
             // ============ PERPLEXITY TOOLS ============
             case "perplexity_ask":
@@ -205,30 +207,55 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
             // ============ OPENAI TOOLS ============
             case "openai_brainstorm":
             case "openai_analyze":
-                actualModel = (model || GPT51_MODELS.FULL);
+                actualModel = (model || OPENAI_MODELS.FULL);
                 return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), actualModel, temperature, maxTokens, "low", // reasoningEffort
                 false, // requireConfirmation
                 options.skipValidation || false), actualModel);
+            case "openai_reason":
+                // GPT-5 Pro with high reasoning effort for complex reasoning
+                actualModel = OPENAI_MODELS.PRO;
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), actualModel, temperature, maxTokens, "high", // reasoningEffort
+                false, // requireConfirmation
+                options.skipValidation || false), actualModel);
+            case "openai_code_review":
+                // GPT-5.1 codex-mini for code review (medium reasoning)
+                actualModel = OPENAI_MODELS.CODEX_MINI;
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt || "You are an expert code reviewer. Provide thorough code review with specific, actionable feedback."), actualModel, 0.3, // Low temperature for consistent code review
+                maxTokens, "medium", // reasoningEffort
+                false, options.skipValidation || false), actualModel);
+            case "openai_explain":
+                // GPT-5.1 codex-mini for explanations (low reasoning)
+                actualModel = OPENAI_MODELS.CODEX_MINI;
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt || "You are an expert educator. Provide clear, engaging explanations."), actualModel, temperature, maxTokens, "low", // reasoningEffort
+                false, options.skipValidation || false), actualModel);
             case "gpt5_analyze":
-                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), GPT51_MODELS.CODEX_MINI, 0.7, maxTokens), GPT51_MODELS.CODEX_MINI);
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), OPENAI_MODELS.CODEX_MINI, 0.7, maxTokens), OPENAI_MODELS.CODEX_MINI);
             case "openai_reason":
-                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), GPT51_MODELS.CODEX_MINI, temperature, maxTokens), GPT51_MODELS.CODEX_MINI);
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), OPENAI_MODELS.CODEX_MINI, temperature, maxTokens), OPENAI_MODELS.CODEX_MINI);
             // ============ GPT-5 TOOLS ============
             case "gpt5":
+                // Map to flagship gpt-5.1
+                const gpt5Full = OPENAI_MODELS.FULL; // gpt-5.1 flagship
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), gpt5Full, 0.7, maxTokens, "medium"), gpt5Full);
             case "gpt5_mini":
-            case "gpt5_nano":
-                // Map old names to new GPT-5.1 models
-                const gpt51Model = GPT51_MODELS.CODEX_MINI; // Always use cost-efficient codex-mini
-                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), gpt51Model, 0.7, maxTokens, "low"), gpt51Model);
+                // Map to gpt-5.1-codex-mini for code tasks (most workflows use for code)
+                const gpt5CodexMini = OPENAI_MODELS.CODEX_MINI; // gpt-5.1-codex-mini
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), gpt5CodexMini, 0.7, maxTokens, "low"), gpt5CodexMini);
             // ============ GROK TOOLS ============
             case "grok":
             case "grok_reason":
-            case "grok_code":
-            case "grok_debug":
             case "grok_brainstorm":
-            case "grok_heavy": // Grok Heavy is just grok-4-0709 with more backend resources
             case "grok_search":
-                actualModel = GrokModel.GROK_4_FAST_REASONING; // Using fast reasoning (2M context, $0.20/$0.50)
+                // Use reasoning model for reasoning/creative tasks
+                actualModel = GrokModel.GROK_4_1_FAST_REASONING; // Latest 4.1 (2M context, $0.20/$0.50)
+                return buildResult(await callGrok(toMessages(prompt, systemPrompt), actualModel, temperature, maxTokens), actualModel);
+            case "grok_code":
+            case "grok_debug":
+                // Use non-reasoning model for code/debug (tool-calling optimized)
+                actualModel = GrokModel.GROK_4_1_FAST; // Latest 4.1 non-reasoning (2M context, $0.20/$0.50)
+                return buildResult(await callGrok(toMessages(prompt, systemPrompt), actualModel, temperature, maxTokens), actualModel);
+            case "grok_heavy": // Grok Heavy is grok-4-0709 with extended context
+                actualModel = GrokModel.GROK_4_HEAVY; // Expensive $3/$15
                 return buildResult(await callGrok(toMessages(prompt, systemPrompt), actualModel, temperature, maxTokens), actualModel);
             // ============ ADVANCED MODES ============
             case "verifier":
@@ -340,20 +367,20 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
             // ============ META TOOLS ============
             case "think":
                 // Simple reflection tool - uses GPT-5.1-codex-mini for cost efficiency
-                return buildResult(await callOpenAI(toMessages(`Reflect on the following and provide brief insights:\n\n${prompt}`, "You are a reflective thinking assistant. Provide concise, insightful analysis."), GPT51_MODELS.CODEX_MINI, 0.7, 500), GPT51_MODELS.CODEX_MINI);
+                return buildResult(await callOpenAI(toMessages(`Reflect on the following and provide brief insights:\n\n${prompt}`, "You are a reflective thinking assistant. Provide concise, insightful analysis."), OPENAI_MODELS.CODEX_MINI, 0.7, 500), OPENAI_MODELS.CODEX_MINI);
             case "focus":
                 // Deep analysis tool - uses GPT-5.1
-                return buildResult(await callOpenAI(toMessages(`Perform deep analysis and synthesis:\n\n${prompt}`, "You are an advanced analytical assistant. Provide comprehensive, synthesized insights."), GPT51_MODELS.FULL, 0.8, maxTokens), GPT51_MODELS.FULL);
+                return buildResult(await callOpenAI(toMessages(`Perform deep analysis and synthesis:\n\n${prompt}`, "You are an advanced analytical assistant. Provide comprehensive, synthesized insights."), OPENAI_MODELS.FULL, 0.8, maxTokens), OPENAI_MODELS.FULL);
             case "code_reviewer":
-                return buildResult(await callOpenAI(toMessages(`Perform thorough code review:\n\n${prompt}`, "You are an expert code reviewer. Analyze for bugs, security issues, performance, and best practices."), GPT51_MODELS.FULL, 0.5, maxTokens), GPT51_MODELS.FULL);
+                return buildResult(await callOpenAI(toMessages(`Perform thorough code review:\n\n${prompt}`, "You are an expert code reviewer. Analyze for bugs, security issues, performance, and best practices."), OPENAI_MODELS.FULL, 0.5, maxTokens), OPENAI_MODELS.FULL);
             case "test_architect":
-                return buildResult(await callOpenAI(toMessages(`Design comprehensive tests:\n\n${prompt}`, "You are a testing expert. Design thorough test suites with edge cases."), GPT51_MODELS.FULL, 0.6, maxTokens), GPT51_MODELS.FULL);
+                return buildResult(await callOpenAI(toMessages(`Design comprehensive tests:\n\n${prompt}`, "You are a testing expert. Design thorough test suites with edge cases."), OPENAI_MODELS.FULL, 0.6, maxTokens), OPENAI_MODELS.FULL);
             case "documentation_writer":
-                return buildResult(await callOpenAI(toMessages(`Create clear documentation:\n\n${prompt}`, "You are a technical writer. Create clear, comprehensive documentation."), GPT51_MODELS.CODEX_MINI, 0.7, maxTokens), GPT51_MODELS.CODEX_MINI);
+                return buildResult(await callOpenAI(toMessages(`Create clear documentation:\n\n${prompt}`, "You are a technical writer. Create clear, comprehensive documentation."), OPENAI_MODELS.CODEX_MINI, 0.7, maxTokens), OPENAI_MODELS.CODEX_MINI);
             // ============ DEFAULT ============
             default:
                 console.warn(`⚠️ Unknown tool: ${toolName}, falling back to GPT-5.1-codex-mini`);
-                return buildResult(await callOpenAI(toMessages(prompt), GPT51_MODELS.CODEX_MINI, temperature, maxTokens), GPT51_MODELS.CODEX_MINI);
+                return buildResult(await callOpenAI(toMessages(prompt), OPENAI_MODELS.CODEX_MINI, temperature, maxTokens), OPENAI_MODELS.CODEX_MINI);
         }
     }
     catch (error) {
@@ -381,9 +408,9 @@ export function getAvailableTools() {
         tools.push("perplexity_ask", "perplexity_research", "perplexity_reason", "perplexity_code_search");
     }
     if (process.env.OPENAI_API_KEY) {
-        tools.push("openai_brainstorm", "gpt5_analyze", "openai_reason", "gpt5", "gpt5_mini", "gpt5_nano");
+        tools.push("openai_brainstorm", "openai_reason", "openai_code_review", "openai_explain", "gpt5_analyze", "openai_reason", "gpt5", "gpt5_mini");
     }
-    if (process.env.XAI_API_KEY) {
+    if (hasGrokApiKey()) {
         tools.push("grok", "grok_reason", "grok_code", "grok_debug", "grok_brainstorm", "grok_search");
     }
     // Add modes if available