tachibot-mcp 2.0.2

package/dist/src/optimization/token-tracker.js

@@ -0,0 +1,118 @@
+export class TokenTracker {
+    constructor() {
+        this.metrics = new Map();
+        this.modelCosts = new Map([
+            ['gpt5', 12],
+            ['gpt5_mini', 8],
+            ['gpt5_nano', 2],
+            ['gemini-2.5-pro', 10],
+            ['gemini-2.5-flash', 2],
+            ['perplexity-sonar-pro', 6],
+            ['qwen3-coder-480b', 12],
+            ['qwq-32b', 10],
+            ['think', 0],
+        ]);
+    }
+    track(stepId, response, model, inputTokens, outputTokens) {
+        const input = inputTokens || this.estimateInputTokens(response);
+        const output = outputTokens || this.estimateOutputTokens(response);
+        const total = input + output;
+        const cost = this.calculateCost(model, total);
+        const metrics = {
+            input,
+            output,
+            total,
+            cost,
+            model,
+            timestamp: Date.now()
+        };
+        this.metrics.set(stepId, metrics);
+        return metrics;
+    }
+    getReport() {
+        let totalTokens = 0;
+        let totalCost = 0;
+        const byModel = new Map();
+        const byStep = new Map();
+        for (const [stepId, metrics] of this.metrics) {
+            totalTokens += metrics.total;
+            totalCost += metrics.cost;
+            byStep.set(stepId, metrics);
+            const existing = byModel.get(metrics.model);
+            if (existing) {
+                byModel.set(metrics.model, {
+                    ...existing,
+                    input: existing.input + metrics.input,
+                    output: existing.output + metrics.output,
+                    total: existing.total + metrics.total,
+                    cost: existing.cost + metrics.cost
+                });
+            }
+            else {
+                byModel.set(metrics.model, { ...metrics });
+            }
+        }
+        const baselineCost = this.calculateBaselineCost(totalTokens);
+        const savings = baselineCost - totalCost;
+        const optimizationRate = savings / baselineCost;
+        return {
+            totalTokens,
+            totalCost,
+            byModel,
+            byStep,
+            savings,
+            optimizationRate
+        };
+    }
+    reset() {
+        this.metrics.clear();
+    }
+    estimateInputTokens(response) {
+        if (typeof response === 'string') {
+            return Math.ceil(response.length / 4);
+        }
+        if (response && response.prompt) {
+            return Math.ceil(response.prompt.length / 4);
+        }
+        return 100;
+    }
+    estimateOutputTokens(response) {
+        if (typeof response === 'string') {
+            return Math.ceil(response.length / 4);
+        }
+        if (response && response.content) {
+            return Math.ceil(response.content.length / 4);
+        }
+        if (response && response.response) {
+            return Math.ceil(response.response.length / 4);
+        }
+        return 500;
+    }
+    calculateCost(model, tokens) {
+        const costPerMillion = this.modelCosts.get(model) || 5;
+        return (tokens / 1000000) * costPerMillion;
+    }
+    calculateBaselineCost(tokens) {
+        const baselineModel = 'gpt5';
+        return this.calculateCost(baselineModel, tokens);
+    }
+    getOptimizationSuggestions() {
+        const suggestions = [];
+        const report = this.getReport();
+        if (report.optimizationRate < 0.5) {
+            suggestions.push('Consider using more cost-effective models like gemini-2.5-flash for simple tasks');
+        }
+        for (const [model, metrics] of report.byModel) {
+            if (model !== 'think' && metrics.total > 10000) {
+                suggestions.push(`High token usage for ${model}: ${metrics.total} tokens. Consider chunking or summarization.`);
+            }
+        }
+        const expensiveModels = ['gpt5_reason', 'qwen3-coder-480b'];
+        for (const model of expensiveModels) {
+            if (report.byModel.has(model)) {
+                suggestions.push(`Using expensive model ${model}. Ensure it's necessary for the task complexity.`);
+            }
+        }
+        return suggestions;
+    }
+}

package/dist/src/orchestrator-instructions.js

@@ -0,0 +1,128 @@
+import { MCPClient } from './mcp-client.js';
+import { WorkflowType } from './types.js';
+import { workflows } from './workflows.js';
+import { PromptEngineerLite } from './prompt-engineer-lite.js';
+export class InstructionOrchestrator {
+    constructor() {
+        this.mcpClient = new MCPClient();
+        this.promptEngineer = new PromptEngineerLite();
+        this.workflowTemplates = new Map(Object.entries(workflows));
+    }
+    async initialize() {
+        await this.mcpClient.connect();
+    }
+    generateOrchestrationPlan(mode, query, context) {
+        // Select workflow
+        const workflowType = this.analyzeQueryIntent(mode, query);
+        const workflow = this.workflowTemplates.get(workflowType);
+        if (!workflow) {
+            throw new Error(`No workflow found for mode: ${mode}`);
+        }
+        // Generate instructions for each step
+        const instructions = [];
+        const toolSequence = [];
+        workflow.steps.forEach((step, index) => {
+            // Apply prompt engineering
+            const enhancedPrompt = this.promptEngineer.applyTechnique(step.tool, step.promptTechnique, query, [] // In real execution, previous results would be passed
+            );
+            // Map to MCP tool name
+            const mcpToolName = this.getToolMapping(step.tool);
+            // Generate instruction
+            const instruction = this.mcpClient.generateToolInstructions(mcpToolName, { prompt: enhancedPrompt, context, query, thought: enhancedPrompt });
+            instructions.push(instruction);
+            toolSequence.push(step.tool);
+        });
+        // Create visual guide
+        const visualGuide = this.createVisualGuide(workflow, toolSequence);
+        return {
+            workflow,
+            instructions,
+            visualGuide
+        };
+    }
+    analyzeQueryIntent(mode, query) {
+        const modeMap = {
+            // Creative modes
+            'creative': WorkflowType.CREATIVE_DISCOVERY,
+            'brainstorm': WorkflowType.CREATIVE_DISCOVERY,
+            'ideate': WorkflowType.CREATIVE_DISCOVERY,
+            // Research modes
+            'research': WorkflowType.DEEP_RESEARCH,
+            'investigate': WorkflowType.DEEP_RESEARCH,
+            // Problem solving modes
+            'solve': WorkflowType.PROBLEM_SOLVING,
+            'analyze': WorkflowType.PROBLEM_SOLVING,
+            'reason': WorkflowType.PROBLEM_SOLVING,
+            // Synthesis modes
+            'synthesis': WorkflowType.SYNTHESIS,
+            'integrate': WorkflowType.SYNTHESIS,
+            // Fact check modes
+            'fact-check': WorkflowType.FACT_CHECK,
+            'verify': WorkflowType.FACT_CHECK,
+            'validate': WorkflowType.FACT_CHECK,
+        };
+        return modeMap[mode] || WorkflowType.CREATIVE_DISCOVERY;
+    }
+    getToolMapping(toolName) {
+        const toolMap = {
+            'gemini_brainstorm': 'mcp__gemini__gemini-brainstorm',
+            'perplexity_research': 'mcp__perplexity-ask__perplexity_research',
+            'openai_reason': 'mcp__openai-mcp__openai_gpt5_reason',
+            'openai_brainstorm': 'mcp__openai-mcp__openai_brainstorm',
+            'think': 'mcp__think-mcp-server__think',
+        };
+        return toolMap[toolName] || toolName;
+    }
+    createVisualGuide(workflow, tools) {
+        const guide = [
+            `## ${workflow.name} Orchestration Plan`,
+            '',
+            '### Execution Sequence:',
+            ...tools.map((tool, i) => `${i + 1}. **${tool}** - ${this.getStepDescription(workflow.steps[i])}`),
+            '',
+            '### Visual Flow:',
+            '```',
+            tools.map(t => t.substring(0, 8)).join(' → '),
+            '```',
+            '',
+            '### Instructions for Claude:',
+            '1. Execute each tool in sequence',
+            '2. Pass results from each step to inform the next',
+            '3. After all tools complete, synthesize the insights',
+            '',
+            '💡 **Tip**: You can call focus again with `mode="reflect"` to synthesize all results'
+        ];
+        return guide.join('\n');
+    }
+    getStepDescription(step) {
+        const descriptions = {
+            'what_if_speculation': 'Explore wild possibilities',
+            'alternative_perspectives': 'Multiple viewpoints',
+            'comprehensive_investigation': 'Deep research',
+            'evidence_gathering': 'Find supporting data',
+            'systematic_analysis': 'Structured analysis',
+            'first_principles': 'Fundamental reasoning',
+            'quick_reflection': 'Pattern recognition',
+            'innovative_solutions': 'Creative solutions'
+        };
+        return descriptions[step.promptTechnique] || step.promptTechnique;
+    }
+    // Generate a formatted instruction set for display
+    formatInstructions(plan) {
+        const formatted = [
+            plan.visualGuide,
+            '',
+            '### Ready to Execute:',
+            ''
+        ];
+        plan.instructions.forEach((inst, i) => {
+            formatted.push(`#### Step ${i + 1}: ${inst.description}`);
+            formatted.push('```');
+            formatted.push(`Tool: ${inst.tool}`);
+            formatted.push(`Parameters: ${JSON.stringify(inst.parameters, null, 2)}`);
+            formatted.push('```');
+            formatted.push('');
+        });
+        return formatted.join('\n');
+    }
+}

package/dist/src/orchestrator-lite.js

@@ -0,0 +1,139 @@
+import { MCPClient } from './mcp-client.js';
+import { WorkflowType, ToolStatus } from './types.js';
+import { workflows } from './workflows.js';
+import { PromptEngineer } from './prompt-engineer.js';
+import { PromptEngineerLite } from './prompt-engineer-lite.js';
+import { WorkflowVisualizer } from './visualizer.js';
+import { WorkflowVisualizerLite } from './visualizer-lite.js';
+export class FocusOrchestratorLite {
+    constructor(options = {}) {
+        this.tokenEfficient = options.tokenEfficient ?? false;
+        this.mcpClient = new MCPClient();
+        // Use lite versions if token efficient mode
+        if (this.tokenEfficient) {
+            this.promptEngineer = new PromptEngineerLite();
+            this.visualizer = new WorkflowVisualizerLite();
+        }
+        else {
+            this.promptEngineer = new PromptEngineer();
+            this.visualizer = new WorkflowVisualizer();
+        }
+        this.workflowTemplates = new Map(Object.entries(workflows));
+    }
+    async initialize() {
+        await this.mcpClient.connect();
+    }
+    selectWorkflow(mode, query) {
+        const workflowType = this.analyzeQueryIntent(mode, query);
+        const workflow = this.workflowTemplates.get(workflowType);
+        if (!workflow) {
+            throw new Error(`No workflow found for type: ${workflowType}`);
+        }
+        return workflow;
+    }
+    analyzeQueryIntent(mode, query) {
+        const modeMap = {
+            'creative': WorkflowType.CREATIVE_DISCOVERY,
+            'research': WorkflowType.DEEP_RESEARCH,
+            'solve': WorkflowType.PROBLEM_SOLVING,
+            'synthesis': WorkflowType.SYNTHESIS,
+            'brainstorm': WorkflowType.CREATIVE_DISCOVERY,
+            'reason': WorkflowType.PROBLEM_SOLVING,
+        };
+        return modeMap[mode] || WorkflowType.CREATIVE_DISCOVERY;
+    }
+    async executeWorkflow(workflow, query, context) {
+        const results = [];
+        const startTime = Date.now();
+        await this.visualizer.renderWorkflow(workflow, new Map());
+        for (const [index, step] of workflow.steps.entries()) {
+            await this.visualizer.updateProgress(step.tool, ToolStatus.PROCESSING);
+            try {
+                const enhancedPrompt = this.promptEngineer.applyTechnique(step.tool, step.promptTechnique, query, results);
+                const result = await this.executeTool(step.tool, enhancedPrompt, context);
+                results.push({
+                    tool: step.tool,
+                    output: result,
+                    timestamp: Date.now(),
+                    duration: Date.now() - startTime
+                });
+                await this.visualizer.updateProgress(step.tool, ToolStatus.COMPLETE);
+                if (step.adaptationCheck && this.shouldAdapt(result)) {
+                    await this.adaptWorkflow(workflow, results, index);
+                }
+            }
+            catch (error) {
+                await this.visualizer.updateProgress(step.tool, ToolStatus.ERROR);
+                if (step.optional) {
+                    console.error(`Optional tool ${step.tool} failed:`, error);
+                    continue;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        const synthesis = await this.synthesizeResults(results, workflow);
+        await this.visualizer.showCompletion(workflow, results);
+        return synthesis;
+    }
+    async executeTool(toolName, prompt, context) {
+        const toolMap = {
+            'gemini_brainstorm': 'mcp__gemini__gemini-brainstorm',
+            'perplexity_research': 'mcp__perplexity-ask__perplexity_research',
+            'openai_reason': 'mcp__openai-mcp__openai_gpt5_reason',
+            'openai_brainstorm': 'mcp__openai-mcp__openai_brainstorm',
+            'think': 'mcp__think-mcp-server__think',
+        };
+        const mcpToolName = toolMap[toolName] || toolName;
+        return await this.mcpClient.executeTool(mcpToolName, {
+            prompt,
+            context,
+            query: prompt,
+            thought: prompt,
+        });
+    }
+    shouldAdapt(result) {
+        return result.includes('insufficient data') ||
+            result.includes('need more information') ||
+            result.length < 100;
+    }
+    async adaptWorkflow(workflow, results, currentIndex) {
+        if (results.some(r => r.output.includes('insufficient data'))) {
+            workflow.steps.splice(currentIndex + 1, 0, {
+                tool: 'perplexity_research',
+                promptTechnique: 'evidence_gathering',
+                optional: true
+            });
+        }
+    }
+    async synthesizeResults(results, workflow) {
+        if (this.tokenEfficient) {
+            // Compact synthesis for token efficiency
+            const insights = results.map(r => `${r.tool}: ${r.output.split('\n')[0].substring(0, 100)}...`).join('\n');
+            return `## ${workflow.name}\n${insights}\n\nDuration: ${(results[results.length - 1].duration / 1000).toFixed(1)}s`;
+        }
+        // Full synthesis (original code)
+        const synthesis = [`## ${workflow.name} Results\n`];
+        synthesis.push(`**Duration**: ${results[results.length - 1].duration}ms`);
+        synthesis.push(`**Tools**: ${results.map(r => r.tool).join(' → ')}\n`);
+        synthesis.push('### Key Insights\n');
+        for (const result of results) {
+            const keyPoints = this.extractKeyPoints(result.output, result.tool);
+            if (keyPoints.length > 0) {
+                synthesis.push(`**${result.tool}:**`);
+                keyPoints.forEach(point => synthesis.push(`- ${point}`));
+                synthesis.push('');
+            }
+        }
+        return synthesis.join('\n');
+    }
+    extractKeyPoints(output, tool) {
+        const points = [];
+        const bulletPoints = output.match(/^[-*•]\s+(.+)$/gm);
+        if (bulletPoints) {
+            points.push(...bulletPoints.map(p => p.replace(/^[-*•]\s+/, '')));
+        }
+        return points.slice(0, 3);
+    }
+}

package/dist/src/orchestrator.js

@@ -0,0 +1,191 @@
+import { MCPClient } from './mcp-client.js';
+import { WorkflowType, ToolStatus } from './types.js';
+import { workflows } from './workflows.js';
+import { PromptEngineer } from './prompt-engineer.js';
+import { WorkflowVisualizer } from './visualizer.js';
+export class FocusOrchestrator {
+    constructor() {
+        this.mcpClient = new MCPClient();
+        this.promptEngineer = new PromptEngineer();
+        this.visualizer = new WorkflowVisualizer();
+        this.workflowTemplates = new Map(Object.entries(workflows));
+    }
+    async initialize() {
+        await this.mcpClient.connect();
+    }
+    selectWorkflow(mode, query) {
+        // Intelligent workflow selection based on mode and query analysis
+        const workflowType = this.analyzeQueryIntent(mode, query);
+        const workflow = this.workflowTemplates.get(workflowType);
+        if (!workflow) {
+            throw new Error(`No workflow found for type: ${workflowType}`);
+        }
+        return workflow;
+    }
+    analyzeQueryIntent(mode, query) {
+        // Simple mapping for now, can be enhanced with NLP
+        const modeMap = {
+            'creative': WorkflowType.CREATIVE_DISCOVERY,
+            'research': WorkflowType.DEEP_RESEARCH,
+            'solve': WorkflowType.PROBLEM_SOLVING,
+            'synthesis': WorkflowType.SYNTHESIS,
+            'brainstorm': WorkflowType.CREATIVE_DISCOVERY,
+            'reason': WorkflowType.PROBLEM_SOLVING,
+        };
+        return modeMap[mode] || WorkflowType.CREATIVE_DISCOVERY;
+    }
+    async executeWorkflow(workflow, query, context) {
+        const results = [];
+        const startTime = Date.now();
+        // Show initial workflow visualization
+        await this.visualizer.renderWorkflow(workflow, new Map());
+        // Execute each step in the workflow
+        for (const [index, step] of workflow.steps.entries()) {
+            // Update visual progress
+            await this.visualizer.updateProgress(step.tool, ToolStatus.PROCESSING);
+            try {
+                // Apply prompt engineering for this tool
+                const enhancedPrompt = this.promptEngineer.applyTechnique(step.tool, step.promptTechnique, query, results // Pass previous results for context
+                );
+                // Execute the tool
+                const result = await this.executeTool(step.tool, enhancedPrompt, context);
+                results.push({
+                    tool: step.tool,
+                    output: result,
+                    timestamp: Date.now(),
+                    duration: Date.now() - startTime
+                });
+                // Update visual progress
+                await this.visualizer.updateProgress(step.tool, ToolStatus.COMPLETE);
+                // Check if we should adapt the workflow based on results
+                if (step.adaptationCheck) {
+                    const shouldAdapt = await this.evaluateAdaptation(result, step);
+                    if (shouldAdapt) {
+                        await this.adaptWorkflow(workflow, results, index);
+                    }
+                }
+            }
+            catch (error) {
+                await this.visualizer.updateProgress(step.tool, ToolStatus.ERROR);
+                // Handle errors gracefully
+                if (step.optional) {
+                    console.error(`Optional tool ${step.tool} failed:`, error);
+                    continue;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        // Synthesize all results
+        const synthesis = await this.synthesizeResults(results, workflow);
+        // Show completion
+        await this.visualizer.showCompletion(workflow, results);
+        return synthesis;
+    }
+    async executeTool(toolName, prompt, context) {
+        // Map internal tool names to MCP tool names
+        const toolMap = {
+            'gemini_brainstorm': 'mcp__gemini__gemini-brainstorm',
+            'perplexity_research': 'mcp__perplexity-ask__perplexity_research',
+            'openai_reason': 'mcp__openai-mcp__openai_gpt5_reason',
+            'openai_brainstorm': 'mcp__openai-mcp__openai_brainstorm',
+            'think': 'mcp__think-mcp-server__think',
+        };
+        const mcpToolName = toolMap[toolName] || toolName;
+        // Execute via MCP client
+        return await this.mcpClient.executeTool(mcpToolName, {
+            prompt,
+            context,
+            query: prompt, // Some tools use 'query' instead of 'prompt'
+            thought: prompt, // think-mcp uses 'thought'
+        });
+    }
+    async evaluateAdaptation(result, step) {
+        // Simple heuristics for workflow adaptation
+        // Can be enhanced with more sophisticated logic
+        if (result.includes('insufficient data') || result.includes('need more information')) {
+            return true;
+        }
+        if (step.adaptationThreshold && result.length < step.adaptationThreshold) {
+            return true;
+        }
+        return false;
+    }
+    async adaptWorkflow(workflow, results, currentIndex) {
+        // Add additional research step if needed
+        if (results.some(r => r.output.includes('insufficient data'))) {
+            workflow.steps.splice(currentIndex + 1, 0, {
+                tool: 'perplexity_research',
+                promptTechnique: 'deep_investigation',
+                optional: true
+            });
+        }
+    }
+    async synthesizeResults(results, workflow) {
+        // Create a comprehensive synthesis of all tool outputs
+        const synthesis = [`## ${workflow.name} Results\n`];
+        // Add workflow metadata
+        synthesis.push(`**Workflow Duration**: ${results[results.length - 1].duration}ms`);
+        synthesis.push(`**Tools Used**: ${results.map(r => r.tool).join(' → ')}\n`);
+        // Key insights section
+        synthesis.push('### Key Insights\n');
+        // Extract key points from each tool result
+        for (const result of results) {
+            const keyPoints = this.extractKeyPoints(result.output, result.tool);
+            if (keyPoints.length > 0) {
+                synthesis.push(`**From ${result.tool}:**`);
+                keyPoints.forEach(point => synthesis.push(`- ${point}`));
+                synthesis.push('');
+            }
+        }
+        // Synthesis section
+        synthesis.push('### Synthesis\n');
+        // Use think-mcp for final synthesis if available
+        if (this.mcpClient.hasTools(['mcp__think-mcp-server__think'])) {
+            const synthesisPrompt = `Synthesize these insights into a coherent conclusion:\n${results.map(r => `${r.tool}: ${this.summarize(r.output)}`).join('\n')}`;
+            const finalThought = await this.executeTool('think', synthesisPrompt);
+            synthesis.push(finalThought);
+        }
+        else {
+            // Fallback synthesis
+            synthesis.push(this.createFallbackSynthesis(results));
+        }
+        return synthesis.join('\n');
+    }
+    extractKeyPoints(output, tool) {
+        // Extract key points based on tool type
+        const points = [];
+        // Look for bullet points
+        const bulletPoints = output.match(/^[-*•]\s+(.+)$/gm);
+        if (bulletPoints) {
+            points.push(...bulletPoints.map(p => p.replace(/^[-*•]\s+/, '')));
+        }
+        // Look for numbered lists
+        const numberedPoints = output.match(/^\d+\.\s+(.+)$/gm);
+        if (numberedPoints) {
+            points.push(...numberedPoints.map(p => p.replace(/^\d+\.\s+/, '')));
+        }
+        // Tool-specific extraction
+        if (tool === 'gemini_brainstorm' && points.length === 0) {
+            // Extract creative ideas
+            const ideas = output.match(/(?:idea|concept|possibility):\s*([^.!?]+[.!?])/gi);
+            if (ideas) {
+                points.push(...ideas.map(i => i.replace(/^(?:idea|concept|possibility):\s*/i, '')));
+            }
+        }
+        return points.slice(0, 3); // Limit to top 3 points per tool
+    }
+    summarize(text, maxLength = 200) {
+        // Simple summarization - take first paragraph or N characters
+        const firstParagraph = text.split('\n\n')[0];
+        if (firstParagraph.length <= maxLength) {
+            return firstParagraph;
+        }
+        return firstParagraph.substring(0, maxLength) + '...';
+    }
+    createFallbackSynthesis(results) {
+        const insights = results.map(r => this.summarize(r.output, 100));
+        return `Based on the analysis from ${results.length} different perspectives:\n\n${insights.join('\n\n')}\n\nThese insights suggest a multi-faceted understanding of the query.`;
+    }
+}

package/dist/src/orchestrators/collaborative/interfaces/IToolExecutionEngine.js

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestrators/collaborative/interfaces/IToolExecutionStrategy.js

@@ -0,0 +1,5 @@
+/**
+ * Tool Execution Strategy Interface
+ * Simple abstraction for executing different AI model tools
+ */
+export {};

package/dist/src/orchestrators/collaborative/interfaces/IVisualizationRenderer.js

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestrators/collaborative/registries/ModelProviderRegistry.js

@@ -0,0 +1,95 @@
+/**
+ * Model Provider Registry
+ * Maps model names to tool names and providers
+ * Replaces hard-coded switch statements
+ */
+export class ModelProviderRegistry {
+    constructor() {
+        this.mappings = new Map();
+    }
+    /**
+     * Register a model mapping
+     */
+    register(mapping) {
+        // Register primary name
+        this.mappings.set(mapping.modelName.toLowerCase(), mapping);
+        // Register aliases
+        if (mapping.aliases) {
+            mapping.aliases.forEach(alias => {
+                this.mappings.set(alias.toLowerCase(), mapping);
+            });
+        }
+    }
+    /**
+     * Register multiple mappings at once
+     */
+    registerMany(mappings) {
+        mappings.forEach(m => this.register(m));
+    }
+    /**
+     * Get tool name for a model
+     * Returns null if no mapping found
+     */
+    getToolName(modelName) {
+        const mapping = this.mappings.get(modelName.toLowerCase());
+        return mapping?.toolName || null;
+    }
+    /**
+     * Get provider for a model
+     * Returns "unknown" if no mapping found
+     */
+    getProvider(modelName) {
+        const mapping = this.mappings.get(modelName.toLowerCase());
+        return mapping?.provider || "unknown";
+    }
+    /**
+     * Get full mapping for a model
+     */
+    getMapping(modelName) {
+        return this.mappings.get(modelName.toLowerCase()) || null;
+    }
+    /**
+     * Check if a model is registered
+     */
+    hasModel(modelName) {
+        return this.mappings.has(modelName.toLowerCase());
+    }
+    /**
+     * Get all registered model names
+     */
+    getRegisteredModels() {
+        const models = new Set();
+        this.mappings.forEach(mapping => {
+            models.add(mapping.modelName);
+        });
+        return Array.from(models);
+    }
+}
+// Singleton instance with default mappings
+export const modelProviderRegistry = new ModelProviderRegistry();
+// Register default model mappings (extracted from CollaborativeOrchestrator)
+modelProviderRegistry.registerMany([
+    // Qwen models
+    { modelName: "qwen", toolName: "qwen_coder", provider: "openrouter" },
+    { modelName: "qwen-coder", toolName: "qwen_coder", provider: "openrouter" },
+    { modelName: "qwq", toolName: "qwq_reason", provider: "openrouter" },
+    // Grok models
+    { modelName: "grok", toolName: "grok_reason", provider: "x.ai" },
+    { modelName: "grok-4", toolName: "grok_reason", provider: "x.ai", aliases: ["grok-4-0709"] },
+    // Claude models
+    { modelName: "claude", toolName: "think", provider: "anthropic", aliases: ["claude-code", "reasoning", "analysis"] },
+    // Gemini models
+    { modelName: "gemini", toolName: "gemini_query", provider: "google", aliases: ["gemini-pro", "gemini-2.5-pro"] },
+    { modelName: "gemini-2.5-flash", toolName: "gemini_analyze_text", provider: "google", aliases: ["gemini-2.5-flash-lite"] },
+    // Perplexity models
+    { modelName: "perplexity", toolName: "perplexity_ask", provider: "perplexity" },
+    { modelName: "perplexity-reason", toolName: "perplexity_reason", provider: "perplexity" },
+    // OpenAI models
+    { modelName: "openai", toolName: "openai_brainstorm", provider: "openai", aliases: ["openai-gpt5", "openai-gpt5-nano"] },
+    { modelName: "gpt5", toolName: "gpt5_reason", provider: "openai", aliases: ["gpt-5"] },
+    { modelName: "gpt5-mini", toolName: "gpt5_mini_reason", provider: "openai", aliases: ["gpt-5-mini"] },
+    // Kimi models (Moonshot AI)
+    { modelName: "kimi", toolName: "kimi_thinking", provider: "openrouter", aliases: ["kimi-k2", "kimi-k2-thinking", "kimi-thinking"] },
+    // Think tool
+    { modelName: "think", toolName: "think", provider: "anthropic" }
+]);