tachibot-mcp 2.0.2

package/dist/src/tools/grok-enhanced.js

@@ -0,0 +1,376 @@
+/**
+ * Enhanced Grok Tools with Live Search and Heavy Mode Support
+ * Implements Grok-4 with proper model names and live search capability
+ */
+import { z } from "zod";
+import { config } from "dotenv";
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+config({ path: path.resolve(__dirname, '../../../.env') });
+// Grok API configuration
+const GROK_API_KEY = process.env.GROK_API_KEY || process.env.XAI_API_KEY;
+const GROK_API_URL = "https://api.x.ai/v1/chat/completions";
+// Grok models - Updated 2025-11-07 with new fast models
+export var GrokModel;
+(function (GrokModel) {
+    // New fast models (2025) - PRIMARY USE
+    GrokModel["CODE_FAST"] = "grok-code-fast-1";
+    GrokModel["GROK_4_FAST_REASONING"] = "grok-4-fast-reasoning";
+    GrokModel["GROK_4_FAST"] = "grok-4-fast-non-reasoning";
+    // Expensive/specialized (use sparingly)
+    GrokModel["GROK_4_HEAVY"] = "grok-4-0709";
+    GrokModel["GROK_3"] = "grok-3";
+    // Beta/experimental (deprecated)
+    GrokModel["GROK_BETA"] = "grok-beta";
+    GrokModel["GROK_VISION_BETA"] = "grok-vision-beta";
+})(GrokModel || (GrokModel = {}));
+/**
+ * Enhanced Grok API call with live search support
+ */
+export async function callGrokEnhanced(messages, options = {}) {
+    if (!GROK_API_KEY) {
+        return {
+            content: `[Grok API key not configured. Add GROK_API_KEY or XAI_API_KEY to .env file]`
+        };
+    }
+    const { model = GrokModel.GROK_4_FAST_REASONING, // Changed: Use cheap fast reasoning by default
+    temperature = 0.7, maxTokens = options.useHeavy ? 100000 : 4000, enableLiveSearch = false, searchSources = 100, // Default to 100 sources for cost control
+    searchDomains = [], structuredOutput = false } = options;
+    try {
+        const requestBody = {
+            model,
+            messages,
+            temperature,
+            max_tokens: maxTokens,
+            stream: false
+        };
+        // Add live search configuration if enabled (following official xAI docs exactly)
+        if (enableLiveSearch) {
+            // Only use search_parameters as documented - NO tools array
+            requestBody.search_parameters = {
+                mode: "on", // Force search on
+                max_search_results: searchSources || 20,
+                return_citations: true
+            };
+            // Add sources if specific domains requested
+            if (searchDomains && searchDomains.length > 0) {
+                requestBody.search_parameters.sources = [{
+                        type: "web",
+                        allowed_websites: searchDomains.slice(0, 5) // Max 5 websites
+                    }];
+            }
+            // If no specific domains, sources will default to web, news, and x
+        }
+        // Enable structured output if requested
+        if (structuredOutput) {
+            requestBody.response_format = { type: "json_object" };
+        }
+        // Heavy mode would be handled by subscription/tier, not headers in body
+        // Removed incorrect header addition to request body
+        // Debug logging for search requests
+        if (enableLiveSearch) {
+            console.error('[Grok Search Debug] Model:', model);
+            console.error('[Grok Search Debug] Request body:', JSON.stringify(requestBody, null, 2));
+            console.error('[Grok Search Debug] API URL:', GROK_API_URL);
+        }
+        const response = await fetch(GROK_API_URL, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${GROK_API_KEY}`,
+                "Content-Type": "application/json",
+                // Add heavy mode header here if needed
+                ...(options.useHeavy ? { 'X-Grok-Mode': 'heavy' } : {})
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Grok API error: ${response.statusText} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content || "No response from Grok";
+        // Extract sources if live search was used
+        const sources = data.choices?.[0]?.message?.sources || [];
+        return {
+            content,
+            sources,
+            usage: data.usage // Include token and cost information
+        };
+    }
+    catch (error) {
+        return {
+            content: `[Grok error: ${error instanceof Error ? error.message : String(error)}]`
+        };
+    }
+}
+/**
+ * Enhanced Scout Tool with Grok-4 Live Search
+ * Quick research with real-time web data
+ */
+export const grokScoutTool = {
+    name: "grok_scout",
+    description: "Quick research",
+    parameters: z.object({
+        query: z.string(),
+        enableLiveSearch: z.boolean().optional(),
+        searchSources: z.number().optional(),
+        searchDomains: z.array(z.string()).optional(),
+        variant: z.enum(["quick", "deep", "technical", "academic"]).optional()
+    }),
+    execute: async (args, { log }) => {
+        const { query, enableLiveSearch = true, searchSources = 50, searchDomains, variant = "quick" } = args;
+        const variantPrompts = {
+            quick: "Provide a quick, concise overview with key facts",
+            deep: "Conduct thorough research with multiple perspectives",
+            technical: "Focus on technical details and implementation aspects",
+            academic: "Provide scholarly analysis with citations"
+        };
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok in research mode with live search capability.
+${variantPrompts[variant]}.
+Use live search to find the most current and relevant information.
+Cite your sources when using web data.`
+            },
+            {
+                role: "user",
+                content: query
+            }
+        ];
+        log?.info(`Grok Scout: ${variant} research with ${enableLiveSearch ? 'live search' : 'knowledge base'} (using ${enableLiveSearch ? 'grok-4-fast-reasoning with search' : 'grok-4-fast-reasoning'})`);
+        const result = await callGrokEnhanced(messages, {
+            model: GrokModel.GROK_4_FAST_REASONING, // Changed: Use fast reasoning (works with search)
+            enableLiveSearch,
+            searchSources,
+            searchDomains,
+            temperature: 0.5, // Lower temperature for factual research
+            maxTokens: 5000
+        });
+        // Format response with sources
+        if (result.sources && result.sources.length > 0) {
+            const sourcesText = result.sources
+                .slice(0, 5) // Limit to top 5 sources
+                .map((s, i) => `[${i + 1}] ${s.title || s.url}`)
+                .join('\n');
+            return `${result.content}\n\n**Sources:**\n${sourcesText}`;
+        }
+        return result.content;
+    }
+};
+/**
+ * Enhanced Reasoning Tool with configurable Heavy mode
+ */
+export const grokReasonEnhanced = {
+    name: "grok_reason_v4",
+    description: "Deep reasoning",
+    parameters: z.object({
+        problem: z.string(),
+        approach: z.enum(["analytical", "creative", "systematic", "first-principles", "multi-agent"]).optional(),
+        context: z.string().optional(),
+        useHeavy: z.boolean().optional(),
+        enableLiveSearch: z.boolean().optional(),
+        maxSteps: z.number().optional()
+    }),
+    execute: async (args, { log }) => {
+        const { problem, approach = "first-principles", context, useHeavy = false, enableLiveSearch = false, maxSteps = 5 } = args;
+        const approachPrompts = {
+            analytical: "Break down the problem systematically and analyze each component",
+            creative: "Think outside the box and consider unconventional solutions",
+            systematic: "Follow a step-by-step logical process",
+            "first-principles": "Break down to fundamental truths and build up from there",
+            "multi-agent": "Consider multiple perspectives and synthesize them"
+        };
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok-4 in ${useHeavy ? 'Heavy' : 'Standard'} reasoning mode.
+${approachPrompts[approach]}.
+${context ? `Context: ${context}` : ''}
+Maximum reasoning steps: ${maxSteps}
+${enableLiveSearch ? 'Use live search for current information when needed.' : ''}`
+            },
+            {
+                role: "user",
+                content: problem
+            }
+        ];
+        const modelName = useHeavy ? 'Grok-4-Heavy' : 'Grok-4-Fast-Reasoning';
+        const costInfo = useHeavy ? '$3/$15 (expensive!)' : '$0.20/$0.50 (cheap!)';
+        log?.info(`Using ${modelName} (${approach}) with ${enableLiveSearch ? 'live search' : 'knowledge base'} - Cost: ${costInfo}`);
+        const result = await callGrokEnhanced(messages, {
+            model: useHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_FAST_REASONING, // Changed: Use fast reasoning unless heavy requested
+            useHeavy,
+            enableLiveSearch,
+            searchSources: 50,
+            temperature: 0.7,
+            maxTokens: useHeavy ? 100000 : 10000
+        });
+        // Add usage info if Heavy mode
+        if (useHeavy && result.usage) {
+            const costEstimate = (result.usage.total_tokens / 1000) * 0.015; // Rough estimate
+            return `${result.content}\n\n---\n*Heavy mode used: ${result.usage.total_tokens} tokens (~$${costEstimate.toFixed(3)})*`;
+        }
+        return result.content;
+    }
+};
+/**
+ * Function Calling Tool - demonstrates Grok-4's function calling capability
+ */
+export const grokFunctionTool = {
+    name: "grok_function",
+    description: "Use Grok-4's function calling to integrate with external tools",
+    parameters: z.object({
+        task: z.string(),
+        availableFunctions: z.array(z.object({
+            name: z.string(),
+            description: z.string(),
+            parameters: z.any()
+        })),
+        useHeavy: z.boolean().optional().default(false)
+    }),
+    execute: async (args, { log }) => {
+        // Convert to OpenAI-compatible tool format
+        const tools = args.availableFunctions.map((fn) => ({
+            type: "function",
+            function: {
+                name: fn.name,
+                description: fn.description,
+                parameters: fn.parameters
+            }
+        }));
+        const messages = [
+            {
+                role: "system",
+                content: "You are Grok-4 with function calling capability. Use the provided functions to complete the task."
+            },
+            {
+                role: "user",
+                content: args.task
+            }
+        ];
+        // Make request with tools
+        const requestBody = {
+            model: args.useHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_FAST_REASONING, // Changed: Use fast reasoning unless heavy requested
+            messages,
+            tools,
+            tool_choice: "auto", // Let Grok decide when to call functions
+            max_tokens: args.useHeavy ? 50000 : 5000,
+            temperature: 0.3 // Lower for function calling
+        };
+        log?.info(`Function calling with ${args.useHeavy ? 'Grok-4-Heavy ($3/$15)' : 'Grok-4-Fast-Reasoning ($0.20/$0.50)'}`);
+        try {
+            const response = await fetch(GROK_API_URL, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${GROK_API_KEY}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify(requestBody)
+            });
+            const data = await response.json();
+            // Check if Grok made tool calls
+            const toolCalls = data.choices?.[0]?.message?.tool_calls || [];
+            if (toolCalls.length > 0) {
+                const callsDesc = toolCalls.map((tc) => `- ${tc.function.name}(${tc.function.arguments})`).join('\n');
+                return `Grok-4 would call these functions:\n${callsDesc}\n\n${data.choices?.[0]?.message?.content || ''}`;
+            }
+            return data.choices?.[0]?.message?.content || "No function calls made";
+        }
+        catch (error) {
+            return `Function calling error: ${error}`;
+        }
+    }
+};
+/**
+ * Cost-optimized Live Search Tool
+ */
+export const grokSearchTool = {
+    name: "grok_search",
+    description: "Web search",
+    parameters: z.object({
+        query: z.string(),
+        sources: z.array(z.object({
+            type: z.enum(["web", "news", "x", "rss"]),
+            country: z.string().optional(),
+            allowed_websites: z.array(z.string()).optional()
+        })).optional(),
+        max_search_results: z.number().optional(),
+        recency: z.enum(["all", "day", "week", "month", "year"]).optional()
+    }),
+    execute: async (args, { log }) => {
+        const { query, sources = [{ type: "web" }], max_search_results = 20, recency = "all" } = args;
+        const recencyPrompt = recency !== "all"
+            ? `Focus on information from the last ${recency}.`
+            : "";
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok-3 with live search. Search for: "${query}".
+${recencyPrompt}
+Provide concise, factual results with sources.
+Limit search to ${max_search_results} sources for cost control.`
+            },
+            {
+                role: "user",
+                content: `Search for: ${query}`
+            }
+        ];
+        log?.info(`Grok Search: ${max_search_results} sources, recency: ${recency} (using grok-4-fast-reasoning with search)`);
+        // Extract domains from sources if specified
+        const domains = sources
+            ?.filter((s) => s.allowed_websites)
+            ?.flatMap((s) => s.allowed_websites) || [];
+        const result = await callGrokEnhanced(messages, {
+            model: GrokModel.GROK_4_FAST_REASONING, // Changed: Use fast reasoning with search
+            enableLiveSearch: true,
+            searchSources: max_search_results,
+            searchDomains: domains,
+            temperature: 0.3, // Low temperature for factual search
+            maxTokens: 3000
+        });
+        // Add cost warning
+        const estimatedCost = (max_search_results / 1000) * 0.025; // $25 per 1000 sources
+        return `${result.content}\n\n*Search used up to ${max_search_results} sources (~$${estimatedCost.toFixed(4)})*`;
+    }
+};
+/**
+ * Check if Grok is available
+ */
+export function isGrokAvailable() {
+    return !!(GROK_API_KEY);
+}
+/**
+ * Get Grok configuration status
+ */
+export function getGrokStatus() {
+    return {
+        available: isGrokAvailable(),
+        model: GrokModel.GROK_4_FAST_REASONING,
+        features: [
+            'Fast reasoning (grok-4-fast-reasoning: $0.20/$0.50, 2M→4M context)',
+            'Code specialist (grok-code-fast-1: 92 tok/sec)',
+            'Heavy mode available (grok-4-0709: $3/$15, use sparingly)',
+            'Live web search with citations',
+            'Function calling',
+            'Structured outputs',
+            'Multi-modal (text, image)'
+        ]
+    };
+}
+/**
+ * Get all enhanced Grok tools
+ */
+export function getEnhancedGrokTools() {
+    if (!isGrokAvailable()) {
+        return [];
+    }
+    return [
+        grokScoutTool,
+        grokReasonEnhanced,
+        grokFunctionTool,
+        grokSearchTool
+    ];
+}

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

@@ -0,0 +1,299 @@
+/**
+ * Grok Tools Implementation
+ * Provides Grok 4 reasoning and code analysis capabilities
+ */
+import { z } from "zod";
+import { config } from "dotenv";
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { grokSearchTool } from './grok-enhanced.js';
+import { validateToolInput } from "../utils/input-validator.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+config({ path: path.resolve(__dirname, '../../../.env') });
+// Grok API configuration
+const GROK_API_KEY = process.env.GROK_API_KEY;
+const GROK_API_URL = "https://api.x.ai/v1/chat/completions";
+// Available Grok models - Updated 2025-11-07 with new fast models
+export var GrokModel;
+(function (GrokModel) {
+    // New fast models (2025) - PRIMARY USE
+    GrokModel["CODE_FAST"] = "grok-code-fast-1";
+    GrokModel["GROK_4_FAST_REASONING"] = "grok-4-fast-reasoning";
+    GrokModel["GROK_4_FAST"] = "grok-4-fast-non-reasoning";
+    // Expensive/specialized (use sparingly)
+    GrokModel["GROK_4_HEAVY"] = "grok-4-0709";
+    GrokModel["GROK_3"] = "grok-3";
+})(GrokModel || (GrokModel = {}));
+/**
+ * Call Grok API
+ */
+export async function callGrok(messages, model = GrokModel.GROK_4_FAST_REASONING, // Changed: Use cheap fast reasoning by default
+temperature = 0.7, maxTokens = 16384, // Increased default for comprehensive responses
+forceVisibleOutput = true) {
+    if (!GROK_API_KEY) {
+        return `[Grok API key not configured. Add GROK_API_KEY to .env file]`;
+    }
+    // Validate and sanitize message content
+    const validatedMessages = messages.map((msg) => {
+        const validation = validateToolInput(msg.content);
+        if (!validation.valid) {
+            throw new Error(validation.error || "Invalid message content");
+        }
+        return { ...msg, content: validation.sanitized };
+    });
+    try {
+        // For Grok 4 models, we need to handle reasoning tokens specially
+        const isGrok4 = model === GrokModel.GROK_4_FAST_REASONING ||
+            model === GrokModel.GROK_4_FAST ||
+            model === GrokModel.GROK_4_HEAVY;
+        // Adjust prompt for Grok 4 to ensure visible output
+        if (isGrok4 && forceVisibleOutput) {
+            const lastMessage = validatedMessages[validatedMessages.length - 1];
+            if (lastMessage.role === 'user') {
+                lastMessage.content += '\n\nProvide a detailed response with your reasoning and conclusion.';
+            }
+        }
+        const response = await fetch(GROK_API_URL, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${GROK_API_KEY}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                model,
+                messages: validatedMessages,
+                temperature,
+                max_tokens: maxTokens,
+                stream: false
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Grok API error: ${response.statusText} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content;
+        // Handle Grok 4's reasoning tokens
+        if (!content && data.usage?.completion_tokens_details?.reasoning_tokens > 0) {
+            // If Grok 4 returns no visible content, retry with Grok 3 for visible output
+            if (isGrok4 && forceVisibleOutput) {
+                console.error(`Grok 4 used ${data.usage.completion_tokens_details.reasoning_tokens} reasoning tokens with no output. Retrying with Grok 3...`);
+                return callGrok(validatedMessages, GrokModel.GROK_3, temperature, maxTokens, false);
+            }
+            return `[Grok ${model} performed deep reasoning with ${data.usage.completion_tokens_details.reasoning_tokens} tokens]`;
+        }
+        return content || "No response from Grok";
+    }
+    catch (error) {
+        return `[Grok error: ${error instanceof Error ? error.message : String(error)}]`;
+    }
+}
+/**
+ * Grok Reasoning Tool
+ * Deep logical reasoning with first principles thinking
+ */
+export const grokReasonTool = {
+    name: "grok_reason",
+    description: "Deep reasoning",
+    parameters: z.object({
+        problem: z.string(),
+        approach: z.enum(["analytical", "creative", "systematic", "first-principles"]).optional(),
+        context: z.string().optional(),
+        useHeavy: z.boolean().optional()
+    }),
+    execute: async (args, { log }) => {
+        const { problem, approach = "first-principles", context, useHeavy } = args;
+        const approachPrompts = {
+            analytical: "Break down the problem systematically and analyze each component",
+            creative: "Think outside the box and consider unconventional solutions",
+            systematic: "Follow a step-by-step logical process",
+            "first-principles": "Break down to fundamental truths and build up from there"
+        };
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok, an expert at logical reasoning and problem-solving.
+${approachPrompts[approach]}.
+${context ? `Context: ${context}` : ''}`
+            },
+            {
+                role: "user",
+                content: problem
+            }
+        ];
+        // Use GROK_4_FAST_REASONING by default (3x cheaper!), GROK_4_HEAVY only if explicitly requested
+        const model = useHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_FAST_REASONING;
+        const maxTokens = useHeavy ? 100000 : 16384; // 100k for heavy, 16k for normal reasoning
+        log?.info(`Using Grok model: ${model} for deep reasoning (max tokens: ${maxTokens}, cost: ${useHeavy ? 'expensive $3/$15' : 'cheap $0.20/$0.50'})`);
+        return await callGrok(messages, model, 0.7, maxTokens, true);
+    }
+};
+/**
+ * Grok Code Tool
+ * Code analysis, optimization, and debugging
+ */
+export const grokCodeTool = {
+    name: "grok_code",
+    description: "Code analysis",
+    parameters: z.object({
+        task: z.enum(["analyze", "optimize", "debug", "review", "refactor"]),
+        code: z.string(),
+        language: z.string().optional(),
+        requirements: z.string().optional()
+    }),
+    execute: async (args, { log }) => {
+        const { task, code, language, requirements } = args;
+        const taskPrompts = {
+            analyze: "Analyze this code for logic, structure, and potential issues",
+            optimize: "Optimize this code for performance and efficiency",
+            debug: "Debug this code and identify issues or bugs",
+            review: "Review this code for best practices and improvements",
+            refactor: "Refactor this code for better maintainability and clarity"
+        };
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok Code Fast, an expert programmer and code analyst.
+Task: ${taskPrompts[task]}
+${language ? `Language: ${language}` : ''}
+${requirements ? `Requirements: ${requirements}` : ''}`
+            },
+            {
+                role: "user",
+                content: `Code:\n\`\`\`${language || ''}\n${code}\n\`\`\``
+            }
+        ];
+        log?.info(`Using Grok Code Fast (92 tok/sec coding specialist)`);
+        return await callGrok(messages, GrokModel.CODE_FAST, 0.2, 4000, true);
+    }
+};
+/**
+ * Grok Debug Tool
+ * Specialized debugging assistance
+ */
+export const grokDebugTool = {
+    name: "grok_debug",
+    description: "Debug assistance",
+    parameters: z.object({
+        issue: z.string(),
+        code: z.string().optional(),
+        error: z.string().optional(),
+        context: z.string().optional()
+    }),
+    execute: async (args, { log }) => {
+        const { issue, code, error, context } = args;
+        let prompt = `Debug this issue: ${issue}\n`;
+        if (error) {
+            prompt += `\nError:\n${error}\n`;
+        }
+        if (code) {
+            prompt += `\nRelevant code:\n\`\`\`\n${code}\n\`\`\`\n`;
+        }
+        if (context) {
+            prompt += `\nContext: ${context}\n`;
+        }
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok Code Fast, an expert debugger.
+Analyze the issue systematically:
+1. Identify the root cause
+2. Explain why it's happening
+3. Provide a clear solution
+4. Suggest preventive measures`
+            },
+            {
+                role: "user",
+                content: prompt
+            }
+        ];
+        log?.info(`Using Grok Code Fast for debugging (specialized code model)`);
+        return await callGrok(messages, GrokModel.CODE_FAST, 0.3, 3000, true);
+    }
+};
+/**
+ * Grok Architect Tool
+ * System architecture and design
+ */
+export const grokArchitectTool = {
+    name: "grok_architect",
+    description: "Architecture design",
+    parameters: z.object({
+        requirements: z.string(),
+        constraints: z.string().optional(),
+        scale: z.enum(["small", "medium", "large", "enterprise"]).optional()
+    }),
+    execute: async (args, { log }) => {
+        const { requirements, constraints, scale } = args;
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok, an expert system architect.
+Design a robust, scalable architecture using first principles.
+Consider: reliability, scalability, maintainability, security, and cost.
+${scale ? `Target scale: ${scale}` : ''}
+${constraints ? `Constraints: ${constraints}` : ''}`
+            },
+            {
+                role: "user",
+                content: requirements
+            }
+        ];
+        log?.info(`Using Grok 4 Fast Reasoning for architecture (cheap reasoning model)`);
+        return await callGrok(messages, GrokModel.GROK_4_FAST_REASONING, 0.6, 4000, true);
+    }
+};
+/**
+ * Grok Brainstorm Tool
+ * Creative brainstorming with Grok 4 Heavy
+ */
+export const grokBrainstormTool = {
+    name: "grok_brainstorm",
+    description: "Creative brainstorming",
+    parameters: z.object({
+        topic: z.string(),
+        constraints: z.string().optional(),
+        numIdeas: z.number().optional(),
+        forceHeavy: z.boolean().optional()
+    }),
+    execute: async (args, { log }) => {
+        const { topic, constraints, numIdeas = 5, forceHeavy = false } = args; // Changed: Default to cheap model
+        const messages = [
+            {
+                role: "system",
+                content: `You are Grok in maximum creative mode. Generate ${numIdeas} innovative, unconventional ideas.
+Think beyond normal boundaries. Challenge assumptions. Propose radical solutions.
+${constraints ? `Constraints: ${constraints}` : 'No constraints - think freely!'}`
+            },
+            {
+                role: "user",
+                content: `Brainstorm creative solutions for: ${topic}`
+            }
+        ];
+        // Use GROK_4_FAST for creative brainstorming (cheap, fast), GROK_4_HEAVY only if explicitly requested
+        const model = forceHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_FAST;
+        log?.info(`Brainstorming with Grok model: ${model} (Heavy: ${forceHeavy}, cost: ${forceHeavy ? 'expensive $3/$15' : 'cheap $0.20/$0.50'})`);
+        return await callGrok(messages, model, 0.95, 4000); // High temperature for creativity
+    }
+};
+/**
+ * Check if Grok is available
+ */
+export function isGrokAvailable() {
+    return !!GROK_API_KEY;
+}
+export function getAllGrokTools() {
+    if (!isGrokAvailable()) {
+        return [];
+    }
+    // Minimized tool set - keeping all essential Grok tools
+    return [
+        grokReasonTool, // Deep reasoning
+        grokCodeTool, // Code analysis
+        grokDebugTool, // Deep debugging
+        grokArchitectTool, // System architecture
+        grokBrainstormTool, // Creative brainstorming
+        grokSearchTool // Web search with Grok
+    ];
+}