tachibot-mcp 2.2.0 → 2.2.5

package/dist/src/config/model-constants.js

@@ -7,30 +7,34 @@
 // OPENAI MODELS (provider-based naming)
 // =============================================================================
 // GPT-5.2 released Dec 11, 2025 - CURRENT
-// OpenRouter uses prefix: openai/gpt-5.2-pro, openai/gpt-5.2, openai/gpt-5.2-chat
+// Model is "gpt-5.2", "thinking" is controlled by reasoning.effort parameter
+// OpenRouter uses prefix: openai/gpt-5.2-pro, openai/gpt-5.2
 export const OPENAI_MODELS = {
     // GPT-5.2 Models (Dec 2025 - CURRENT)
-    THINKING: "gpt-5.2-thinking", // SOTA reasoning: 293% accuracy boost ($1.75/$14, 400K)
+    // Note: "gpt-5.2" + reasoning.effort="high"/"xhigh" = "thinking" mode
+    DEFAULT: "gpt-5.2", // Main model - use with reasoning.effort for "thinking"
     PRO: "gpt-5.2-pro", // Expert: programming, science, 88.4% GPQA ($21/$168, 400K)
-    INSTANT: "gpt-5.2-instant", // Fast: conversations, explanations ($1.75/$14, 400K)
     // Aliases for backward compatibility
-    FULL: "gpt-5.2-thinking", // Map old FULL to THINKING
-    CODEX_MINI: "gpt-5.2-instant", // Map old codex-mini to INSTANT
+    THINKING: "gpt-5.2", // "Thinking" = gpt-5.2 with high reasoning effort
+    INSTANT: "gpt-5.2", // Same model, just use lower reasoning effort
+    FULL: "gpt-5.2", // Map old FULL to DEFAULT
+    CODEX_MINI: "gpt-5.2", // Map old codex-mini to DEFAULT
     CODEX: "gpt-5.2-pro", // Map old codex to PRO
     CODEX_MAX: "gpt-5.2-pro", // Map old codex-max to PRO
 };
 // OpenRouter model ID mapping (add prefix when using OpenRouter gateway)
 export const OPENROUTER_PREFIX_MAP = {
-    "gpt-5.2-thinking": "openai/",
+    "gpt-5.2": "openai/",
     "gpt-5.2-pro": "openai/",
-    "gpt-5.2-instant": "openai/",
 };
 // OpenAI Reasoning Effort Levels (for models that support it)
+// Use with gpt-5.2: none=fast, low/medium=balanced, high/xhigh="thinking" mode
 export const OPENAI_REASONING = {
-    NONE: "none", // No extra reasoning (fastest, cheapest)
+    NONE: "none", // No extra reasoning (fastest, allows temperature)
     LOW: "low", // Light reasoning
     MEDIUM: "medium", // Balanced reasoning (default)
-    HIGH: "high", // Maximum reasoning (slowest, most thorough)
+    HIGH: "high", // Strong reasoning ("thinking" mode)
+    XHIGH: "xhigh", // Maximum reasoning (most thorough, slowest)
 };
 // =============================================================================
 // GEMINI MODELS (Google)
@@ -112,13 +116,17 @@ export const DEFAULT_WORKFLOW_SETTINGS = {
 // When new models release, update ONLY this section!
 // All tools automatically use the new models.
 // ============================================================================
-// UPDATED Dec 11, 2025: Migrated to GPT-5.2 (PRO for quality, THINKING for reasoning)
+// UPDATED Dec 12, 2025: Use gpt-5.2 with reasoning.effort for "thinking" mode
+// PRO available for opt-in when extra quality needed (12x more expensive)
 export const CURRENT_MODELS = {
     openai: {
-        reason: OPENAI_MODELS.THINKING, // Deep reasoning (gpt-5.2-thinking - 293% accuracy)
-        brainstorm: OPENAI_MODELS.PRO, // Creative ideation (gpt-5.2-pro - HIGH IQ)
-        code: OPENAI_MODELS.PRO, // Code tasks (gpt-5.2-pro - 88.4% GPQA)
-        explain: OPENAI_MODELS.PRO, // Explanations (gpt-5.2-pro - quality)
+        default: OPENAI_MODELS.DEFAULT, // gpt-5.2 - use with reasoning.effort
+        reason: OPENAI_MODELS.DEFAULT, // Deep reasoning (gpt-5.2 + effort=high)
+        brainstorm: OPENAI_MODELS.DEFAULT, // Creative ideation (gpt-5.2 + effort=medium)
+        code: OPENAI_MODELS.DEFAULT, // Code tasks (gpt-5.2 + effort=medium)
+        explain: OPENAI_MODELS.DEFAULT, // Explanations (gpt-5.2 + effort=low)
+        // Premium option for opt-in (use sparingly - 12x more expensive)
+        premium: OPENAI_MODELS.PRO, // Expert mode (gpt-5.2-pro - 88.4% GPQA, $21/$168)
     },
     grok: {
         reason: GROK_MODELS._4_1_FAST_REASONING,
@@ -244,7 +252,7 @@ export const TOOL_DEFAULTS = {
     think: {
         model: CURRENT_MODELS.openai.reason,
         reasoning_effort: OPENAI_REASONING.HIGH,
-        maxTokens: 500,
+        maxTokens: 4000,
         temperature: 0.7,
     },
     focus: {

package/dist/src/config/model-defaults.js

@@ -17,9 +17,9 @@ import { GEMINI_MODELS, OPENAI_MODELS, GROK_MODELS, PERPLEXITY_MODELS, KIMI_MODE
 const MODELS = {
     // Google Gemini
     GEMINI: GEMINI_MODELS.GEMINI_3_PRO, // gemini-3-pro-preview
-    // OpenAI
-    OPENAI: OPENAI_MODELS.CODEX_MINI, // gpt-5.1-codex-mini (default)
-    OPENAI_REASON: OPENAI_MODELS.FULL, // gpt-5.1 (deep reasoning)
+    // OpenAI (GPT-5.2)
+    OPENAI: OPENAI_MODELS.THINKING, // gpt-5.2-thinking (default - SOTA reasoning)
+    OPENAI_REASON: OPENAI_MODELS.THINKING, // gpt-5.2-thinking (deep reasoning)
     // xAI Grok
     GROK: GROK_MODELS._4_1_FAST_REASONING, // grok-4-1-fast-reasoning
     // Perplexity
@@ -50,7 +50,7 @@ export function getChallengerModels() {
 }
 /**
  * Get Verifier model configuration
- * All variants use Gemini 3 Pro; deep uses gpt-5.1 for max reasoning
+ * All variants use Gemini 3 Pro; deep uses gpt-5.2-thinking for max reasoning
  */
 export function getVerifierModels() {
     const quick = process.env.VERIFIER_QUICK_MODELS?.split(',').map(m => m.trim()) ||

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

@@ -4,25 +4,24 @@
  */
 export var ModelTier;
 (function (ModelTier) {
-    // Tier 0: Cheapest - GPT-5.1 Codex Mini
-    ModelTier["ULTRA_CHEAP"] = "gpt-5.1-codex-mini";
+    // Tier 0: Cheapest - GPT-5.2 Instant/Thinking (same price!)
+    ModelTier["ULTRA_CHEAP"] = "gpt-5.2-instant";
     // Tier 1: Ultra Fast & Cheap (< $0.001 per request)
     ModelTier["ULTRA_EFFICIENT"] = "gemini-2.5-flash";
-    ModelTier["EFFICIENT"] = "gpt-5.1-codex-mini";
-    // Tier 2: Balanced ($0.001-$0.01 per request)
-    ModelTier["STANDARD"] = "gpt-5.1-codex";
-    ModelTier["GPT5_MINI"] = "gpt-5.1-codex-mini";
+    ModelTier["EFFICIENT"] = "gpt-5.2-thinking";
+    // Tier 2: Balanced - GPT-5.2 Thinking (best value)
+    ModelTier["STANDARD"] = "gpt-5.2-thinking";
+    ModelTier["GPT5_MINI"] = "gpt-5.2-thinking";
     // Tier 3: Advanced ($0.01-$0.05 per request)
     ModelTier["WEB_SEARCH"] = "perplexity-sonar-pro";
-    // Tier 4: Premium (Use with caution)
-    ModelTier["GPT5_FULL"] = "gpt-5.1";
+    // Tier 4: Premium (Use with caution - 12x more expensive)
+    ModelTier["GPT5_FULL"] = "gpt-5.2-pro";
 })(ModelTier || (ModelTier = {}));
 const MODEL_COSTS = {
-    // GPT-5.1 Models (Nov 2025 pricing) - ACTUAL API MODEL NAMES
-    "gpt-5.1-codex-mini": { input: 0.002, output: 0.006, latency: 800 }, // CHEAPEST!
-    "gpt-5.1-codex": { input: 0.015, output: 0.045, latency: 1500 },
-    "gpt-5.1": { input: 0.010, output: 0.030, latency: 2000 },
-    "gpt-5-pro": { input: 0.020, output: 0.060, latency: 3000 },
+    // GPT-5.2 Models (Dec 2025 pricing) - ACTUAL API MODEL NAMES
+    "gpt-5.2-thinking": { input: 0.00175, output: 0.014, latency: 1500 }, // SOTA reasoning, cheap!
+    "gpt-5.2-instant": { input: 0.00175, output: 0.014, latency: 800 }, // Fast, same price
+    "gpt-5.2-pro": { input: 0.021, output: 0.168, latency: 2500 }, // Premium (12x more)
     // Gemini models
     "gemini-2.5-flash": { input: 0.000075, output: 0.0003, latency: 500 },
     "gemini-2.5-pro": { input: 0.00015, output: 0.0006, latency: 1000 },
@@ -103,7 +102,7 @@ export class SmartModelRouter {
             const gpt5Enabled = process.env.ENABLE_GPT5 !== "false";
             if (gpt5Enabled) {
                 return {
-                    primary: ModelTier.ULTRA_CHEAP, // gpt-5.1-codex-mini
+                    primary: ModelTier.ULTRA_CHEAP, // gpt-5.2-instant
                     fallback: ModelTier.ULTRA_EFFICIENT, // gemini-2.5-flash
                     estimatedCost: 0.002,
                     estimatedLatency: 800,

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

@@ -1,6 +1,7 @@
 /**
  * OpenAI Tools Implementation
- * Provides GPT-5.1 model capabilities with reasoning_effort control
+ * Provides GPT-5.2 model capabilities with reasoning_effort control
+ * Uses centralized model constants from model-constants.ts
  */
 import { z } from "zod";
 import { config } from "dotenv";
@@ -8,6 +9,7 @@ import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { validateToolInput } from "../utils/input-validator.js";
 import { tryOpenRouterGateway, isGatewayEnabled } from "../utils/openrouter-gateway.js";
+import { OPENAI_MODELS } from "../config/model-constants.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 config({ path: path.resolve(__dirname, '../../../.env') });
@@ -71,20 +73,40 @@ const ResponsesAPISchema = z.object({
         total_tokens: z.number().optional()
     }).optional()
 });
-// 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 = {}));
+// Type guard for safe fallback extraction
+function isPartialChatCompletion(data) {
+    if (typeof data !== 'object' || data === null)
+        return false;
+    const obj = data;
+    return Array.isArray(obj.choices);
+}
+// Type guard for Responses API fallback extraction
+function isPartialResponsesAPI(data) {
+    if (typeof data !== 'object' || data === null)
+        return false;
+    const obj = data;
+    return Array.isArray(obj.output);
+}
+// Re-export for backward compatibility (maps to gpt-5.2 models)
+// "Thinking" mode = gpt-5.2 with reasoning.effort="high"/"xhigh"
+export const OpenAI52Model = {
+    DEFAULT: OPENAI_MODELS.DEFAULT, // gpt-5.2 (use with reasoning.effort)
+    THINKING: OPENAI_MODELS.DEFAULT, // gpt-5.2 + high effort = "thinking"
+    PRO: OPENAI_MODELS.PRO, // gpt-5.2-pro (expert mode)
+    INSTANT: OPENAI_MODELS.DEFAULT, // gpt-5.2 + low effort = fast
+    // Legacy aliases
+    FULL: OPENAI_MODELS.DEFAULT,
+    CODEX_MINI: OPENAI_MODELS.DEFAULT,
+    CODEX: OPENAI_MODELS.PRO,
+};
+// Backward compatibility alias
+export const OpenAI51Model = OpenAI52Model;
 /**
  * Call OpenAI API with model fallback support
- * Automatically detects GPT-5.1 models and uses correct endpoint + format
+ * GPT-5.2 uses /v1/responses endpoint for all models
  */
-export async function callOpenAI(messages, model = OpenAI51Model.CODEX_MINI, temperature = 0.7, maxTokens = 16384, // Increased default for comprehensive responses
+export async function callOpenAI(messages, model = OPENAI_MODELS.INSTANT, // Default to fast/cheap model
+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
@@ -114,11 +136,10 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
         }
         return { ...msg, content: validation.sanitized };
     });
-    // Model fallback chain - GPT-5.1 models have no fallbacks to test actual availability
+    // Model fallback chain - GPT-5.2 models have no fallbacks to test actual availability
     const modelFallbacks = {
-        [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
+        "gpt-5.2": [], // No fallback - test actual gpt-5.2
+        "gpt-5.2-pro": [] // No fallback - test actual gpt-5.2-pro
     };
     const modelsToTry = [model, ...(modelFallbacks[model] || [])];
     console.error(`🔍 TRACE: Models to try: ${modelsToTry.join(', ')}`);
@@ -126,33 +147,37 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
     for (const currentModel of modelsToTry) {
         console.error(`🔍 TRACE: Trying model: ${currentModel}`);
         try {
-            // 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;
+            // GPT-5.2 uses Responses API, others use Chat Completions
+            const isGPT52 = currentModel.startsWith('gpt-5.2');
+            const endpoint = isGPT52 ? OPENAI_RESPONSES_URL : OPENAI_CHAT_URL;
             let requestBody;
-            if (isCodex) {
-                // Responses API format for codex models
+            if (isGPT52) {
+                // Responses API format for GPT-5.2
+                // Input is array of message objects [{role, content}]
+                const inputMessages = validatedMessages.map(m => ({
+                    role: m.role,
+                    content: m.content
+                }));
                 requestBody = {
                     model: currentModel,
-                    input: validatedMessages,
-                    max_output_tokens: maxTokens,
-                    stream: false,
+                    input: inputMessages,
                     reasoning: {
-                        effort: reasoningEffort
-                    }
+                        effort: reasoningEffort || 'medium'
+                    },
+                    max_output_tokens: maxTokens
                 };
             }
             else {
-                // Chat Completions format for non-codex GPT-5 models (gpt-5.1, gpt-5-pro)
+                // Chat Completions format for older models
                 requestBody = {
                     model: currentModel,
                     messages: validatedMessages,
-                    temperature,
-                    max_completion_tokens: maxTokens, // GPT-5 requires max_completion_tokens (not max_tokens)
+                    max_completion_tokens: maxTokens,
+                    temperature: temperature,
                     stream: false
                 };
             }
-            console.error(`🔍 TRACE: Using ${isCodex ? '/v1/responses' : '/v1/chat/completions'} endpoint`);
+            console.error(`🔍 TRACE: Using ${isGPT52 ? '/v1/responses' : '/v1/chat/completions'} endpoint for ${currentModel}`);
             const response = await fetch(endpoint, {
                 method: "POST",
                 headers: {
@@ -173,25 +198,37 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
                 throw new Error(lastError);
             }
             const rawData = await response.json();
-            // Parse based on API type
+            // Parse response based on API type
             let rawContent;
-            if (isCodex) {
-                // Responses API format
+            if (isGPT52) {
+                // Parse Responses API response for GPT-5.2
                 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;
-                    if (data.reasoning) {
-                        console.error(`🔍 TRACE: Reasoning effort: ${data.reasoning.effort}`);
+                    const responsesData = parseResult.data;
+                    // Extract text from output array - find first message with content
+                    for (const outputItem of responsesData.output) {
+                        if (outputItem.content) {
+                            for (const contentItem of outputItem.content) {
+                                if (contentItem.text) {
+                                    rawContent = contentItem.text;
+                                    break;
+                                }
+                            }
+                        }
+                        if (rawContent)
+                            break;
                     }
                 }
                 else {
                     console.error(`🔍 TRACE: Failed to parse Responses API response:`, parseResult.error);
+                    // Safe fallback using type guard
+                    if (isPartialResponsesAPI(rawData)) {
+                        rawContent = rawData.output?.[0]?.content?.[0]?.text;
+                    }
                 }
             }
             else {
-                // Chat Completions format
+                // Parse Chat Completions response for older models
                 const parseResult = ChatCompletionResponseSchema.safeParse(rawData);
                 if (parseResult.success) {
                     const chatData = parseResult.data;
@@ -199,6 +236,10 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
                 }
                 else {
                     console.error(`🔍 TRACE: Failed to parse Chat Completions response:`, parseResult.error);
+                    // Safe fallback using type guard
+                    if (isPartialChatCompletion(rawData)) {
+                        rawContent = rawData.choices?.[0]?.message?.content;
+                    }
                 }
             }
             // Ensure result is always a string
@@ -213,13 +254,13 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
         }
     }
     console.error(`🔍 TRACE: ALL MODELS FAILED - Last error: ${lastError}`);
-    return `[GPT-5.1 model "${model}" not available. Error: ${lastError}]`;
+    return `[GPT-5.2 model "${model}" not available. Error: ${lastError}]`;
 }
 /**
  * Call OpenAI API with custom parameters for specific models
- * Automatically detects GPT-5.1 models and uses correct endpoint + format
+ * GPT-5.2 models use /v1/responses endpoint
  */
-async function callOpenAIWithCustomParams(messages, model, temperature = 0.7, maxTokens = 16384, // Increased for detailed brainstorming
+async function callOpenAIWithCustomParams(messages, model = OPENAI_MODELS.DEFAULT, 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
@@ -249,34 +290,38 @@ reasoningEffort = "low", skipValidation = false) {
         return { ...msg, content: validation.sanitized };
     });
     try {
-        // 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;
+        // GPT-5.2 uses Responses API, others use Chat Completions
+        const isGPT52 = model.startsWith('gpt-5.2');
+        const endpoint = isGPT52 ? OPENAI_RESPONSES_URL : OPENAI_CHAT_URL;
         let requestBody;
-        if (isCodex) {
-            // Responses API format for codex models
+        if (isGPT52) {
+            // Responses API format for GPT-5.2
+            // Input is array of message objects [{role, content}]
+            const inputMessages = validatedMessages.map(m => ({
+                role: m.role,
+                content: m.content
+            }));
             requestBody = {
                 model: model,
-                input: validatedMessages,
-                max_output_tokens: maxTokens, // NOT max_completion_tokens or max_tokens!
-                stream: false,
+                input: inputMessages,
                 reasoning: {
-                    effort: reasoningEffort // "none", "low", "medium", "high"
-                }
+                    effort: reasoningEffort || 'medium'
+                },
+                max_output_tokens: maxTokens
             };
         }
         else {
-            // Chat Completions format for non-codex GPT-5 models (gpt-5.1, gpt-5-pro)
+            // Chat Completions format for older models
             requestBody = {
                 model: model,
                 messages: validatedMessages,
-                temperature,
-                max_completion_tokens: maxTokens, // GPT-5 requires max_completion_tokens (not max_tokens)
+                max_completion_tokens: maxTokens,
+                temperature: temperature,
                 stream: false
             };
         }
-        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}`}`);
+        console.error(`🔍 TRACE: Using ${isGPT52 ? '/v1/responses' : '/v1/chat/completions'} endpoint for ${model}`);
+        console.error(`🔍 TRACE: Model params: max_tokens=${maxTokens}, reasoning_effort=${reasoningEffort}`);
         const response = await fetch(endpoint, {
             method: "POST",
             headers: {
@@ -291,26 +336,35 @@ reasoningEffort = "low", skipValidation = false) {
             return `[${model} failed: ${response.status} - ${error}]`;
         }
         const rawData = await response.json();
-        // Parse based on API type - they have DIFFERENT response formats!
+        // Parse response based on API type
         let rawContent;
-        if (isCodex) {
-            // Validate and parse Responses API format
+        if (isGPT52) {
+            // Parse Responses API response for GPT-5.2
             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}`);
+                const responsesData = parseResult.data;
+                for (const outputItem of responsesData.output) {
+                    if (outputItem.content) {
+                        for (const contentItem of outputItem.content) {
+                            if (contentItem.text) {
+                                rawContent = contentItem.text;
+                                break;
+                            }
+                        }
+                    }
+                    if (rawContent)
+                        break;
                 }
             }
             else {
                 console.error(`🔍 TRACE: Failed to parse Responses API response:`, parseResult.error);
+                if (isPartialResponsesAPI(rawData)) {
+                    rawContent = rawData.output?.[0]?.content?.[0]?.text;
+                }
             }
         }
         else {
-            // Validate and parse Chat Completions API format
+            // Parse Chat Completions response for older models
             const parseResult = ChatCompletionResponseSchema.safeParse(rawData);
             if (parseResult.success) {
                 const chatData = parseResult.data;
@@ -318,6 +372,9 @@ reasoningEffort = "low", skipValidation = false) {
             }
             else {
                 console.error(`🔍 TRACE: Failed to parse Chat Completions response:`, parseResult.error);
+                if (isPartialChatCompletion(rawData)) {
+                    rawContent = rawData.choices?.[0]?.message?.content;
+                }
             }
         }
         // Ensure result is always a string
@@ -364,8 +421,8 @@ export const gpt5ReasonTool = {
                 content: args.query
             }
         ];
-        // Use GPT-5.1 with high reasoning
-        return await callOpenAI(messages, OpenAI51Model.FULL, 0.7, 4000, "high");
+        // Use GPT-5.2-thinking with high reasoning
+        return await callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.7, 4000, "high");
     }
 };
 /**
@@ -396,13 +453,13 @@ export const gpt5MiniReasonTool = {
                 content: args.query
             }
         ];
-        // Use GPT-5.1-codex-mini with medium reasoning
-        return await callOpenAI(messages, OpenAI51Model.CODEX_MINI, 0.7, 3000, "medium");
+        // Use GPT-5.2-thinking with medium reasoning (cost-effective)
+        return await callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.7, 3000, "medium");
     }
 };
 export const openaiGpt5ReasonTool = {
     name: "openai_reason",
-    description: "Mathematical reasoning using GPT-5.1 with high reasoning effort",
+    description: "Mathematical reasoning using GPT-5.2-thinking with high reasoning effort",
     parameters: z.object({
         query: z.string(),
         context: z.string().optional(),
@@ -428,8 +485,8 @@ ${args.context ? `Context: ${args.context}` : ''}`
                 content: args.query
             }
         ];
-        // Use GPT-5.1 with high reasoning effort for complex reasoning
-        return await callOpenAI(messages, OpenAI51Model.FULL, 0.7, 4000, "high");
+        // Use GPT-5.2-thinking with high reasoning effort for complex reasoning
+        return await callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.7, 4000, "high");
     }
 };
 /**
@@ -444,12 +501,13 @@ export const openAIBrainstormTool = {
         constraints: z.string().optional(),
         quantity: z.number().optional(),
         style: z.enum(["innovative", "practical", "wild", "systematic"]).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(),
+        model: z.enum(["gpt-5.2", "gpt-5.2-pro"]).optional(),
+        reasoning_effort: z.enum(["none", "low", "medium", "high", "xhigh"]).optional(),
         max_tokens: z.number().optional()
     }),
     execute: async (args, options = {}) => {
-        const { problem, constraints, quantity = 5, style = "innovative", model = "gpt-5.1-codex-mini", reasoning_effort = "medium", max_tokens = 4000 } = args;
+        const { problem, constraints, quantity = 5, style = "innovative", model = OPENAI_MODELS.DEFAULT, // Default to gpt-5.2 (use reasoning.effort for "thinking")
+        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));
@@ -516,7 +574,7 @@ 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, OpenAI51Model.CODEX_MINI, 0.3, 4000, "medium");
+        return await callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.3, 4000, "medium");
     }
 };
 /**
@@ -556,7 +614,7 @@ Make the explanation clear, engaging, and memorable.`
                 content: `Explain: ${args.topic}`
             }
         ];
-        return await callOpenAI(messages, OpenAI51Model.CODEX_MINI, 0.7, 2500, "low");
+        return await callOpenAI(messages, OPENAI_MODELS.DEFAULT, 0.7, 2500, "low");
     }
 };
 /**
@@ -573,9 +631,9 @@ export function getAllOpenAITools() {
         return [];
     }
     return [
-        openaiGpt5ReasonTool, // GPT-5.1 reasoning (high 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)
+        openaiGpt5ReasonTool, // GPT-5.2-thinking reasoning (high effort)
+        openAIBrainstormTool, // GPT-5.2-thinking brainstorming (medium effort)
+        openaiCodeReviewTool, // GPT-5.2-thinking code review (medium effort)
+        openaiExplainTool // GPT-5.2-thinking explanations (low effort)
     ];
 }

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

@@ -59,12 +59,12 @@ const PROVIDER_CONFIGS = {
     openai: {
         base: 'https://api.openai.com/v1',
         key: process.env.OPENAI_API_KEY,
-        models: ['gpt-5.1', 'gpt-5.1-codex-mini', 'gpt-5.1-codex']
+        models: ['gpt-5.2', 'gpt-5.2-pro'] // gpt-5.2 with reasoning.effort for "thinking"
     },
-    gpt51: {
-        base: 'https://api.openai.com/v1', // Uses /responses endpoint internally
+    gpt52: {
+        base: 'https://api.openai.com/v1', // Uses /responses endpoint
         key: process.env.OPENAI_API_KEY,
-        models: ['gpt-5.1', 'gpt-5.1-codex-mini', 'gpt-5.1-codex'],
+        models: ['gpt-5.2', 'gpt-5.2-pro'], // reasoning.effort controls "thinking" mode
         special: true // Needs special handling for reasoning_effort
     },
     mistral: {
@@ -167,9 +167,9 @@ export async function queryAI(prompt, options) {
             }
         } // 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);
+    // Handle GPT-5.2 special case (direct API only)
+    if (options.provider === 'gpt52' && 'special' in providerConfig && providerConfig.special) {
+        return await handleGPT52(prompt, options);
     }
     // Standard OpenAI-compatible handling (direct API)
     const client = new OpenAI({
@@ -196,19 +196,28 @@ export async function queryAI(prompt, options) {
     }
 }
 /**
- * Special handling for GPT-5 (uses /responses endpoint)
+ * Special handling for GPT-5.2 (uses /v1/responses endpoint)
  */
-async function handleGPT5(prompt, options) {
-    const config = PROVIDER_CONFIGS.gpt51;
+async function handleGPT52(prompt, options) {
+    const config = PROVIDER_CONFIGS.gpt52;
     const endpoint = 'https://api.openai.com/v1/responses';
-    const model = options.model || 'gpt-5.1-codex-mini'; // Default to cheapest
+    // Default to gpt-5.2 model (use reasoning.effort for "thinking" mode)
+    const model = options.model || 'gpt-5.2';
+    // Reasoning effort based on model - "high" for "thinking" mode
+    // gpt-5.2-pro gets high effort, gpt-5.2 uses medium by default
+    const reasoningEffort = model === 'gpt-5.2-pro' ? 'high' : 'medium';
+    // Build input as array of message objects
+    const inputMessages = [
+        ...(options.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+        { role: 'user', content: prompt }
+    ];
     const requestBody = {
         model,
-        input: prompt,
+        input: inputMessages,
         reasoning: {
-            effort: model === 'gpt-5.1' ? 'high' : 'low'
+            effort: reasoningEffort
         },
-        max_output_tokens: 4000
+        max_output_tokens: options.maxTokens || 4000
     };
     try {
         const response = await fetch(endpoint, {
@@ -221,14 +230,29 @@ async function handleGPT5(prompt, options) {
         });
         if (!response.ok) {
             const error = await response.text();
-            throw new Error(`GPT-5 API error: ${error}`);
+            throw new Error(`GPT-5.2 API error: ${error}`);
         }
         const data = await response.json();
-        const messageOutput = data.output.find(item => item.type === 'message');
-        return messageOutput?.content?.[0]?.text || 'No response generated';
+        // Extract text from Responses API output
+        let result;
+        if (data.output) {
+            for (const outputItem of data.output) {
+                if (outputItem.content) {
+                    for (const contentItem of outputItem.content) {
+                        if (contentItem.text) {
+                            result = contentItem.text;
+                            break;
+                        }
+                    }
+                }
+                if (result)
+                    break;
+            }
+        }
+        return result || 'No response generated';
     }
     catch (error) {
-        console.error('GPT-5 error:', error);
+        console.error('GPT-5.2 error:', error);
         throw error;
     }
 }

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

@@ -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.1-codex-mini",
+                    model: model || "gpt-5.2-thinking",
                     maxTokens: resolvedParams.maxTokens,
                 });
                 if (optimized.fromCache) {

package/package.json

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

package/workflows/core/iterative-problem-solver.yaml

@@ -87,7 +87,7 @@ steps:
     input:
       query: "Synthesize the best solution for: ${input}"
       rounds: 3
-      models: ["grok-4-fast-reasoning", "gpt-5.1", "gemini-2.5"]
+      models: ["grok-4-1-fast-reasoning", "gpt-5.2-thinking", "gemini-3-pro-preview"]
       context: |
         Research: ${research_context}
         Problem breakdown: ${problem_breakdown}
@@ -206,7 +206,7 @@ steps:
       problem: "Create comprehensive solution for: ${input}"
       style: "systematic"
       reasoning_effort: "high"
-      model: "gpt-5.1"
+      model: "gpt-5.2-thinking"
       context: |
         COMPLETE WORKFLOW CONTEXT:
 

package/workflows/system/scout.yaml

@@ -107,7 +107,7 @@ steps:
         4. Confidence levels for different claims
         5. Actionable recommendations based on the synthesis
       mode: "analyze"
-      models: ["gpt-5.1-codex-mini", "gemini-2.5-pro", "gemini-2.5-flash", "grok-4-fast-reasoning"]
+      models: ["gpt-5.2-thinking", "gemini-3-pro-preview", "grok-4-1-fast-reasoning"]
       rounds: 2
       domain: "research"
     saveToFile: true

package/workflows/ultra-creative-brainstorm.yaml

@@ -195,7 +195,7 @@ steps:
     input:
       query: "${query} - explore creative applications across domains"
       mode: "code-brainstorm"
-      models: ["gpt-5.1", "gemini-2.5-flash", "grok-4-1-fast-reasoning"]
+      models: ["gpt-5.2-thinking", "gemini-3-pro-preview", "grok-4-1-fast-reasoning"]
       rounds: 3
       context: "Research: ${research_findings}\nIdeas: ${innovative_solutions}\nPatterns: ${patterns}"
     saveToFile: true
@@ -210,7 +210,7 @@ steps:
       problem: "Synthesize all perspectives and ideas for ${query} into coherent solutions"
       style: "systematic"
       reasoning_effort: "high"
-      model: "gpt-5.1"
+      model: "gpt-5.2-thinking"
       context: |
         COMPREHENSIVE CONTEXT: