tachibot-mcp 2.0.2 → 2.0.4

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/perplexity-tools.js

@@ -14,12 +14,8 @@ function getPerplexityApiKey() {
 function debugApiKey() {
     const apiKey = getPerplexityApiKey();
     console.error('[PERPLEXITY DEBUG] API Key present:', !!apiKey);
-    if (apiKey) {
-        console.error('[PERPLEXITY DEBUG] Key length:', apiKey.length);
-        console.error('[PERPLEXITY DEBUG] Key prefix:', apiKey.substring(0, 8) + '...');
-    }
-    else {
-        console.error('[PERPLEXITY DEBUG] process.env keys:', Object.keys(process.env).filter(k => k.includes('PERP') || k.includes('API')));
+    if (!apiKey) {
+        console.error('[PERPLEXITY DEBUG] Environment variables containing PERP or API found:', Object.keys(process.env).filter(k => k.includes('PERP') || k.includes('API')).length);
     }
 }
 // Available Perplexity models (2025 latest)

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/engine/handlers/StepExecutionHandler.js

@@ -161,7 +161,7 @@ export class StepExecutionHandler {
         if (match) {
             const [, variable, expectedValue] = match;
             const actualValue = variables[variable];
-            return String(actualValue).trim() === expectedValue.trim().replace(/['"]/, '');
+            return String(actualValue).trim() === expectedValue.trim().replace(/['"]/g, '');
         }
         // Default: check if variable exists and is truthy
         return !!variables[condition];