tachibot-mcp 2.0.2 → 2.0.3

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

@@ -1,6 +1,6 @@
 /**
  * OpenAI Tools Implementation
- * Provides GPT-5, GPT-5-mini, and GPT-5-nano model capabilities
+ * Provides GPT-5.1 model capabilities with reasoning_effort control
  */
 import { z } from "zod";
 import { config } from "dotenv";
@@ -12,20 +12,77 @@ const __dirname = path.dirname(__filename);
 config({ path: path.resolve(__dirname, '../../../.env') });
 // OpenAI API configuration
 const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
-const OPENAI_API_URL = "https://api.openai.com/v1/chat/completions";
-// Available OpenAI models (GPT-5 family only)
-export var OpenAIModel;
-(function (OpenAIModel) {
-    OpenAIModel["GPT5"] = "gpt-5";
-    OpenAIModel["GPT5_MINI"] = "gpt-5-mini";
-    OpenAIModel["GPT5_NANO"] = "gpt-5-nano";
-})(OpenAIModel || (OpenAIModel = {}));
+const OPENAI_CHAT_URL = "https://api.openai.com/v1/chat/completions";
+const OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
+// Zod schemas for API responses
+const ChatCompletionResponseSchema = z.object({
+    id: z.string(),
+    object: z.string(),
+    created: z.number(),
+    model: z.string(),
+    choices: z.array(z.object({
+        index: z.number(),
+        message: z.object({
+            role: z.string(),
+            content: z.string()
+        }),
+        finish_reason: z.string().optional()
+    })),
+    usage: z.object({
+        prompt_tokens: z.number().optional(),
+        completion_tokens: z.number().optional(),
+        total_tokens: z.number().optional()
+    }).optional()
+});
+const ResponsesAPIOutputSchema = z.object({
+    id: z.string(),
+    type: z.string(),
+    status: z.string().optional(),
+    content: z.array(z.object({
+        type: z.string(), // Can be "output_text", "text", etc.
+        text: z.string().optional(), // Make optional to handle different content types
+        annotations: z.array(z.unknown()).optional(),
+        logprobs: z.array(z.unknown()).optional()
+    })).optional(),
+    summary: z.array(z.unknown()).optional(),
+    role: z.string().optional()
+});
+const ResponsesAPISchema = z.object({
+    id: z.string(),
+    object: z.literal("response"),
+    created_at: z.number(),
+    status: z.string(),
+    model: z.string(),
+    output: z.array(ResponsesAPIOutputSchema),
+    reasoning: z.object({
+        effort: z.string(),
+        summary: z.string().nullable().optional()
+    }).optional(),
+    usage: z.object({
+        input_tokens: z.number().optional(), // Fixed: was prompt_tokens
+        input_tokens_details: z.object({
+            cached_tokens: z.number().optional()
+        }).optional(),
+        output_tokens: z.number().optional(), // Fixed: was completion_tokens
+        output_tokens_details: z.object({
+            reasoning_tokens: z.number().optional()
+        }).optional(),
+        total_tokens: z.number().optional()
+    }).optional()
+});
+// Available OpenAI models (GPT-5.1 family)
+export var OpenAI51Model;
+(function (OpenAI51Model) {
+    OpenAI51Model["FULL"] = "gpt-5.1";
+    OpenAI51Model["CODEX_MINI"] = "gpt-5.1-codex-mini";
+    OpenAI51Model["CODEX"] = "gpt-5.1-codex";
+})(OpenAI51Model || (OpenAI51Model = {}));
 /**
  * Call OpenAI API with model fallback support
- * Automatically detects GPT-5 models and uses correct endpoint + format
+ * Automatically detects GPT-5.1 models and uses correct endpoint + format
  */
-export async function callOpenAI(messages, model = OpenAIModel.GPT5_MINI, temperature = 1, maxTokens = 16384, // Increased default for comprehensive responses
-requireConfirmation = false, skipValidation = false) {
+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}`);
     if (!OPENAI_API_KEY) {
         console.error(`🔍 TRACE: No API key found`);
@@ -42,11 +99,11 @@ requireConfirmation = false, skipValidation = false) {
         }
         return { ...msg, content: validation.sanitized };
     });
-    // Model fallback chain - GPT-5 models have no fallbacks to test actual availability
+    // Model fallback chain - GPT-5.1 models have no fallbacks to test actual availability
     const modelFallbacks = {
-        [OpenAIModel.GPT5]: [], // No fallback - test actual GPT-5
-        [OpenAIModel.GPT5_MINI]: [], // No fallback - test actual GPT-5-mini
-        [OpenAIModel.GPT5_NANO]: [] // No fallback - test actual GPT-5-nano
+        [OpenAI51Model.FULL]: [], // No fallback - test actual GPT-5.1
+        [OpenAI51Model.CODEX_MINI]: [], // No fallback - test actual GPT-5.1-codex-mini
+        [OpenAI51Model.CODEX]: [] // No fallback - test actual GPT-5.1-codex
     };
     const modelsToTry = [model, ...(modelFallbacks[model] || [])];
     console.error(`🔍 TRACE: Models to try: ${modelsToTry.join(', ')}`);
@@ -54,32 +111,34 @@ requireConfirmation = false, skipValidation = false) {
     for (const currentModel of modelsToTry) {
         console.error(`🔍 TRACE: Trying model: ${currentModel}`);
         try {
-            // Detect if this is a GPT-5 model (uses /v1/responses endpoint)
-            const isGPT5 = currentModel.startsWith('gpt-5');
-            const endpoint = isGPT5
-                ? "https://api.openai.com/v1/responses"
-                : OPENAI_API_URL;
-            // For GPT-5: convert messages to input string
-            const input = isGPT5
-                ? validatedMessages.map(m => m.role === 'system' ? `System: ${m.content}` : m.content).join('\n\n')
-                : undefined;
-            const requestBody = isGPT5 ? {
-                model: currentModel,
-                input: input,
-                reasoning: {
-                    effort: "minimal" // minimal/low/medium/high
-                },
-                text: {
-                    verbosity: "medium" // silent/minimal/concise/balanced/medium/detailed/exhaustive
-                }
-            } : {
-                model: currentModel,
-                messages: validatedMessages,
-                temperature,
-                max_tokens: maxTokens,
-                stream: false
-            };
-            console.error(`🔍 TRACE: Using ${isGPT5 ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
+            // 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;
+            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
+                requestBody = {
+                    model: currentModel,
+                    input: validatedMessages,
+                    max_output_tokens: maxTokens,
+                    stream: false,
+                    reasoning: {
+                        effort: reasoningEffort // "none", "low", "medium", "high"
+                    }
+                };
+            }
+            else {
+                // Chat Completions format
+                requestBody = {
+                    model: currentModel,
+                    messages: validatedMessages,
+                    temperature,
+                    max_tokens: maxTokens,
+                    stream: false
+                };
+            }
+            console.error(`🔍 TRACE: Using ${isGPT51 ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
             const response = await fetch(endpoint, {
                 method: "POST",
                 headers: {
@@ -99,19 +158,38 @@ requireConfirmation = false, skipValidation = false) {
                 }
                 throw new Error(lastError);
             }
-            const data = await response.json();
-            // Parse response based on endpoint type
-            let result;
-            if (isGPT5) {
-                // GPT-5 /v1/responses format: output array with message objects
-                const messageOutput = data.output?.find((o) => o.type === 'message');
-                const textContent = messageOutput?.content?.find((c) => c.type === 'output_text');
-                result = textContent?.text || "No response from OpenAI";
+            const rawData = await response.json();
+            // Parse based on API type - they have DIFFERENT response formats!
+            let rawContent;
+            if (isGPT51) {
+                // Validate and parse 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}`);
+                    }
+                }
+                else {
+                    console.error(`🔍 TRACE: Failed to parse Responses API response:`, parseResult.error);
+                }
             }
             else {
-                // GPT-4 /v1/chat/completions format
-                result = data.choices?.[0]?.message?.content || "No response from OpenAI";
+                // Validate and parse Chat Completions API format
+                const parseResult = ChatCompletionResponseSchema.safeParse(rawData);
+                if (parseResult.success) {
+                    const chatData = parseResult.data;
+                    rawContent = chatData.choices[0]?.message?.content;
+                }
+                else {
+                    console.error(`🔍 TRACE: Failed to parse Chat Completions response:`, parseResult.error);
+                }
             }
+            // Ensure result is always a string
+            const result = rawContent || "No response from OpenAI";
             console.error(`🔍 TRACE: ${currentModel} SUCCESS - Response length: ${result.length}`);
             return result;
         }
@@ -122,13 +200,13 @@ requireConfirmation = false, skipValidation = false) {
         }
     }
     console.error(`🔍 TRACE: ALL MODELS FAILED - Last error: ${lastError}`);
-    return `[GPT-5 model "${model}" not available. Error: ${lastError}]`;
+    return `[GPT-5.1 model "${model}" not available. Error: ${lastError}]`;
 }
 /**
  * Call OpenAI API with custom parameters for specific models
- * Automatically detects GPT-5 models and uses correct endpoint + format
+ * Automatically detects GPT-5.1 models and uses correct endpoint + format
  */
-async function callOpenAIWithCustomParams(messages, model, temperature = 0.8, maxTokens = 16384, // Increased for detailed brainstorming
+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}`);
     if (!OPENAI_API_KEY) {
@@ -147,37 +225,35 @@ reasoningEffort = "low", skipValidation = false) {
         return { ...msg, content: validation.sanitized };
     });
     try {
-        const isGPT5 = model.startsWith('gpt-5');
-        const endpoint = isGPT5
-            ? "https://api.openai.com/v1/responses"
-            : OPENAI_API_URL;
-        // For GPT-5: convert messages to input string
-        const input = isGPT5
-            ? validatedMessages.map(m => m.role === 'system' ? `System: ${m.content}` : m.content).join('\n\n')
-            : undefined;
-        const requestBody = isGPT5 ? {
-            model: model,
-            input: input,
-            reasoning: {
-                effort: reasoningEffort // minimal/low/medium/high
-            },
-            text: {
-                verbosity: "medium"
-            }
-        } : {
-            model: model,
-            messages: validatedMessages,
-            temperature,
-            max_tokens: maxTokens,
-            stream: false
-        };
-        console.error(`🔍 TRACE: Using ${isGPT5 ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
-        if (isGPT5) {
-            console.error(`🔍 TRACE: GPT-5 params: reasoning_effort=${reasoningEffort}`);
+        // 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;
+        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
+            requestBody = {
+                model: model,
+                input: validatedMessages,
+                max_output_tokens: maxTokens,
+                stream: false,
+                reasoning: {
+                    effort: reasoningEffort // "none", "low", "medium", "high"
+                }
+            };
         }
         else {
-            console.error(`🔍 TRACE: GPT-4 params: max_tokens=${maxTokens}, temperature=${temperature}`);
+            // Chat Completions format
+            requestBody = {
+                model: model,
+                messages: validatedMessages,
+                temperature,
+                max_tokens: maxTokens,
+                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}` : ''}`);
         const response = await fetch(endpoint, {
             method: "POST",
             headers: {
@@ -191,19 +267,38 @@ reasoningEffort = "low", skipValidation = false) {
             console.error(`🔍 TRACE: ${model} failed - Status: ${response.status}, Error: ${error}`);
             return `[${model} failed: ${response.status} - ${error}]`;
         }
-        const data = await response.json();
-        // Parse response based on endpoint type
-        let result;
-        if (isGPT5) {
-            // GPT-5 /v1/responses format
-            const messageOutput = data.output?.find((o) => o.type === 'message');
-            const textContent = messageOutput?.content?.find((c) => c.type === 'output_text');
-            result = textContent?.text || "No response from OpenAI";
+        const rawData = await response.json();
+        // Parse based on API type - they have DIFFERENT response formats!
+        let rawContent;
+        if (isGPT51) {
+            // Validate and parse 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}`);
+                }
+            }
+            else {
+                console.error(`🔍 TRACE: Failed to parse Responses API response:`, parseResult.error);
+            }
         }
         else {
-            // GPT-4 /v1/chat/completions format
-            result = data.choices?.[0]?.message?.content || "No response from OpenAI";
+            // Validate and parse Chat Completions API format
+            const parseResult = ChatCompletionResponseSchema.safeParse(rawData);
+            if (parseResult.success) {
+                const chatData = parseResult.data;
+                rawContent = chatData.choices[0]?.message?.content;
+            }
+            else {
+                console.error(`🔍 TRACE: Failed to parse Chat Completions response:`, parseResult.error);
+            }
         }
+        // Ensure result is always a string
+        const result = rawContent || "No response from OpenAI";
         console.error(`🔍 TRACE: ${model} SUCCESS - Response length: ${result.length}`);
         return result;
     }
@@ -246,8 +341,8 @@ export const gpt5ReasonTool = {
                 content: args.query
             }
         ];
-        // Use GPT-5; callOpenAI has fallback to 5-mini and 4o if unavailable
-        return await callOpenAI(messages, OpenAIModel.GPT5, 0.7, 4000);
+        // Use GPT-5.1 with high reasoning
+        return await callOpenAI(messages, OpenAI51Model.FULL, 0.7, 4000, "high");
     }
 };
 /**
@@ -278,13 +373,13 @@ export const gpt5MiniReasonTool = {
                 content: args.query
             }
         ];
-        // Use GPT-5-mini directly; fallback chain will handle unavailability
-        return await callOpenAI(messages, OpenAIModel.GPT5_MINI, 0.7, 3000);
+        // Use GPT-5.1-codex-mini with medium reasoning
+        return await callOpenAI(messages, OpenAI51Model.CODEX_MINI, 0.7, 3000, "medium");
     }
 };
 export const openaiGpt5ReasonTool = {
     name: "openai_gpt5_reason",
-    description: "Mathematical reasoning using GPT-5-mini",
+    description: "Mathematical reasoning using GPT-5.1 with high reasoning effort",
     parameters: z.object({
         query: z.string(),
         context: z.string().optional(),
@@ -310,13 +405,13 @@ ${args.context ? `Context: ${args.context}` : ''}`
                 content: args.query
             }
         ];
-        // Use GPT-5-mini for reasoning
-        return await callOpenAI(messages, OpenAIModel.GPT5_MINI, 0.7, 4000);
+        // Use GPT-5.1 with high reasoning effort for complex reasoning
+        return await callOpenAI(messages, OpenAI51Model.FULL, 0.7, 4000, "high");
     }
 };
 /**
  * OpenAI Compare Tool
- * Multi-option comparison and consensus building using GPT-5-mini
+ * Multi-option comparison and consensus building using GPT-5.1-codex-mini
  */
 export const openaiCompareTool = {
     name: "openai_compare",
@@ -342,7 +437,7 @@ ${args.includeRecommendation ? 'Provide a clear recommendation with justificatio
                 content: `Topic: ${args.topic}\n\nOptions:\n${optionsList}`
             }
         ];
-        return await callOpenAI(messages, OpenAIModel.GPT5_MINI, 0.7, 3000);
+        return await callOpenAI(messages, OpenAI51Model.CODEX_MINI, 0.7, 3000, "low");
     }
 };
 /**
@@ -357,13 +452,12 @@ export const openAIBrainstormTool = {
         constraints: z.string().optional(),
         quantity: z.number().optional(),
         style: z.enum(["innovative", "practical", "wild", "systematic"]).optional(),
-        model: z.enum(["gpt-5", "gpt-5-mini", "gpt-5-nano"]).optional(),
-        reasoning_effort: z.enum(["minimal", "low", "medium", "high"]).optional(),
-        verbosity: z.enum(["silent", "minimal", "concise", "balanced", "detailed", "exhaustive"]).optional(),
+        model: z.enum(["gpt-5.1", "gpt-5.1-codex-mini", "gpt-5.1-codex"]).optional(),
+        reasoning_effort: z.enum(["none", "low", "medium", "high"]).optional(),
         max_tokens: z.number().optional()
     }),
     execute: async (args, options = {}) => {
-        const { problem, constraints, quantity = 5, style = "innovative", model = "gpt-5-mini", reasoning_effort = "low", verbosity = "balanced", max_tokens = 4000 } = args;
+        const { problem, constraints, quantity = 5, style = "innovative", model = "gpt-5.1-codex-mini", reasoning_effort = "medium", max_tokens = 4000 } = args;
         console.error('🚀 TOOL CALLED: openai_brainstorm');
         console.error('📥 ARGS RECEIVED:', JSON.stringify(args, null, 2));
         console.error('📥 OPTIONS RECEIVED:', JSON.stringify(options, null, 2));
@@ -394,9 +488,7 @@ Format: Number each idea and provide a brief explanation.`
         // Convert string model to OpenAIModel enum
         const modelEnum = model;
         console.error(`🔍 CALLING: callOpenAIWithCustomParams with ${modelEnum}, skipValidation: ${options.skipValidation || false}`);
-        // Use temperature=1 (default) for GPT-5, 0.8 for others
-        const temperature = model.startsWith('gpt-5') ? 1.0 : 0.8;
-        const result = await callOpenAIWithCustomParams(messages, modelEnum, temperature, maxTokens, reasoningEffort, options.skipValidation || false);
+        const result = await callOpenAIWithCustomParams(messages, modelEnum, 0.9, maxTokens, reasoningEffort, options.skipValidation || false);
         console.error('🔍 DEBUG: Got result from callOpenAI:', result.substring(0, 100));
         console.error('✅ TOOL COMPLETE: openai_brainstorm');
         return result;
@@ -404,7 +496,7 @@ Format: Number each idea and provide a brief explanation.`
 };
 /**
  * OpenAI Code Review Tool
- * Comprehensive code review
+ * Comprehensive code review using GPT-5.1-codex-mini
  */
 export const openaiCodeReviewTool = {
     name: "openai_code_review",
@@ -432,12 +524,12 @@ Format: Use sections for different aspects, be specific about line numbers or fu
                 content: `Review this code:\n\`\`\`${args.language || ''}\n${args.code}\n\`\`\``
             }
         ];
-        return await callOpenAI(messages, OpenAIModel.GPT5_MINI, 0.7, 4000);
+        return await callOpenAI(messages, OpenAI51Model.CODEX_MINI, 0.3, 4000, "medium");
     }
 };
 /**
  * OpenAI Explain Tool
- * Clear explanations for complex topics
+ * Clear explanations for complex topics using GPT-5.1-codex-mini
  */
 export const openaiExplainTool = {
     name: "openai_explain",
@@ -472,7 +564,7 @@ Make the explanation clear, engaging, and memorable.`
                 content: `Explain: ${args.topic}`
             }
         ];
-        return await callOpenAI(messages, OpenAIModel.GPT5_MINI, 0.7, 2500);
+        return await callOpenAI(messages, OpenAI51Model.CODEX_MINI, 0.7, 2500, "low");
     }
 };
 /**
@@ -489,10 +581,10 @@ export function getAllOpenAITools() {
         return [];
     }
     return [
-        openaiGpt5ReasonTool, // GPT-5-mini reasoning
-        openaiCompareTool, // GPT-5-mini comparison
-        openAIBrainstormTool, // GPT-5-mini/GPT-5 brainstorming
-        openaiCodeReviewTool, // GPT-5-mini code review
-        openaiExplainTool // GPT-5-mini explanations
+        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/unified-ai-provider.js

@@ -15,13 +15,13 @@ const PROVIDER_CONFIGS = {
     openai: {
         base: 'https://api.openai.com/v1',
         key: process.env.OPENAI_API_KEY,
-        models: ['gpt-5', 'gpt-5-mini', 'gpt-5-nano']
+        models: ['gpt-5.1', 'gpt-5.1-codex-mini', 'gpt-5.1-codex']
     },
-    gpt5: {
+    gpt51: {
         base: 'https://api.openai.com/v1', // Uses /responses endpoint internally
         key: process.env.OPENAI_API_KEY,
-        models: ['gpt-5', 'gpt-5-mini', 'gpt-5-nano'],
-        special: true // Needs special handling
+        models: ['gpt-5.1', 'gpt-5.1-codex-mini', 'gpt-5.1-codex'],
+        special: true // Needs special handling for reasoning_effort
     },
     mistral: {
         base: 'https://api.mistral.ai/v1',
@@ -86,7 +86,7 @@ export async function queryAI(prompt, options) {
         throw new Error(`Provider ${options.provider} is not configured. Please set the appropriate API key.`);
     }
     // Handle GPT-5 special case
-    if (options.provider === 'gpt5' && 'special' in config && config.special) {
+    if (options.provider === 'gpt51' && 'special' in config && config.special) {
         return await handleGPT5(prompt, options);
     }
     // Standard OpenAI-compatible handling
@@ -118,18 +118,16 @@ export async function queryAI(prompt, options) {
  * Special handling for GPT-5 (uses /responses endpoint)
  */
 async function handleGPT5(prompt, options) {
-    const config = PROVIDER_CONFIGS.gpt5;
+    const config = PROVIDER_CONFIGS.gpt51;
     const endpoint = 'https://api.openai.com/v1/responses';
-    const model = options.model || 'gpt-5-nano'; // Default to cheapest
+    const model = options.model || 'gpt-5.1-codex-mini'; // Default to cheapest
     const requestBody = {
         model,
         input: prompt,
         reasoning: {
-            effort: model === 'gpt-5' ? 'high' : 'low'
+            effort: model === 'gpt-5.1' ? 'high' : 'low'
         },
-        text: {
-            verbosity: 'medium'
-        }
+        max_output_tokens: 4000
     };
     try {
         const response = await fetch(endpoint, {
@@ -145,7 +143,8 @@ async function handleGPT5(prompt, options) {
             throw new Error(`GPT-5 API error: ${error}`);
         }
         const data = await response.json();
-        return data.output || data.response || 'No response generated';
+        const messageOutput = data.output.find(item => item.type === 'message');
+        return messageOutput?.content?.[0]?.text || 'No response generated';
     }
     catch (error) {
         console.error('GPT-5 error:', error);

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

@@ -6,7 +6,7 @@ import { callGemini, GeminiModel } 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 { GPT5_MODELS, TOOL_DEFAULTS, } from "../config/model-constants.js";
+import { GPT51_MODELS, TOOL_DEFAULTS, } from "../config/model-constants.js";
 import { validateToolInput } from "../utils/input-validator.js";
 // Lazy load OpenRouter for Qwen models
 let callOpenRouter = null;
@@ -121,7 +121,7 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
         maxTokens: 2000,
         temperature: 0.7,
     };
-    const { model = toolDefaults.model || "gpt-5-mini", maxTokens = options.maxTokens ?? toolDefaults.maxTokens ?? 2000, temperature = options.temperature ?? toolDefaults.temperature ?? 0.7, systemPrompt, } = options;
+    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;
     // Helper to convert to messages array format
     const toMessages = (text, system) => {
         const messages = [];
@@ -136,7 +136,7 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
         return { result, modelUsed: actualModel };
     };
     try {
-        let actualModel = model; // Track the actual model used
+        let actualModel = model; // Track the actual model used (can be OpenAI51Model, GrokModel, or string)
         // Route to appropriate tool based on name
         switch (toolName) {
             // ============ GEMINI TOOLS ============
@@ -205,25 +205,21 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
             // ============ OPENAI TOOLS ============
             case "openai_brainstorm":
             case "openai_analyze":
-                actualModel = model || "gpt-5";
-                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), actualModel, temperature, maxTokens, false, // requireConfirmation
+                actualModel = (model || GPT51_MODELS.FULL);
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), actualModel, temperature, maxTokens, "low", // reasoningEffort
+                false, // requireConfirmation
                 options.skipValidation || false), actualModel);
             case "gpt5_analyze":
-                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), "gpt-5-mini", 0.7, maxTokens), "gpt-5-mini");
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), GPT51_MODELS.CODEX_MINI, 0.7, maxTokens), GPT51_MODELS.CODEX_MINI);
             case "openai_reason":
-                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), "gpt-5-mini", temperature, maxTokens), "gpt-5-mini");
+                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), GPT51_MODELS.CODEX_MINI, temperature, maxTokens), GPT51_MODELS.CODEX_MINI);
             // ============ GPT-5 TOOLS ============
             case "gpt5":
             case "gpt5_mini":
             case "gpt5_nano":
-                const gpt5Model = toolName === "gpt5_nano"
-                    ? GPT5_MODELS.NANO
-                    : toolName === "gpt5_mini"
-                        ? GPT5_MODELS.MINI
-                        : GPT5_MODELS.FULL;
-                // GPT-5 models only support temperature=1.0
-                return buildResult(await callOpenAI(toMessages(prompt, systemPrompt), gpt5Model, 1.0, // Fixed temperature for GPT-5
-                maxTokens), gpt5Model);
+                // 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);
             // ============ GROK TOOLS ============
             case "grok":
             case "grok_reason":
@@ -343,21 +339,21 @@ export async function executeWorkflowTool(toolName, input, options = {}) {
                 return buildResult(`[Architect mode not available]`, "error");
             // ============ META TOOLS ============
             case "think":
-                // Simple reflection tool - uses GPT-5-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."), "gpt-5-mini", 0.7, 500), "gpt-5-mini");
+                // 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);
             case "focus":
-                // Deep analysis tool - uses GPT-5
-                return buildResult(await callOpenAI(toMessages(`Perform deep analysis and synthesis:\n\n${prompt}`, "You are an advanced analytical assistant. Provide comprehensive, synthesized insights."), "gpt-5", 0.8, maxTokens), "gpt-5");
+                // 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);
             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."), "gpt-5", 0.5, maxTokens), "gpt-5");
+                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);
             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."), "gpt-5", 0.6, maxTokens), "gpt-5");
+                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);
             case "documentation_writer":
-                return buildResult(await callOpenAI(toMessages(`Create clear documentation:\n\n${prompt}`, "You are a technical writer. Create clear, comprehensive documentation."), "gpt-5-mini", 0.7, maxTokens), "gpt-5-mini");
+                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);
             // ============ DEFAULT ============
             default:
-                console.warn(`⚠️ Unknown tool: ${toolName}, falling back to GPT-5-mini`);
-                return buildResult(await callOpenAI(toMessages(prompt), "gpt-5-mini", temperature, maxTokens), "gpt-5-mini");
+                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);
         }
     }
     catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tachibot-mcp",
   "displayName": "TachiBot MCP - Universal AI Orchestrator",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "type": "module",
   "main": "dist/src/server.js",
   "bin": {