@voria/cli 0.0.3 → 0.0.5

package/python/voria/core/llm/minimax_provider.py

@@ -0,0 +1,187 @@
+"""MiniMax LLM Provider via NVIDIA Integrate API"""
+
+import logging
+from typing import List, Dict, Any, Optional
+import httpx
+
+from .base import BaseLLMProvider, Message, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class MiniMaxProvider(BaseLLMProvider):
+    """MiniMax LLM Provider using NVIDIA's OpenAI-compatible API"""
+
+    API_ENDPOINT = "https://integrate.api.nvidia.com/v1/chat/completions"
+    DEFAULT_MODEL = "minimaxai/minimax-m2.7"
+
+    def __init__(self, api_key: str, model: str = DEFAULT_MODEL):
+        """
+        Initialize MiniMax provider
+
+        Args:
+            api_key: NVIDIA API key
+            model: Model (minimaxai/minimax-m2.7, etc)
+        """
+        super().__init__(api_key, model)
+        self.client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=300.0,
+        )
+
+    async def generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ) -> LLMResponse:
+        """Generate response using MiniMax"""
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": msg.role, "content": msg.content} for msg in messages
+                ],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": 0.95,
+                "stream": False,
+            }
+
+            logger.debug(f"Calling MiniMax API with {len(messages)} messages")
+            logger.info(f"Sending generation request to MiniMax model {self.model}...")
+
+            response = await self.client.post(self.API_ENDPOINT, json=payload)
+            response.raise_for_status()
+
+            data = response.json()
+            content = data["choices"][0]["message"]["content"]
+            tokens_used = data.get("usage", {}).get("total_tokens", 0)
+
+            logger.info(f"MiniMax API response: {tokens_used} tokens used")
+
+            return LLMResponse(
+                content=content,
+                tokens_used=tokens_used,
+                model=self.model,
+                provider="MiniMax",
+            )
+
+        except httpx.HTTPError as e:
+            logger.error(f"MiniMax API error: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error generating with MiniMax: {e}")
+            raise
+
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        """Stream generation from MiniMax"""
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": msg.role, "content": msg.content} for msg in messages
+                ],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": 0.95,
+                "stream": True,
+            }
+
+            import json
+
+            async with self.client.stream("POST", self.API_ENDPOINT, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line: continue
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]": break
+                        try:
+                            data = json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except Exception as e:
+                            logger.error(f"Error parsing stream chunk: {e}")
+                            continue
+
+        except Exception as e:
+            logger.error(f"Error in MiniMax stream: {e}")
+            raise
+
+    async def plan(self, issue_description: str) -> str:
+        """Generate implementation plan"""
+        system_message = Message(
+            role="system",
+            content="""You are an expert software architect.
+Create a detailed implementation plan for fixing this GitHub issue.""",
+        )
+
+        user_message = Message(role="user", content=f"Issue:\n{issue_description}")
+
+        response = await self.generate([system_message, user_message], max_tokens=2000)
+
+        return response.content
+
+    async def generate_patch(
+        self,
+        issue_description: str,
+        context_files: Dict[str, str],
+        previous_errors: Optional[str] = None,
+    ) -> str:
+        """Generate code patch in unified diff format"""
+        system_message = Message(
+            role="system",
+            content="""Generate a unified diff format patch.
+Format:
+--- a/path
++++ b/path
+@@ -line,count +line,count @@""",
+        )
+
+        context = f"Issue:\n{issue_description}\n\n"
+        for filename, content in context_files.items():
+            context += f"\n--- {filename} ---\n{content}\n"
+
+        if previous_errors:
+            context += f"\nPrevious Errors:\n{previous_errors}"
+
+        user_message = Message(role="user", content=context)
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=3000, temperature=0.5
+        )
+
+        return response.content
+
+    async def analyze_test_failure(
+        self, test_output: str, code_context: str
+    ) -> Dict[str, Any]:
+        """Analyze test failure"""
+        system_message = Message(
+            role="system", content="Analyze the test failure and suggest fixes."
+        )
+
+        user_message = Message(
+            role="user",
+            content=f"""Test Output:
+{test_output}
+
+Code:
+{code_context}""",
+        )
+
+        response = await self.generate([system_message, user_message], max_tokens=1500)
+
+        return {
+            "analysis": response.content,
+            "provider": "MiniMax",
+            "tokens_used": response.tokens_used,
+        }
+
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()

package/python/voria/core/llm/modal_provider.py

@@ -214,6 +214,39 @@ Code Context:
             "tokens_used": response.tokens_used,
         }
 
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        """Stream response tokens from Modal"""
+        import json as _json
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [{"role": m.role, "content": m.content} for m in messages],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "stream": True,
+            }
+            async with self.client.stream("POST", self.API_ENDPOINT, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = _json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except Exception:
+                            continue
+        except Exception as e:
+            logger.error(f"Modal stream error: {e}")
+            raise
+
     async def close(self):
         """Close HTTP client"""
         await self.client.aclose()

package/python/voria/core/llm/model_discovery.py

@@ -5,9 +5,10 @@ Fetches available models at runtime based on API keys.
 
 import asyncio
 import httpx
-from dataclasses import dataclass
+from dataclasses import dataclass, asdict
 from typing import List, Optional
 import logging
+import json
 
 logger = logging.getLogger(__name__)
 
@@ -26,6 +27,40 @@ class ModelInfo:
 class ModelDiscovery:
     """Fetch available models from LLM providers."""
 
+    @staticmethod
+    async def fetch_generic_openai_compatible(
+        api_key: str, base_url: str, provider_name: str
+    ) -> List[ModelInfo]:
+        """Fetch models from an OpenAI-compatible API."""
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{base_url.rstrip('/')}/models",
+                    headers={"Authorization": f"Bearer {api_key}"},
+                    timeout=10.0,
+                )
+                if response.status_code == 200:
+                    data = response.json()
+                    models = []
+                    for model in data.get("data", []):
+                        model_id = model.get("id", "")
+                        models.append(
+                            ModelInfo(
+                                name=model_id,
+                                display_name=model_id,
+                                description=f"{provider_name} Model",
+                            )
+                        )
+                    return models
+                else:
+                    logger.warning(
+                        f"{provider_name} API returned {response.status_code}"
+                    )
+                    return []
+        except Exception as e:
+            logger.warning(f"Failed to fetch {provider_name} models: {e}")
+            return []
+
     @staticmethod
     async def fetch_modal_models(api_key: str) -> List[ModelInfo]:
         """Fetch available models from Modal Z.ai API."""
@@ -39,7 +74,6 @@ class ModelDiscovery:
                 if response.status_code == 200:
                     data = response.json()
                     models = []
-                    # Modal returns model data in "data" key
                     for model in data.get("data", []):
                         models.append(
                             ModelInfo(
@@ -52,31 +86,15 @@ class ModelDiscovery:
                     return (
                         models if models else await ModelDiscovery._get_modal_fallback()
                     )
-                else:
-                    logger.warning(
-                        f"Modal API returned {response.status_code}, using fallback models"
-                    )
-                    return await ModelDiscovery._get_modal_fallback()
-        except Exception as e:
-            logger.warning(f"Failed to fetch Modal models: {e}, using fallback")
+                return await ModelDiscovery._get_modal_fallback()
+        except Exception:
             return await ModelDiscovery._get_modal_fallback()
 
     @staticmethod
     async def _get_modal_fallback() -> List[ModelInfo]:
-        """Fallback models for Modal when API unavailable."""
         return [
-            ModelInfo(
-                name="zai-org/GLM-5.1-FP8",
-                display_name="GLM-5.1-FP8 (745B, Latest)",
-                max_tokens=4096,
-                description="Latest Modal Z.ai model - 745B parameters",
-            ),
-            ModelInfo(
-                name="zai-org/GLM-4",
-                display_name="GLM-4 (370B, Legacy)",
-                max_tokens=2048,
-                description="Previous generation Modal model",
-            ),
+            ModelInfo(name="zai-org/GLM-5.1-FP8", display_name="GLM-5.1-FP8 (Latest)"),
+            ModelInfo(name="zai-org/GLM-4", display_name="GLM-4 (Legacy)"),
         ]
 
     @staticmethod
@@ -92,81 +110,32 @@ class ModelDiscovery:
                 if response.status_code == 200:
                     data = response.json()
                     models = []
-                    # Filter to only gpt models suitable for text generation
-                    suitable_models = {
-                        "gpt-4o",
-                        "gpt-4-turbo",
-                        "gpt-4",
-                        "gpt-3.5-turbo",
-                    }
+                    suitable_prefixes = {"gpt-4", "gpt-3.5", "o1-"}
                     for model in data.get("data", []):
                         model_id = model.get("id", "")
-                        # Match by prefix or exact name
-                        if any(
-                            model_id.startswith(prefix) for prefix in suitable_models
-                        ):
+                        if any(model_id.startswith(p) for p in suitable_prefixes):
                             models.append(
-                                ModelInfo(
-                                    name=model_id,
-                                    display_name=model_id,
-                                    description=f"OpenAI - {model.get('owned_by', 'N/A')}",
-                                )
+                                ModelInfo(name=model_id, display_name=model_id)
                             )
-                    # Sort by recency (gpt-4o > gpt-4-turbo > gpt-4 > gpt-3.5-turbo)
                     return (
-                        sorted(
-                            models,
-                            key=lambda x: (
-                                not x.name.startswith("gpt-4o"),
-                                not x.name.startswith("gpt-4-turbo"),
-                                not x.name.startswith("gpt-4"),
-                            ),
-                        )
+                        models
                         if models
                         else await ModelDiscovery._get_openai_fallback()
                     )
-                else:
-                    logger.warning(
-                        f"OpenAI API returned {response.status_code}, using fallback models"
-                    )
-                    return await ModelDiscovery._get_openai_fallback()
-        except Exception as e:
-            logger.warning(f"Failed to fetch OpenAI models: {e}, using fallback")
+                return await ModelDiscovery._get_openai_fallback()
+        except Exception:
             return await ModelDiscovery._get_openai_fallback()
 
     @staticmethod
     async def _get_openai_fallback() -> List[ModelInfo]:
-        """Fallback models for OpenAI when API unavailable."""
         return [
-            ModelInfo(
-                name="gpt-5.4",
-                display_name="GPT-5.4 (Latest Frontier)",
-                max_tokens=128000,
-                description="Best intelligence at scale for agentic, coding, and professional workflows. $2.50 input, $15 output per 1M tokens",
-            ),
-            ModelInfo(
-                name="gpt-5.4-mini",
-                display_name="GPT-5.4-mini (Mini Model)",
-                max_tokens=128000,
-                description="Strongest mini model yet for coding, computer use, and agentic tasks. $0.75 input, $4.50 output per 1M tokens",
-            ),
-            ModelInfo(
-                name="gpt-5.4-nano",
-                display_name="GPT-5.4-nano (Cheapest)",
-                max_tokens=128000,
-                description="Cheapest GPT-5.4-class model for simple high-volume tasks. $0.20 input, $1.25 output per 1M tokens",
-            ),
-            ModelInfo(
-                name="gpt-4o",
-                display_name="GPT-4o (Previous High Quality)",
-                max_tokens=128000,
-                description="Previous latest model - optimized for speed and cost",
-            ),
+            ModelInfo(name="gpt-4o", display_name="GPT-4o"),
+            ModelInfo(name="gpt-4o-mini", display_name="GPT-4o-mini"),
+            ModelInfo(name="o1-preview", display_name="o1-preview"),
         ]
 
     @staticmethod
     async def fetch_gemini_models(api_key: str) -> List[ModelInfo]:
-        """Fetch available models from Google Gemini API."""
         try:
             async with httpx.AsyncClient() as client:
                 response = await client.get(
@@ -176,106 +145,53 @@ class ModelDiscovery:
                 if response.status_code == 200:
                     data = response.json()
                     models = []
-                    # Filter to generative models
                     for model in data.get("models", []):
-                        model_name = model.get("name", "").replace("models/", "")
-                        if "gemini" in model_name.lower():
-                            models.append(
-                                ModelInfo(
-                                    name=model_name,
-                                    display_name=model_name,
-                                    description=f"Google Gemini - {model.get('displayName', 'N/A')}",
-                                )
-                            )
+                        name = model.get("name", "").replace("models/", "")
+                        if "gemini" in name.lower():
+                            models.append(ModelInfo(name=name, display_name=name))
                     return (
                         models
                         if models
                         else await ModelDiscovery._get_gemini_fallback()
                     )
-                else:
-                    logger.warning(
-                        f"Gemini API returned {response.status_code}, using fallback models"
-                    )
-                    return await ModelDiscovery._get_gemini_fallback()
-        except Exception as e:
-            logger.warning(f"Failed to fetch Gemini models: {e}, using fallback")
+                return await ModelDiscovery._get_gemini_fallback()
+        except Exception:
             return await ModelDiscovery._get_gemini_fallback()
 
     @staticmethod
     async def _get_gemini_fallback() -> List[ModelInfo]:
-        """Fallback models for Gemini when API unavailable."""
+        return [
+            ModelInfo(name="gemini-1.5-pro", display_name="Gemini 1.5 Pro"),
+            ModelInfo(name="gemini-1.5-flash", display_name="Gemini 1.5 Flash"),
+        ]
+
+    @staticmethod
+    async def _get_claude_fallback() -> List[ModelInfo]:
         return [
             ModelInfo(
-                name="gemini-3.1-pro",
-                display_name="Gemini 3.1 Pro (Latest SOTA Reasoning)",
-                max_tokens=200000,
-                description="Latest SOTA reasoning model with unprecedented depth and nuance. $2 input, $12 output per context window",
-            ),
-            ModelInfo(
-                name="gemini-3-flash",
-                display_name="Gemini 3 Flash (Latest, Fastest)",
-                max_tokens=200000,
-                description="Most intelligent model built for speed, combining frontier intelligence with superior search and grounding",
-            ),
-            ModelInfo(
-                name="gemini-3.1-flash-lite",
-                display_name="Gemini 3.1 Flash Lite (Cheapest)",
-                max_tokens=200000,
-                description="Most cost-efficient model, optimized for high-volume agentic tasks. $0.25 input, $1.50 output",
-            ),
-            ModelInfo(
-                name="gemini-2.0-flash",
-                display_name="Gemini 2.0 Flash (Previous)",
-                max_tokens=2000,
-                description="Previous generation Gemini model",
+                name="claude-3-5-sonnet-20240620", display_name="Claude 3.5 Sonnet"
             ),
+            ModelInfo(name="claude-3-opus-20240229", display_name="Claude 3 Opus"),
+            ModelInfo(name="claude-3-haiku-20240307", display_name="Claude 3 Haiku"),
         ]
 
     @staticmethod
     async def fetch_claude_models(api_key: str) -> List[ModelInfo]:
-        """Fetch available models from Anthropic Claude API."""
-        try:
-            async with httpx.AsyncClient() as client:
-                # Claude doesn't have a public models endpoint, use documented models
-                # Make a test call to verify API key works
-                response = await client.get(
-                    "https://api.anthropic.com/v1/models",
-                    headers={"x-api-key": api_key},
-                    timeout=10.0,
-                )
-                # If we get here, API key works - return known models
-                return await ModelDiscovery._get_claude_fallback()
-        except Exception as e:
-            logger.warning(f"Failed to verify Claude API: {e}, returning known models")
-            return await ModelDiscovery._get_claude_fallback()
+        # Anthropic doesn't have a models endpoint, just return hardcoded
+        return await ModelDiscovery._get_claude_fallback()
 
     @staticmethod
-    async def _get_claude_fallback() -> List[ModelInfo]:
-        """Known Claude models (Anthropic doesn't provide list endpoint)."""
+    async def _get_minimax_fallback() -> List[ModelInfo]:
         return [
             ModelInfo(
-                name="claude-opus-4.6",
-                display_name="Claude Opus 4.6 (Most Intelligent)",
-                max_tokens=200000,
-                description="Most intelligent broadly available model for complex reasoning. $5 input, $25 output per 1M tokens",
-            ),
-            ModelInfo(
-                name="claude-sonnet-4.6",
-                display_name="Claude Sonnet 4.6 (Best Value)",
-                max_tokens=200000,
-                description="Best balance of speed and intelligence. $3 input, $15 output per 1M tokens",
-            ),
-            ModelInfo(
-                name="claude-haiku-4.5",
-                display_name="Claude Haiku 4.5 (Fastest, Cheapest)",
-                max_tokens=200000,
-                description="Fast and cost-efficient for simpler tasks. $0.80 input, $4 output per 1M tokens",
+                name="minimaxai/minimax-m2.7",
+                display_name="MiniMax M2.7",
+                description="MiniMax M2.7 via NVIDIA",
             ),
         ]
 
     @staticmethod
     async def discover_all(provider: str, api_key: str) -> List[ModelInfo]:
-        """Discover all models for a given provider."""
         provider = provider.lower().strip()
         if provider == "modal":
             return await ModelDiscovery.fetch_modal_models(api_key)
@@ -285,5 +201,38 @@ class ModelDiscovery:
             return await ModelDiscovery.fetch_gemini_models(api_key)
         elif provider == "claude":
             return await ModelDiscovery.fetch_claude_models(api_key)
+        elif provider == "deepseek":
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://api.deepseek.com/v1", "DeepSeek"
+            )
+        elif provider == "kimi":
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://api.moonshot.cn/v1", "Kimi"
+            )
+        elif provider == "minimax":
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://integrate.api.nvidia.com/v1", "MiniMax"
+            )
+        elif provider == "siliconflow":
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://api.siliconflow.cn/v1", "SiliconFlow"
+            )
         else:
-            raise ValueError(f"Unknown provider: {provider}")
+            return []
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 3:
+        print(json.dumps([]))
+        sys.exit(0)
+
+    provider = sys.argv[1]
+    api_key = sys.argv[2]
+
+    async def main():
+        models = await ModelDiscovery.discover_all(provider, api_key)
+        print(json.dumps([asdict(m) for m in models]))
+
+    asyncio.run(main())

package/python/voria/core/llm/openai_provider.py

@@ -141,6 +141,39 @@ Code:
             "tokens_used": response.tokens_used,
         }
 
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        """Stream response tokens from OpenAI"""
+        import json as _json
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [{"role": m.role, "content": m.content} for m in messages],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "stream": True,
+            }
+            async with self.client.stream("POST", self.API_ENDPOINT, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = _json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except Exception:
+                            continue
+        except Exception as e:
+            logger.error(f"OpenAI stream error: {e}")
+            raise
+
     async def close(self):
         """Close HTTP client"""
         await self.client.aclose()