tachibot-mcp 2.0.6 → 2.1.0

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

@@ -7,6 +7,7 @@ import { config } from "dotenv";
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { validateToolInput } from "../utils/input-validator.js";
+import { tryOpenRouterGateway, isGatewayEnabled } from "../utils/openrouter-gateway.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 config({ path: path.resolve(__dirname, '../../../.env') });
@@ -70,12 +71,14 @@ const ResponsesAPISchema = z.object({
         total_tokens: z.number().optional()
     }).optional()
 });
-// Available OpenAI models (GPT-5.1 family)
+// Available OpenAI GPT-5 models (optimized for Claude Code)
 export var OpenAI51Model;
 (function (OpenAI51Model) {
     OpenAI51Model["FULL"] = "gpt-5.1";
+    OpenAI51Model["PRO"] = "gpt-5-pro";
     OpenAI51Model["CODEX_MINI"] = "gpt-5.1-codex-mini";
     OpenAI51Model["CODEX"] = "gpt-5.1-codex";
+    OpenAI51Model["CODEX_MAX"] = "gpt-5.1-codex-max";
 })(OpenAI51Model || (OpenAI51Model = {}));
 /**
  * Call OpenAI API with model fallback support
@@ -84,6 +87,18 @@ export var OpenAI51Model;
 export async function callOpenAI(messages, model = OpenAI51Model.CODEX_MINI, temperature = 0.7, maxTokens = 16384, // Increased default for comprehensive responses
 reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
     console.error(`🔍 TRACE: callOpenAI called with model: ${model}`);
+    // Try OpenRouter gateway first if enabled
+    if (isGatewayEnabled()) {
+        const gatewayResult = await tryOpenRouterGateway(model, messages, {
+            temperature,
+            max_tokens: maxTokens
+        });
+        if (gatewayResult) {
+            return gatewayResult;
+        }
+        // Gateway failed or returned null, fall through to direct API
+        console.error(`🔍 TRACE: Gateway returned null, falling back to direct OpenAI API`);
+    }
     if (!OPENAI_API_KEY) {
         console.error(`🔍 TRACE: No API key found`);
         return `[OpenAI API key not configured. Add OPENAI_API_KEY to .env file]`;
@@ -111,34 +126,33 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
     for (const currentModel of modelsToTry) {
         console.error(`🔍 TRACE: Trying model: ${currentModel}`);
         try {
-            // GPT-5.1 models use /v1/responses, others use /v1/chat/completions
-            const isGPT51 = currentModel.startsWith('gpt-5.1');
-            const endpoint = isGPT51 ? OPENAI_RESPONSES_URL : OPENAI_CHAT_URL;
+            // Codex models use /v1/responses, non-codex use /v1/chat/completions
+            const isCodex = currentModel.includes('codex');
+            const endpoint = isCodex ? OPENAI_RESPONSES_URL : OPENAI_CHAT_URL;
             let requestBody;
-            // GPT-5.1 uses Responses API format, others use Chat Completions format
-            if (isGPT51) {
-                // Responses API format - NO temperature, use reasoning.effort instead
+            if (isCodex) {
+                // Responses API format for codex models
                 requestBody = {
                     model: currentModel,
                     input: validatedMessages,
                     max_output_tokens: maxTokens,
                     stream: false,
                     reasoning: {
-                        effort: reasoningEffort // "none", "low", "medium", "high"
+                        effort: reasoningEffort
                     }
                 };
             }
             else {
-                // Chat Completions format
+                // Chat Completions format for non-codex GPT-5 models (gpt-5.1, gpt-5-pro)
                 requestBody = {
                     model: currentModel,
                     messages: validatedMessages,
                     temperature,
-                    max_tokens: maxTokens,
+                    max_completion_tokens: maxTokens, // GPT-5 requires max_completion_tokens (not max_tokens)
                     stream: false
                 };
             }
-            console.error(`🔍 TRACE: Using ${isGPT51 ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
+            console.error(`🔍 TRACE: Using ${isCodex ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
             const response = await fetch(endpoint, {
                 method: "POST",
                 headers: {
@@ -159,16 +173,15 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
                 throw new Error(lastError);
             }
             const rawData = await response.json();
-            // Parse based on API type - they have DIFFERENT response formats!
+            // Parse based on API type
             let rawContent;
-            if (isGPT51) {
-                // Validate and parse Responses API format
+            if (isCodex) {
+                // Responses API format
                 const parseResult = ResponsesAPISchema.safeParse(rawData);
                 if (parseResult.success) {
                     const data = parseResult.data;
                     const messageOutput = data.output.find(item => item.type === 'message');
                     rawContent = messageOutput?.content?.[0]?.text;
-                    // Capture reasoning info
                     if (data.reasoning) {
                         console.error(`🔍 TRACE: Reasoning effort: ${data.reasoning.effort}`);
                     }
@@ -178,7 +191,7 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
                 }
             }
             else {
-                // Validate and parse Chat Completions API format
+                // Chat Completions format
                 const parseResult = ChatCompletionResponseSchema.safeParse(rawData);
                 if (parseResult.success) {
                     const chatData = parseResult.data;
@@ -209,6 +222,17 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
 async function callOpenAIWithCustomParams(messages, model, temperature = 0.7, maxTokens = 16384, // Increased for detailed brainstorming
 reasoningEffort = "low", skipValidation = false) {
     console.error(`🔍 TRACE: callOpenAIWithCustomParams called with model: ${model}, reasoning_effort: ${reasoningEffort}`);
+    // Try OpenRouter gateway first if enabled
+    if (isGatewayEnabled()) {
+        const gatewayResult = await tryOpenRouterGateway(model, messages, {
+            temperature,
+            max_tokens: maxTokens
+        });
+        if (gatewayResult) {
+            return gatewayResult;
+        }
+        console.error(`🔍 TRACE: Gateway returned null, falling back to direct OpenAI API`);
+    }
     if (!OPENAI_API_KEY) {
         console.error(`🔍 TRACE: No API key found`);
         return `[OpenAI API key not configured. Add OPENAI_API_KEY to .env file]`;
@@ -225,17 +249,16 @@ reasoningEffort = "low", skipValidation = false) {
         return { ...msg, content: validation.sanitized };
     });
     try {
-        // GPT-5.1 models use /v1/responses, others use /v1/chat/completions
-        const isGPT51 = model.startsWith('gpt-5.1');
-        const endpoint = isGPT51 ? OPENAI_RESPONSES_URL : OPENAI_CHAT_URL;
+        // Codex models use /v1/responses, non-codex use /v1/chat/completions
+        const isCodex = model.includes('codex');
+        const endpoint = isCodex ? OPENAI_RESPONSES_URL : OPENAI_CHAT_URL;
         let requestBody;
-        // GPT-5.1 uses Responses API format, others use Chat Completions format
-        if (isGPT51) {
-            // Responses API format - NO temperature, use reasoning.effort instead
+        if (isCodex) {
+            // Responses API format for codex models
             requestBody = {
                 model: model,
                 input: validatedMessages,
-                max_output_tokens: maxTokens,
+                max_output_tokens: maxTokens, // NOT max_completion_tokens or max_tokens!
                 stream: false,
                 reasoning: {
                     effort: reasoningEffort // "none", "low", "medium", "high"
@@ -243,17 +266,17 @@ reasoningEffort = "low", skipValidation = false) {
             };
         }
         else {
-            // Chat Completions format
+            // Chat Completions format for non-codex GPT-5 models (gpt-5.1, gpt-5-pro)
             requestBody = {
                 model: model,
                 messages: validatedMessages,
                 temperature,
-                max_tokens: maxTokens,
+                max_completion_tokens: maxTokens, // GPT-5 requires max_completion_tokens (not max_tokens)
                 stream: false
             };
         }
-        console.error(`🔍 TRACE: Using ${isGPT51 ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
-        console.error(`🔍 TRACE: Model params: max_tokens=${maxTokens}, temperature=${temperature}${isGPT51 ? `, reasoning_effort=${reasoningEffort}` : ''}`);
+        console.error(`🔍 TRACE: Using ${isCodex ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
+        console.error(`🔍 TRACE: Model params: ${isCodex ? `max_output_tokens=${maxTokens}, reasoning_effort=${reasoningEffort}` : `max_completion_tokens=${maxTokens}, temperature=${temperature}`}`);
         const response = await fetch(endpoint, {
             method: "POST",
             headers: {
@@ -270,7 +293,7 @@ reasoningEffort = "low", skipValidation = false) {
         const rawData = await response.json();
         // Parse based on API type - they have DIFFERENT response formats!
         let rawContent;
-        if (isGPT51) {
+        if (isCodex) {
             // Validate and parse Responses API format
             const parseResult = ResponsesAPISchema.safeParse(rawData);
             if (parseResult.success) {
@@ -378,7 +401,7 @@ export const gpt5MiniReasonTool = {
     }
 };
 export const openaiGpt5ReasonTool = {
-    name: "openai_gpt5_reason",
+    name: "openai_reason",
     description: "Mathematical reasoning using GPT-5.1 with high reasoning effort",
     parameters: z.object({
         query: z.string(),
@@ -409,37 +432,6 @@ ${args.context ? `Context: ${args.context}` : ''}`
         return await callOpenAI(messages, OpenAI51Model.FULL, 0.7, 4000, "high");
     }
 };
-/**
- * OpenAI Compare Tool
- * Multi-option comparison and consensus building using GPT-5.1-codex-mini
- */
-export const openaiCompareTool = {
-    name: "openai_compare",
-    description: "Multi-model consensus",
-    parameters: z.object({
-        topic: z.string(),
-        options: z.array(z.string()),
-        criteria: z.string().optional(),
-        includeRecommendation: z.boolean().optional().default(true)
-    }),
-    execute: async (args, { log }) => {
-        const optionsList = args.options.map((opt, i) => `${i + 1}. ${opt}`).join('\n');
-        const messages = [
-            {
-                role: "system",
-                content: `You are an expert at comparative analysis and decision-making.
-Compare the given options systematically.
-${args.criteria ? `Criteria: ${args.criteria}` : 'Consider: pros, cons, trade-offs, and suitability'}
-${args.includeRecommendation ? 'Provide a clear recommendation with justification.' : ''}`
-            },
-            {
-                role: "user",
-                content: `Topic: ${args.topic}\n\nOptions:\n${optionsList}`
-            }
-        ];
-        return await callOpenAI(messages, OpenAI51Model.CODEX_MINI, 0.7, 3000, "low");
-    }
-};
 /**
  * OpenAI Brainstorm Tool
  * Creative ideation and brainstorming
@@ -582,7 +574,6 @@ export function getAllOpenAITools() {
     }
     return [
         openaiGpt5ReasonTool, // GPT-5.1 reasoning (high effort)
-        openaiCompareTool, // GPT-5.1-codex-mini comparison (low effort)
         openAIBrainstormTool, // GPT-5.1-codex-mini brainstorming (medium effort)
         openaiCodeReviewTool, // GPT-5.1-codex-mini code review (medium effort)
         openaiExplainTool // GPT-5.1-codex-mini explanations (low effort)

package/dist/src/tools/tool-router.js

@@ -2,6 +2,7 @@
  * Smart Tool Router for Focus MCP Server
  * Manages tool selection based on availability, preferences, and capabilities
  */
+import { hasGrokApiKey, hasOpenAIApiKey, hasPerplexityApiKey, hasGeminiApiKey, hasOpenRouterApiKey } from "../utils/api-keys.js";
 // Tool capability categories
 export var ToolCategory;
 (function (ToolCategory) {
@@ -46,64 +47,54 @@ export class ToolRouter {
         return {
             [ToolCategory.REASONING]: [
                 {
-                    name: "gpt5_reason",
+                    name: "openai_reason",
                     provider: ToolProvider.OPENAI,
                     categories: [ToolCategory.REASONING],
                     priority: 1,
                     costTier: "high",
                     speedTier: "medium",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENAI_API_KEY && process.env.ENABLE_GPT5 === 'true'
+                    checkAvailability: () => hasOpenAIApiKey()
                 },
                 {
-                    name: "gpt5_mini_reason",
-                    provider: ToolProvider.OPENAI,
+                    name: "grok_reason",
+                    provider: ToolProvider.GROK,
                     categories: [ToolCategory.REASONING],
                     priority: 2,
                     costTier: "medium",
                     speedTier: "fast",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                    checkAvailability: () => hasGrokApiKey()
                 },
                 {
-                    name: "qwq_reason",
-                    provider: ToolProvider.OPENROUTER,
-                    categories: [ToolCategory.REASONING],
+                    name: "perplexity_reason",
+                    provider: ToolProvider.PERPLEXITY,
+                    categories: [ToolCategory.REASONING, ToolCategory.SEARCH],
                     priority: 3,
                     costTier: "medium",
-                    speedTier: "medium",
-                    qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENROUTER_API_KEY
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => hasPerplexityApiKey()
                 },
                 {
-                    name: "grok_reason",
-                    provider: ToolProvider.GROK,
+                    name: "kimi_thinking",
+                    provider: ToolProvider.OPENROUTER,
                     categories: [ToolCategory.REASONING],
                     priority: 4,
                     costTier: "medium",
-                    speedTier: "fast",
+                    speedTier: "medium",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.GROK_API_KEY
-                },
-                {
-                    name: "perplexity_reason",
-                    provider: ToolProvider.PERPLEXITY,
-                    categories: [ToolCategory.REASONING, ToolCategory.SEARCH],
-                    priority: 5,
-                    costTier: "medium",
-                    speedTier: "fast",
-                    qualityTier: "good",
-                    checkAvailability: () => !!process.env.PERPLEXITY_API_KEY
+                    checkAvailability: () => hasOpenRouterApiKey()
                 },
                 {
-                    name: "gemini_query",
+                    name: "gemini_brainstorm",
                     provider: ToolProvider.GEMINI,
                     categories: [ToolCategory.REASONING],
-                    priority: 6,
+                    priority: 5,
                     costTier: "low",
                     speedTier: "fast",
                     qualityTier: "good",
-                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                    checkAvailability: () => hasGeminiApiKey()
                 }
             ],
             [ToolCategory.CODE]: [
@@ -115,7 +106,7 @@ export class ToolRouter {
                     costTier: "medium",
                     speedTier: "medium",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENROUTER_API_KEY
+                    checkAvailability: () => hasOpenRouterApiKey()
                 },
                 {
                     name: "grok_code",
@@ -125,17 +116,17 @@ export class ToolRouter {
                     costTier: "medium",
                     speedTier: "fast",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.GROK_API_KEY
+                    checkAvailability: () => hasGrokApiKey()
                 },
                 {
-                    name: "gpt5_code",
+                    name: "openai_code_review",
                     provider: ToolProvider.OPENAI,
                     categories: [ToolCategory.CODE, ToolCategory.ANALYSIS],
                     priority: 3,
                     costTier: "medium",
                     speedTier: "fast",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                    checkAvailability: () => hasOpenAIApiKey()
                 },
                 {
                     name: "gemini_analyze_code",
@@ -145,7 +136,7 @@ export class ToolRouter {
                     costTier: "low",
                     speedTier: "fast",
                     qualityTier: "good",
-                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                    checkAvailability: () => hasGeminiApiKey()
                 }
             ],
             [ToolCategory.BRAINSTORM]: [
@@ -157,7 +148,7 @@ export class ToolRouter {
                     costTier: "medium",
                     speedTier: "medium",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.GROK_API_KEY
+                    checkAvailability: () => hasGrokApiKey()
                 },
                 {
                     name: "openai_brainstorm",
@@ -167,7 +158,7 @@ export class ToolRouter {
                     costTier: "high",
                     speedTier: "medium",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                    checkAvailability: () => hasOpenAIApiKey()
                 },
                 {
                     name: "gemini_brainstorm",
@@ -177,7 +168,7 @@ export class ToolRouter {
                     costTier: "low",
                     speedTier: "fast",
                     qualityTier: "good",
-                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                    checkAvailability: () => hasGeminiApiKey()
                 }
             ],
             [ToolCategory.SEARCH]: [
@@ -189,7 +180,7 @@ export class ToolRouter {
                     costTier: "medium",
                     speedTier: "fast",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.PERPLEXITY_API_KEY
+                    checkAvailability: () => hasPerplexityApiKey()
                 },
                 {
                     name: "perplexity_research",
@@ -199,39 +190,49 @@ export class ToolRouter {
                     costTier: "medium",
                     speedTier: "medium",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.PERPLEXITY_API_KEY
+                    checkAvailability: () => hasPerplexityApiKey()
+                },
+                {
+                    name: "grok_search",
+                    provider: ToolProvider.GROK,
+                    categories: [ToolCategory.SEARCH],
+                    priority: 3,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => hasGrokApiKey()
                 }
             ],
             [ToolCategory.ANALYSIS]: [
                 {
-                    name: "gpt5_mini_analyze",
+                    name: "openai_code_review",
                     provider: ToolProvider.OPENAI,
                     categories: [ToolCategory.ANALYSIS],
                     priority: 1,
                     costTier: "medium",
                     speedTier: "fast",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                    checkAvailability: () => hasOpenAIApiKey()
                 },
                 {
-                    name: "openai_compare",
-                    provider: ToolProvider.OPENAI,
+                    name: "gemini_analyze_text",
+                    provider: ToolProvider.GEMINI,
                     categories: [ToolCategory.ANALYSIS],
                     priority: 2,
-                    costTier: "medium",
-                    speedTier: "medium",
-                    qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                    costTier: "low",
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => hasGeminiApiKey()
                 },
                 {
-                    name: "gemini_analyze_text",
+                    name: "gemini_analyze_code",
                     provider: ToolProvider.GEMINI,
-                    categories: [ToolCategory.ANALYSIS],
+                    categories: [ToolCategory.ANALYSIS, ToolCategory.CODE],
                     priority: 3,
                     costTier: "low",
                     speedTier: "fast",
                     qualityTier: "good",
-                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                    checkAvailability: () => hasGeminiApiKey()
                 }
             ],
             [ToolCategory.DEBUG]: [
@@ -243,17 +244,17 @@ export class ToolRouter {
                     costTier: "medium",
                     speedTier: "fast",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.GROK_API_KEY
+                    checkAvailability: () => hasGrokApiKey()
                 },
                 {
-                    name: "gpt5_code",
+                    name: "openai_code_review",
                     provider: ToolProvider.OPENAI,
                     categories: [ToolCategory.DEBUG, ToolCategory.CODE],
                     priority: 2,
                     costTier: "medium",
                     speedTier: "fast",
                     qualityTier: "excellent",
-                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                    checkAvailability: () => hasOpenAIApiKey()
                 }
             ]
         };

package/dist/src/tools/unified-ai-provider.js

@@ -10,6 +10,50 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 config({ path: path.resolve(__dirname, '../../../.env') });
+// =============================================================================
+// OPENROUTER GATEWAY MODE
+// =============================================================================
+// When enabled, routes OpenAI/Gemini/Grok through OpenRouter with single API key
+// Kimi/Qwen always use OpenRouter (native), Perplexity always uses direct API
+const USE_OPENROUTER_GATEWAY = process.env.USE_OPENROUTER_GATEWAY === 'true';
+/**
+ * Get OpenRouter model name - adds provider prefix
+ * Returns null if model should skip gateway (e.g., Perplexity)
+ */
+function getOpenRouterModel(model) {
+    // Perplexity - NEVER use gateway
+    if (model.startsWith('sonar'))
+        return null;
+    // Already has prefix
+    if (model.includes('/'))
+        return model;
+    // Add provider prefix
+    if (model.startsWith('gpt-'))
+        return `openai/${model}`;
+    if (model.startsWith('gemini-'))
+        return `google/${model}`;
+    if (model.startsWith('grok-'))
+        return `x-ai/${model}`;
+    return model;
+}
+/**
+ * Check if a model should use OpenRouter gateway
+ * - Kimi/Qwen: Always (native OpenRouter)
+ * - Perplexity: Never (not on OpenRouter)
+ * - Others: Only if USE_OPENROUTER_GATEWAY=true
+ */
+function shouldUseOpenRouterGateway(model) {
+    // Already OpenRouter format (qwen/, moonshotai/)
+    if (model.startsWith('qwen/') || model.startsWith('moonshotai/')) {
+        return true;
+    }
+    // Perplexity models never go through OpenRouter
+    if (model.startsWith('sonar')) {
+        return false;
+    }
+    // Everything else: check gateway flag
+    return USE_OPENROUTER_GATEWAY;
+}
 // Provider configurations with their base URLs
 const PROVIDER_CONFIGS = {
     openai: {
@@ -31,7 +75,7 @@ const PROVIDER_CONFIGS = {
     gemini: {
         base: 'https://generativelanguage.googleapis.com/v1beta/',
         key: process.env.GOOGLE_API_KEY,
-        models: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']
+        models: ['gemini-3-pro-preview', 'gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']
     },
     openrouter: {
         base: 'https://openrouter.ai/api/v1',
@@ -78,23 +122,60 @@ export function getAvailableProviders() {
  * Unified AI query function
  */
 export async function queryAI(prompt, options) {
-    const config = PROVIDER_CONFIGS[options.provider];
-    if (!config) {
+    const providerConfig = PROVIDER_CONFIGS[options.provider];
+    if (!providerConfig) {
         throw new Error(`Unknown provider: ${options.provider}`);
     }
     if (!isProviderAvailable(options.provider)) {
         throw new Error(`Provider ${options.provider} is not configured. Please set the appropriate API key.`);
     }
-    // Handle GPT-5 special case
-    if (options.provider === 'gpt51' && 'special' in config && config.special) {
+    let model = options.model || providerConfig.models[0];
+    // Check if we should route through OpenRouter gateway
+    if (shouldUseOpenRouterGateway(model) && process.env.OPENROUTER_API_KEY) {
+        const openRouterModel = getOpenRouterModel(model);
+        // Skip gateway if model returns null (e.g., Perplexity)
+        if (!openRouterModel) {
+            // Fall through to direct API handling below
+        }
+        else {
+            console.error(`🔀 [OpenRouter Gateway] Routing ${model} → ${openRouterModel}`);
+            const client = new OpenAI({
+                apiKey: process.env.OPENROUTER_API_KEY,
+                baseURL: 'https://openrouter.ai/api/v1',
+                defaultHeaders: {
+                    'HTTP-Referer': 'https://tachibot-mcp.local',
+                    'X-Title': 'TachiBot MCP Server'
+                }
+            });
+            try {
+                const response = await client.chat.completions.create({
+                    model: openRouterModel,
+                    messages: [
+                        ...(options.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+                        { role: 'user', content: prompt }
+                    ],
+                    temperature: options.temperature ?? 0.7,
+                    max_tokens: options.maxTokens ?? 2000,
+                    stream: false
+                });
+                return response.choices[0]?.message?.content || 'No response generated';
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error(`Error with OpenRouter gateway:`, errorMessage);
+                throw new Error(`OpenRouter gateway error: ${errorMessage}`);
+            }
+        } // Close else block for openRouterModel check
+    }
+    // Handle GPT-5 special case (direct API only)
+    if (options.provider === 'gpt51' && 'special' in providerConfig && providerConfig.special) {
         return await handleGPT5(prompt, options);
     }
-    // Standard OpenAI-compatible handling
+    // Standard OpenAI-compatible handling (direct API)
     const client = new OpenAI({
-        apiKey: config.key,
-        baseURL: config.base
+        apiKey: providerConfig.key,
+        baseURL: providerConfig.base
     });
-    const model = options.model || config.models[0];
     try {
         const response = await client.chat.completions.create({
             model,

package/dist/src/tools/workflow-runner.js

@@ -73,6 +73,22 @@ export function registerWorkflowTools(server) {
                         output += `## Step ${i + 1}: ${step.step}\n\n`;
                         // Format the step output - keep it clean and readable
                         let stepOutput = step.output;
+                        // DEFENSIVE: Ensure stepOutput is a string (fix [object Object] issue)
+                        if (stepOutput !== null && typeof stepOutput === 'object') {
+                            // Handle FileReference objects - extract summary or stringify
+                            if ('summary' in stepOutput && typeof stepOutput.summary === 'string') {
+                                stepOutput = stepOutput.summary;
+                            }
+                            else if ('content' in stepOutput && typeof stepOutput.content === 'string') {
+                                stepOutput = stepOutput.content;
+                            }
+                            else {
+                                stepOutput = JSON.stringify(stepOutput, null, 2);
+                            }
+                        }
+                        else if (stepOutput === undefined || stepOutput === null) {
+                            stepOutput = '[No output]';
+                        }
                         // Truncate based on settings
                         if (truncate && typeof stepOutput === 'string' && stepOutput.length > maxChars) {
                             const approxTokens = Math.floor(stepOutput.length / 4);

package/dist/src/tools/workflow-validator-tool.js

@@ -16,7 +16,7 @@ function getAllKnownTools() {
         // 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