Upload 18 files

app.py

@@ -144,6 +144,7 @@ class WebDevRequest(BaseModel):
     existing_code: str | None = None
     mode: str = "html"  # "html" or "react"
     error_message: str | None = None  # For agentic error fixing
+    model: str | None = None  # Model to use (e.g., "kimi-k2", "claude-sonnet")
 
 @app.post("/webdev/generate")
 async def handle_webdev(request: WebDevRequest):
@@ -152,7 +153,8 @@ async def handle_webdev(request: WebDevRequest):
             prompt=request.prompt,
             refine_code=request.existing_code,
             mode=request.mode,
-            error_message=request.error_message
+            error_message=request.error_message,
+            model=request.model
         )
         return result
     except Exception as e:

jade/webdev.py

@@ -1,23 +1,80 @@
 """
 Jade Web Dev - Vibe Coder
 AI-powered web code generator with React/Sandpack support
+Multi-model support: Groq + OpenRouter
 """
 
 import os
 import json
 import logging
 from groq import Groq
+from openai import OpenAI
 
 logger = logging.getLogger("JadeWebDev")
 
 class WebDevAgent:
+    # Available models configuration
+    MODELS = {
+        "kimi-k2": {
+            "name": "Kimi K2",
+            "provider": "groq",
+            "model_id": "moonshotai/kimi-k2-instruct-0905",
+            "description": "Rápido, bom para código"
+        },
+        "qwen-coder": {
+            "name": "Qwen Coder",
+            "provider": "groq",
+            "model_id": "qwen-2.5-coder-32b",
+            "description": "Especialista em código"
+        },
+        "llama-90b": {
+            "name": "Llama 3.3 70B",
+            "provider": "groq",
+            "model_id": "llama-3.3-70b-versatile",
+            "description": "Versátil, bom contexto"
+        },
+        "claude-sonnet": {
+            "name": "Claude Sonnet",
+            "provider": "openrouter",
+            "model_id": "anthropic/claude-sonnet-4",
+            "description": "Alta qualidade, longo contexto"
+        },
+        "deepseek-coder": {
+            "name": "DeepSeek Coder",
+            "provider": "openrouter",
+            "model_id": "deepseek/deepseek-coder",
+            "description": "Especialista código open-source"
+        },
+        "gpt-4o-mini": {
+            "name": "GPT-4o Mini",
+            "provider": "openrouter", 
+            "model_id": "openai/gpt-4o-mini",
+            "description": "Rápido e capaz"
+        }
+    }
+
     def __init__(self):
         self.groq_api_key = os.getenv("GROQ_API_KEY")
-        if not self.groq_api_key:
-            logger.warning("GROQ_API_KEY not set. WebDev agent may fail.")
+        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+        
+        # Initialize clients
+        self.groq_client = None
+        self.openrouter_client = None
+        
+        if self.groq_api_key:
+            self.groq_client = Groq(api_key=self.groq_api_key)
+        else:
+            logger.warning("GROQ_API_KEY not set.")
+            
+        if self.openrouter_api_key:
+            self.openrouter_client = OpenAI(
+                base_url="https://openrouter.ai/api/v1",
+                api_key=self.openrouter_api_key
+            )
+        else:
+            logger.warning("OPENROUTER_API_KEY not set. Some models unavailable.")
         
-        self.client = Groq(api_key=self.groq_api_key)
-        self.model = "moonshotai/kimi-k2-instruct-0905"
+        self.default_model = "kimi-k2"
         
         # HTML mode prompt
         self.html_prompt = """You are an elite web developer AI creating stunning, FULLY FUNCTIONAL websites.
@@ -97,7 +154,46 @@ DESIGN:
 
 OUTPUT: Only the JSON object, nothing else."""
 
-    def generate(self, prompt: str, refine_code: str = None, mode: str = "html", error_message: str = None) -> dict:
+    def _call_model(self, model_key: str, messages: list, temperature: float = 0.7, max_tokens: int = 16000) -> str:
+        """Call the appropriate model based on provider"""
+        model_config = self.MODELS.get(model_key, self.MODELS[self.default_model])
+        provider = model_config["provider"]
+        model_id = model_config["model_id"]
+        
+        if provider == "groq":
+            if not self.groq_client:
+                raise Exception("Groq client not available")
+            response = self.groq_client.chat.completions.create(
+                model=model_id,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+        elif provider == "openrouter":
+            if not self.openrouter_client:
+                # Fallback to Groq if OpenRouter not available
+                logger.warning(f"OpenRouter not available, falling back to Groq")
+                if not self.groq_client:
+                    raise Exception("No API client available")
+                response = self.groq_client.chat.completions.create(
+                    model=self.MODELS[self.default_model]["model_id"],
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens
+                )
+            else:
+                response = self.openrouter_client.chat.completions.create(
+                    model=model_id,
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens
+                )
+        else:
+            raise Exception(f"Unknown provider: {provider}")
+        
+        return response.choices[0].message.content.strip()
+
+    def generate(self, prompt: str, refine_code: str = None, mode: str = "html", error_message: str = None, model: str = None) -> dict:
         """
         Generate or refine code based on prompt
         
@@ -106,11 +202,13 @@ OUTPUT: Only the JSON object, nothing else."""
             refine_code: Optional existing code to refine
             mode: "html" for HTML generation, "react" for React/Sandpack
             error_message: If provided, fix this error in the code
+            model: Model key to use (e.g., "kimi-k2", "claude-sonnet")
             
         Returns:
             dict with code/files and success status
         """
         try:
+            model_key = model if model and model in self.MODELS else self.default_model
             system_prompt = self.react_prompt if mode == "react" else self.html_prompt
             
             if mode == "react":
@@ -143,18 +241,17 @@ Update the React app based on the feedback. Output the complete updated JSON."""
                 else:
                     user_message = f"Create a React app: {prompt}"
                 
-                response = self.client.chat.completions.create(
-                    model=self.model,
-                    messages=[
-                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": user_message}
-                    ],
-                    temperature=0.5 if error_message else 0.7,  # Lower temp for fixes
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_message}
+                ]
+                content = self._call_model(
+                    model_key, 
+                    messages, 
+                    temperature=0.5 if error_message else 0.7,
                     max_tokens=16000
                 )
                 
-                content = response.choices[0].message.content.strip()
-                
                 # Clean up markdown if present
                 if content.startswith("```json"):
                     content = content[7:]
@@ -203,18 +300,17 @@ Update the code based on the feedback. Output the complete updated HTML file."""
                 else:
                     user_message = f"Create a website: {prompt}"
                 
-                response = self.client.chat.completions.create(
-                    model=self.model,
-                    messages=[
-                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": user_message}
-                    ],
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_message}
+                ]
+                code = self._call_model(
+                    model_key,
+                    messages,
                     temperature=0.5 if error_message else 0.7,
                     max_tokens=8000
                 )
                 
-                code = response.choices[0].message.content.strip()
-                
                 # Clean up markdown
                 if code.startswith("```html"):
                     code = code[7:]