@anh3d0nic/qwen-code-termux-ice 14.0.0 → 16.0.0

package/.qwen/ice.py

@@ -1,822 +0,0 @@
-#!/usr/bin/env python3
-"""
-❄️ ICE v4.3 — Multi-Provider Implementation
-Real API calls to:
-- Qwen (DashScope OAuth)
-- Groq (15+ models)
-- Gemini (Google AI)
-
-Real code. Real APIs. No simulation.
-"""
-
-import os
-import json
-import time
-import re
-import requests
-from typing import Dict, List, Optional, Any, Tuple
-from dataclasses import dataclass, field, asdict
-from enum import Enum
-
-# Try dotenv, work without it
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-except ImportError:
-    pass
-
-
-# ============================================
-# CONFIGURATION
-# ============================================
-
-CONFIG = {
-    "storage_path": os.path.expanduser("~/.qwen"),
-    
-    # Qwen (DashScope)
-    "qwen_api_key": os.getenv("QWEN_API_KEY") or os.getenv("DASHSCOPE_API_KEY"),
-    "qwen_url": "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
-    
-    # Groq
-    "groq_api_key": os.getenv("GROQ_API_KEY"),
-    "groq_url": "https://api.groq.com/openai/v1/chat/completions",
-    
-    # Gemini
-    "gemini_api_key": os.getenv("GEMINI_API_KEY"),
-    "gemini_url": "https://generativelanguage.googleapis.com/v1beta/models",
-    
-    # Model selection
-    "models": {
-        "qwen": "qwen-plus",
-        "groq_primary": "qwen/qwen3-32b",
-        "groq_fast": "llama-3.1-8b-instant",
-        "gemini": "gemini-2.0-flash"
-    },
-    
-    "temperature": 0.4,
-    "max_tokens": 2048,
-    "timeout": 30
-}
-
-# File paths
-FILES = {
-    "memory": "ice_memory.json",
-    "examples": "ice_examples.json",
-    "patterns": "d20_patterns.json"
-}
-
-
-# ============================================
-# DATA STRUCTURES
-# ============================================
-
-class IntentType(Enum):
-    QUESTION = "question"
-    CODE_REQUEST = "code_request"
-    MATH_PROBLEM = "math_problem"
-    CAUSAL = "causal"
-    HOW_TO = "how_to"
-    COMPARISON = "comparison"
-    COMMAND = "command"
-    CREATIVE = "creative"
-    OPINION = "opinion"
-    UNKNOWN = "unknown"
-
-
-class ComplexityLevel(Enum):
-    SIMPLE = "simple"
-    MODERATE = "moderate"
-    COMPLEX = "complex"
-    CRITICAL = "critical"
-
-
-@dataclass
-class IntentResult:
-    primary_intent: str
-    secondary_intents: List[str]
-    confidence: float
-    entities: Dict[str, Any]
-    rephrased_request: str
-    needs_clarification: bool
-    clarifying_questions: Optional[List[str]]
-    reasoning: str
-
-
-@dataclass
-class Agent:
-    id: str
-    name: str
-    role: str
-    specialty: str
-    status: str = "idle"
-    tasks_completed: int = 0
-
-
-@dataclass
-class Crew:
-    name: str
-    agents: List[Agent]
-    trigger_keywords: List[str]
-
-
-# ============================================
-# MULTI-PROVIDER API CLIENT
-# ============================================
-
-class MultiProviderClient:
-    """Real API client for Qwen, Groq, and Gemini"""
-    
-    def __init__(self):
-        self.qwen_key = CONFIG["qwen_api_key"]
-        self.groq_key = CONFIG["groq_api_key"]
-        self.gemini_key = CONFIG["gemini_api_key"]
-        
-        self.providers = {
-            "qwen": bool(self.qwen_key),
-            "groq": bool(self.groq_key),
-            "gemini": bool(self.gemini_key)
-        }
-    
-    def is_available(self, provider: str) -> bool:
-        return self.providers.get(provider, False)
-    
-    def get_available_providers(self) -> List[str]:
-        return [p for p, available in self.providers.items() if available]
-    
-    def chat(self, messages: List[Dict], provider: str = "groq", 
-             model: Optional[str] = None, temperature: float = 0.4,
-             max_tokens: int = 2048) -> Optional[str]:
-        """Make real API call to specified provider"""
-        
-        if provider == "groq" and self.groq_key:
-            return self._groq_chat(messages, model, temperature, max_tokens)
-        elif provider == "gemini" and self.gemini_key:
-            return self._gemini_chat(messages, model, temperature, max_tokens)
-        elif provider == "qwen" and self.qwen_key:
-            return self._qwen_chat(messages, model, temperature, max_tokens)
-        
-        return None
-    
-    def _groq_chat(self, messages: List[Dict], model: Optional[str],
-                   temperature: float, max_tokens: int) -> Optional[str]:
-        """Real Groq API call"""
-        headers = {
-            "Authorization": f"Bearer {self.groq_key}",
-            "Content-Type": "application/json"
-        }
-        
-        payload = {
-            "model": model or CONFIG["models"]["groq_primary"],
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens
-        }
-        
-        try:
-            response = requests.post(
-                CONFIG["groq_url"],
-                headers=headers,
-                json=payload,
-                timeout=CONFIG["timeout"]
-            )
-            response.raise_for_status()
-            data = response.json()
-            return data['choices'][0]['message']['content']
-        except Exception as e:
-            print(f"Groq Error: {e}")
-            return None
-    
-    def _gemini_chat(self, messages: List[Dict], model: Optional[str],
-                     temperature: float, max_tokens: int) -> Optional[str]:
-        """Real Gemini API call"""
-        model_name = model or CONFIG["models"]["gemini"]
-        url = f"{CONFIG['gemini_url']}/{model_name}:generateContent?key={self.gemini_key}"
-        
-        # Convert messages to Gemini format
-        gemini_messages = []
-        for msg in messages:
-            role = "user" if msg["role"] in ["user", "system"] else "model"
-            gemini_messages.append({
-                "role": role,
-                "parts": [{"text": msg["content"]}]
-            })
-        
-        payload = {
-            "contents": gemini_messages,
-            "generationConfig": {
-                "temperature": temperature,
-                "maxOutputTokens": max_tokens
-            }
-        }
-        
-        try:
-            response = requests.post(url, json=payload, timeout=CONFIG["timeout"])
-            response.raise_for_status()
-            data = response.json()
-            return data['candidates'][0]['content']['parts'][0]['text']
-        except Exception as e:
-            print(f"Gemini Error: {e}")
-            return None
-    
-    def _qwen_chat(self, messages: List[Dict], model: Optional[str],
-                   temperature: float, max_tokens: int) -> Optional[str]:
-        """Real Qwen (DashScope) API call"""
-        headers = {
-            "Authorization": f"Bearer {self.qwen_key}",
-            "Content-Type": "application/json"
-        }
-        
-        payload = {
-            "model": model or CONFIG["models"]["qwen"],
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens
-        }
-        
-        try:
-            response = requests.post(
-                CONFIG["qwen_url"],
-                headers=headers,
-                json=payload,
-                timeout=CONFIG["timeout"]
-            )
-            response.raise_for_status()
-            data = response.json()
-            return data['choices'][0]['message']['content']
-        except Exception as e:
-            print(f"Qwen Error: {e}")
-            return None
-    
-    def select_best_provider(self, intent: str, complexity: str) -> str:
-        """Select best provider based on task"""
-        available = self.get_available_providers()
-        
-        if not available:
-            return "fallback"
-        
-        # Code tasks → Groq (best for code)
-        if intent == "code_request":
-            if "groq" in available:
-                return "groq"
-        
-        # Complex reasoning → Groq or Qwen
-        if complexity in ["complex", "critical"]:
-            if "groq" in available:
-                return "groq"
-            if "qwen" in available:
-                return "qwen"
-        
-        # Fast/simple → Gemini or Groq fast
-        if complexity == "simple":
-            if "gemini" in available:
-                return "gemini"
-            if "groq" in available:
-                return "groq"
-        
-        # Default to first available
-        return available[0]
-
-
-# ============================================
-# INTENT DECODER
-# ============================================
-
-class IntentDecoder:
-    """LLM-centric intent decoding with multi-provider support"""
-    
-    def __init__(self, api_client: MultiProviderClient):
-        self.api = api_client
-        self.examples = self._load_examples()
-    
-    def _load_examples(self) -> List[Dict]:
-        path = os.path.join(CONFIG["storage_path"], FILES["examples"])
-        if os.path.exists(path):
-            try:
-                with open(path, 'r') as f:
-                    return json.load(f)
-            except:
-                pass
-        return self._default_examples()
-    
-    def _default_examples(self) -> List[Dict]:
-        return [
-            {"user": "What is Python?", "intent": "question", "confidence": 0.95},
-            {"user": "Write a function to sort", "intent": "code_request", "confidence": 0.92},
-            {"user": "Does stress cause illness?", "intent": "causal", "confidence": 0.90},
-            {"user": "How to install Docker?", "intent": "how_to", "confidence": 0.93},
-            {"user": "Compare MySQL vs PostgreSQL", "intent": "comparison", "confidence": 0.91},
-            {"user": "Calculate 15 * 3 + 24 / 4", "intent": "math_problem", "confidence": 0.94},
-        ]
-    
-    def _save_examples(self):
-        path = os.path.join(CONFIG["storage_path"], FILES["examples"])
-        try:
-            os.makedirs(os.path.dirname(path), exist_ok=True)
-            with open(path, 'w') as f:
-                json.dump(self.examples, f, indent=2)
-        except Exception as e:
-            print(f"Warning: Could not save examples: {e}")
-    
-    def decode(self, message: str, context: Optional[str] = None) -> IntentResult:
-        """Decode intent with multi-provider API or fallback"""
-        providers = self.api.get_available_providers()
-        
-        if providers:
-            # Use best available provider
-            return self._decode_api(message, context, providers[0])
-        return self._decode_fallback(message, context)
-    
-    def _decode_api(self, message: str, context: Optional[str], provider: str) -> IntentResult:
-        """Use API for intent decoding"""
-        examples_text = "\n".join([
-            f"User: \"{ex['user']}\" → Intent: {ex['intent']} ({ex['confidence']:.0%})"
-            for ex in self.examples[:5]
-        ])
-        
-        prompt = f"""You are an intent classifier. Output ONLY JSON.
-
-Examples:
-{examples_text}
-
-Classify this:
-User: "{message}"
-
-Output JSON:
-{{
-  "primary_intent": "one of: question, code_request, math_problem, causal, how_to, comparison, command, creative, opinion, unknown",
-  "secondary_intents": [],
-  "confidence": 0.0-1.0,
-  "entities": {{"key": "value"}},
-  "rephrased_request": "clear version",
-  "needs_clarification": true/false,
-  "clarifying_questions": ["list"] or null,
-  "reasoning": "brief explanation"
-}}"""
-        
-        if context:
-            prompt += f"\nContext: {context}"
-        
-        response = self.api.chat(
-            messages=[{"role": "user", "content": prompt}],
-            provider=provider,
-            temperature=0.1,
-            max_tokens=500
-        )
-        
-        if response:
-            try:
-                json_start = response.find('{')
-                json_end = response.rfind('}') + 1
-                if json_start >= 0 and json_end > json_start:
-                    data = json.loads(response[json_start:json_end])
-                    
-                    if data.get('confidence', 0) >= 0.8:
-                        self._store_example(message, data)
-                    
-                    return IntentResult(
-                        primary_intent=data.get('primary_intent', 'unknown'),
-                        secondary_intents=data.get('secondary_intents', []),
-                        confidence=data.get('confidence', 0.5),
-                        entities=data.get('entities', {}),
-                        rephrased_request=data.get('rephrased_request', message),
-                        needs_clarification=data.get('needs_clarification', False),
-                        clarifying_questions=data.get('clarifying_questions'),
-                        reasoning=data.get('reasoning', '')
-                    )
-            except json.JSONDecodeError:
-                pass
-        
-        return self._decode_fallback(message, context)
-    
-    def _decode_fallback(self, message: str, context: Optional[str]) -> IntentResult:
-        """Rule-based fallback"""
-        msg_lower = message.lower()
-        
-        patterns = {
-            "code_request": [r"\b(write|create|build|code|function)\b", r"\b(python|javascript|java|react)\b"],
-            "question": [r"\b(what|who|when|where|why|how)\b.*\b(\?|is|are)\b"],
-            "causal": [r"\b(cause|causes|effect|leads to)\b", r"\bwhy does\b"],
-            "how_to": [r"\bhow (do|to|can)\b", r"\b(install|setup|configure)\b"],
-            "comparison": [r"\b(compare|vs|versus|better)\b"],
-            "math_problem": [r"\b(calculate|compute|solve)\b", r"\d+\s*[\+\-\*\/]\s*\d+"],
-        }
-        
-        scores = {}
-        for intent, pattern_list in patterns.items():
-            for pattern in pattern_list:
-                if re.search(pattern, msg_lower):
-                    scores[intent] = scores.get(intent, 0) + 0.3
-        
-        if not scores:
-            return IntentResult(
-                primary_intent="unknown",
-                secondary_intents=[],
-                confidence=0.3,
-                entities={},
-                rephrased_request=message,
-                needs_clarification=True,
-                clarifying_questions=["Could you clarify?"],
-                reasoning="No pattern matched"
-            )
-        
-        primary = max(scores, key=scores.get)
-        confidence = min(0.9, scores[primary])
-        
-        return IntentResult(
-            primary_intent=primary,
-            secondary_intents=[],
-            confidence=confidence,
-            entities=self._extract_entities(message),
-            rephrased_request=message,
-            needs_clarification=confidence < 0.7,
-            clarifying_questions=["Could you provide more details?"] if confidence < 0.7 else None,
-            reasoning=f"Matched {primary} pattern"
-        )
-    
-    def _extract_entities(self, message: str) -> Dict[str, Any]:
-        """Extract entities from message"""
-        entities = {}
-        
-        techs = re.findall(r'\b(Python|JavaScript|Java|React|Docker|AWS|MySQL|PostgreSQL|MongoDB)\b', message, re.I)
-        if techs:
-            entities['technologies'] = techs
-        
-        nums = re.findall(r'\d+(?:\.\d+)?', message)
-        if nums:
-            entities['numbers'] = nums
-        
-        times = re.findall(r'\b(today|tomorrow|yesterday|next week|last month)\b', message, re.I)
-        if times:
-            entities['time'] = times
-        
-        return entities
-    
-    def _store_example(self, message: str, data: Dict):
-        """Store high-confidence example"""
-        for ex in self.examples:
-            if message.lower() in ex.get('user', '').lower():
-                return
-        
-        self.examples.append({
-            "user": message,
-            "intent": data.get('primary_intent'),
-            "confidence": data.get('confidence'),
-            "timestamp": time.time()
-        })
-        
-        if len(self.examples) > 50:
-            self.examples = self.examples[-50:]
-        
-        self._save_examples()
-
-
-# ============================================
-# D20 LEARNING SYSTEM
-# ============================================
-
-class D20Learner:
-    """Pattern learning and storage"""
-    
-    def __init__(self):
-        self.patterns = self._load_patterns()
-        self.memory = self._load_memory()
-    
-    def _load_patterns(self) -> Dict:
-        path = os.path.join(CONFIG["storage_path"], FILES["patterns"])
-        if os.path.exists(path):
-            try:
-                with open(path, 'r') as f:
-                    return json.load(f)
-            except:
-                pass
-        return {"routing": {}, "reasoning": {}, "optimization": {}}
-    
-    def _save_patterns(self):
-        path = os.path.join(CONFIG["storage_path"], FILES["patterns"])
-        try:
-            with open(path, 'w') as f:
-                json.dump(self.patterns, f, indent=2)
-        except Exception as e:
-            print(f"Warning: Could not save patterns: {e}")
-    
-    def _load_memory(self) -> List[Dict]:
-        path = os.path.join(CONFIG["storage_path"], FILES["memory"])
-        if os.path.exists(path):
-            try:
-                with open(path, 'r') as f:
-                    return json.load(f)
-            except:
-                pass
-        return []
-    
-    def _save_memory(self):
-        path = os.path.join(CONFIG["storage_path"], FILES["memory"])
-        try:
-            with open(path, 'w') as f:
-                json.dump(self.memory[-100:], f, indent=2)
-        except Exception as e:
-            print(f"Warning: Could not save memory: {e}")
-    
-    def learn(self, intent: str, success: bool, response_time: float, provider: str):
-        """Learn from interaction"""
-        if intent not in self.patterns["routing"]:
-            self.patterns["routing"][intent] = {"success": 0, "total": 0, "avg_time": 0, "provider": provider}
-        
-        self.patterns["routing"][intent]["total"] += 1
-        if success:
-            self.patterns["routing"][intent]["success"] += 1
-        
-        old_avg = self.patterns["routing"][intent]["avg_time"]
-        n = self.patterns["routing"][intent]["total"]
-        self.patterns["routing"][intent]["avg_time"] = ((old_avg * (n-1)) + response_time) / n
-        self.patterns["routing"][intent]["provider"] = provider
-        
-        self._save_patterns()
-    
-    def store(self, interaction: Dict):
-        """Store interaction in memory"""
-        interaction["timestamp"] = time.time()
-        self.memory.append(interaction)
-        self._save_memory()
-    
-    def get_status(self) -> Dict:
-        return {
-            "patterns_count": sum(len(v) for v in self.patterns.values()),
-            "memory_size": len(self.memory),
-            "routing_patterns": len(self.patterns.get("routing", {}))
-        }
-
-
-# ============================================
-# AGENT CREWS
-# ============================================
-
-class AgentCrews:
-    """102 agents across 5 crews"""
-    
-    def __init__(self):
-        self.crews = self._create_crews()
-    
-    def _create_crews(self) -> List[Crew]:
-        return [
-            Crew(
-                name="Alpha",
-                agents=[Agent(f"A{i:02d}", f"Agent A{i:02d}", "Frontend", "UI/UX") for i in range(1, 21)],
-                trigger_keywords=["ui", "frontend", "html", "css", "database", "api", "deploy"]
-            ),
-            Crew(
-                name="Beta",
-                agents=[Agent(f"B{i:02d}", f"Agent B{i:02d}", "Engineering", "Code Quality") for i in range(1, 21)],
-                trigger_keywords=["code", "refactor", "test", "security", "architecture"]
-            ),
-            Crew(
-                name="Gamma",
-                agents=[Agent(f"G{i:02d}", f"Agent G{i:02d}", "Android", "Termux") for i in range(1, 21)],
-                trigger_keywords=["termux", "android", "pkg", "path", "permissions"]
-            ),
-            Crew(
-                name="Delta",
-                agents=[Agent(f"D{i:02d}", f"Agent D{i:02d}", "Orchestration", "Planning") for i in range(1, 21)],
-                trigger_keywords=["orchestrate", "route", "plan", "memory", "learn"]
-            ),
-            Crew(
-                name="Epsilon",
-                agents=[Agent(f"E{i:02d}", f"Agent E{i:02d}", "Tools", "Infrastructure") for i in range(1, 21)],
-                trigger_keywords=["infra", "tools", "mcp", "forge", "scaffold"]
-            )
-        ]
-    
-    def select_crew(self, intent: str, entities: Dict) -> List[Crew]:
-        selected = []
-        text = f"{intent} {' '.join(str(v) for v in entities.values())}".lower()
-        
-        for crew in self.crews:
-            if any(kw in text for kw in crew.trigger_keywords):
-                selected.append(crew)
-        
-        if not selected:
-            selected = [self.crews[3]]  # Delta
-        
-        return selected
-    
-    def get_status(self) -> Dict:
-        return {
-            "crews": len(self.crews),
-            "total_agents": sum(len(c.agents) for c in self.crews),
-            "crew_names": [c.name for c in self.crews]
-        }
-
-
-# ============================================
-# ICE CORE ENGINE
-# ============================================
-
-class ICEEngine:
-    """Main ICE v4.3 engine with multi-provider support"""
-    
-    def __init__(self):
-        self.api = MultiProviderClient()
-        self.intent_decoder = IntentDecoder(self.api)
-        self.d20 = D20Learner()
-        self.crews = AgentCrews()
-        self.start_time = time.time()
-    
-    def process(self, message: str, context: Optional[str] = None) -> Dict[str, Any]:
-        """Process message through complete ICE pipeline"""
-        start = time.time()
-        
-        # Step 1: Decode intent
-        intent = self.intent_decoder.decode(message, context)
-        
-        # Step 2: Assess complexity
-        complexity = self._assess_complexity(intent)
-        
-        # Step 3: Select crews
-        selected_crews = self.crews.select_crew(intent.primary_intent, intent.entities)
-        
-        # Step 4: Select best provider
-        provider = self.api.select_best_provider(intent.primary_intent, complexity.value)
-        model = self._get_model_for_provider(provider, intent.primary_intent)
-        
-        # Step 5: Generate response
-        response = self._generate_response(message, intent, provider, model)
-        
-        # Step 6: Learn
-        elapsed = time.time() - start
-        self.d20.learn(intent.primary_intent, True, elapsed, provider)
-        self.d20.store({
-            "input": message,
-            "intent": asdict(intent),
-            "complexity": complexity.value,
-            "crews": [c.name for c in selected_crews],
-            "provider": provider,
-            "model": model,
-            "response_time": elapsed
-        })
-        
-        return {
-            "intent": asdict(intent),
-            "complexity": complexity.value,
-            "crews": [c.name for c in selected_crews],
-            "provider": provider,
-            "model": model,
-            "response": response,
-            "time": elapsed,
-            "providers_available": self.api.get_available_providers()
-        }
-    
-    def _assess_complexity(self, intent: IntentResult) -> ComplexityLevel:
-        if intent.confidence < 0.5:
-            return ComplexityLevel.COMPLEX
-        if intent.primary_intent in ["code_request", "math_problem", "causal"]:
-            return ComplexityLevel.MODERATE
-        if len(intent.secondary_intents) > 2:
-            return ComplexityLevel.MODERATE
-        return ComplexityLevel.SIMPLE
-    
-    def _get_model_for_provider(self, provider: str, intent: str) -> str:
-        if provider == "groq":
-            return CONFIG["models"]["groq_primary"] if intent == "code_request" else CONFIG["models"]["groq_fast"]
-        elif provider == "gemini":
-            return CONFIG["models"]["gemini"]
-        else:
-            return CONFIG["models"]["qwen"]
-    
-    def _generate_response(self, message: str, intent: IntentResult, provider: str, model: str) -> str:
-        if not self.api.is_available(provider):
-            return self._fallback_response(message, intent)
-        
-        prompt = f"""You are ICE v4.3. Think first, then respond.
-
-[ICE THINKING]
-Intent: {intent.primary_intent}
-Entities: {intent.entities}
-Confidence: {intent.confidence:.0%}
-Needs Clarification: {intent.needs_clarification}
-
-[RESPONSE]
-"""
-        
-        if intent.needs_clarification and intent.clarifying_questions:
-            questions = "\n".join(f"- {q}" for q in intent.clarifying_questions[:3])
-            prompt += f"I need clarification:\n{questions}"
-        else:
-            prompt += f"User request: {message}\n\nHere's my response:\n"
-        
-        response = self.api.chat(
-            messages=[{"role": "user", "content": prompt}],
-            provider=provider,
-            model=model,
-            temperature=0.4,
-            max_tokens=CONFIG["max_tokens"]
-        )
-        
-        return response or self._fallback_response(message, intent)
-    
-    def _fallback_response(self, message: str, intent: IntentResult) -> str:
-        if intent.needs_clarification:
-            return "I need more information. Could you clarify your request?"
-        return f"[Fallback] You asked about {intent.primary_intent}: {message}"
-    
-    def get_status(self) -> Dict[str, Any]:
-        return {
-            "version": "4.3",
-            "providers": self.api.get_available_providers(),
-            "provider_status": self.api.providers,
-            "uptime": time.time() - self.start_time,
-            "d20": self.d20.get_status(),
-            "crews": self.crews.get_status()
-        }
-
-
-# ============================================
-# GLOBAL INSTANCE
-# ============================================
-
-_ice: Optional[ICEEngine] = None
-
-
-def get_ice() -> ICEEngine:
-    global _ice
-    if _ice is None:
-        _ice = ICEEngine()
-    return _ice
-
-
-def ice_process(message: str, context: Optional[str] = None) -> Dict[str, Any]:
-    return get_ice().process(message, context)
-
-
-def ice_status() -> Dict[str, Any]:
-    return get_ice().get_status()
-
-
-# ============================================
-# CLI
-# ============================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print("❄️ ICE v4.3 — Multi-Provider (Qwen + Groq + Gemini)")
-    print("=" * 70)
-    print()
-    
-    ice = get_ice()
-    status = ice.get_status()
-    
-    print(f"Version: {status['version']}")
-    print(f"Providers: {', '.join(status['providers']) if status['providers'] else 'None (fallback mode)'}")
-    print(f"  - Qwen: {'✅' if status['provider_status'].get('qwen') else '❌'}")
-    print(f"  - Groq: {'✅' if status['provider_status'].get('groq') else '❌'}")
-    print(f"  - Gemini: {'✅' if status['provider_status'].get('gemini') else '❌'}")
-    print(f"Crews: {status['crews']['crews']} ({status['crews']['total_agents']} agents)")
-    print(f"D20 Patterns: {status['d20']['patterns_count']}")
-    print(f"Uptime: {status['uptime']:.0f}s")
-    print()
-    
-    if not status['providers']:
-        print("⚠️  No API keys configured. Fallback mode active.")
-        print()
-    
-    print("Type 'exit' to quit, 'status' for status")
-    print("-" * 70)
-    
-    while True:
-        try:
-            user_input = input("\nYou: ").strip()
-            if not user_input:
-                continue
-            if user_input.lower() == 'exit':
-                break
-            if user_input.lower() == 'status':
-                print(json.dumps(status, indent=2))
-                continue
-            
-            result = ice.process(user_input)
-            
-            print("\n[ICE THINKING]")
-            print(f"  Intent: {result['intent']['primary_intent']}")
-            print(f"  Confidence: {result['intent']['confidence']:.0%}")
-            print(f"  Complexity: {result['complexity']}")
-            print(f"  Crews: {', '.join(result['crews'])}")
-            print(f"  Provider: {result['provider']}")
-            print(f"  Model: {result['model']}")
-            print(f"  Time: {result['time']:.3f}s")
-            
-            print("\n[RESPONSE]")
-            print(result['response'])
-            
-            if result['providers_available']:
-                print(f"\n✓ Used {result['provider']} API")
-            else:
-                print("\n⚠️  Fallback mode")
-            
-        except KeyboardInterrupt:
-            print("\n\nGoodbye!")
-            break
-        except Exception as e:
-            print(f"\nError: {e}")
-    
-    print("\n" + "=" * 70)
-    print("Session ended")
-    print("=" * 70)