dbagent-cli 0.6.1__tar.gz → 0.7.0__tar.gz

{dbagent_cli-0.6.1 → dbagent_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbagent-cli
-Version: 0.6.1
+Version: 0.7.0
 Summary: Enterprise AI Database Copilot, Schema Graph Introspector & Autonomous Recovery Agent (CLI)
 Author: Santhosh Gupta
 Requires-Python: >=3.9

{dbagent_cli-0.6.1 → dbagent_cli-0.7.0}/dbagent/__init__.py

@@ -2,5 +2,5 @@
 DB-Agent: Universal Database Introspection and Script Generation AI Agent (CLI).
 """
 
-__version__ = "0.6.1"
+__version__ = "0.7.0"
 __author__ = "Santhosh Gupta"

{dbagent_cli-0.6.1 → dbagent_cli-0.7.0}/dbagent/cli.py

@@ -687,16 +687,18 @@ def chat_command(
                     if not cmd_arg:
                         curr_model = model or getattr(llm, "default_model", "default")
                         console.print(f"\n[bold cyan]Active AI Provider:[/bold cyan] [bold white]{llm.name}[/bold white] | Model: [bold green]{curr_model}[/bold green]")
-                        console.print("[dim]Usage: [bold]:provider <ollama|gemini|groq|openrouter>[/bold][/dim]\n")
+                        console.print("[dim]Supported: [bold]claude, openai, deepseek, mistral, gemini, groq, openrouter, ollama[/bold][/dim]\n")
                         continue
-                    prov_target = cmd_arg.lower()
-                    if prov_target in ["ollama", "gemini", "groq", "openrouter", "mock"]:
+                    prov_target = cmd_arg.lower().strip()
+                    if prov_target in ["claude", "anthropic", "openai", "chatgpt", "gpt", "deepseek", "mistral", "gemini", "groq", "openrouter", "ollama", "local", "mock"]:
                         llm = get_llm_provider(provider_name=prov_target, config_mgr=config_mgr)
                         model = None
                         pipeline.generator.llm = llm  # Update reused pipeline
                         print_success(f"Switched AI provider to [bold cyan]{llm.name}[/bold cyan]")
+                        if not llm.is_available() and llm.name not in ["ollama", "mock"]:
+                            print_warning(f"Note: API key for {llm.name} is not set. Run `db-agent config` or set {llm.name.upper()}_API_KEY.")
                     else:
-                        print_error(f"Unknown provider '{cmd_arg}'. Supported: ollama, gemini, groq, openrouter")
+                        print_error(f"Unknown provider '{cmd_arg}'. Supported: claude, openai, deepseek, mistral, gemini, groq, openrouter, ollama")
                     continue
 
                 if cmd_name in [":model", ":models", ":providers", ":ai"]:
@@ -710,18 +712,41 @@ def chat_command(
                         if avail_models:
                             console.print(f"[bold]Available Models for {llm.name}:[/bold]")
                             model_descriptions = {
-                                "gemini-flash-lite-latest": "⚡ Ultra-Fast (~0.8s) • Recommended for instant chat & queries",
+                                # Gemini
+                                "gemini-flash-lite-latest": "⚡ Ultra-Fast (~0.8s) • Instant chat & queries",
                                 "gemini-3.6-flash": "⚡ High Quality (~3.5s) • Strong SQL reasoning & accuracy",
                                 "gemini-3.7-flash": "🧠 Deep Reasoning (~13s) • Latest flagship model",
                                 "gemini-3.1-flash-lite": "⚡ Fast Lite (~4.0s) • Low latency",
                                 "gemini-flash-latest": "⚡ Standard Flash (~7.0s)",
+                                # Claude
+                                "claude-3-7-sonnet-20250219": "🧠 Hybrid Reasoning Flagship • Deepest architecture understanding",
+                                "claude-3-5-sonnet-20241022": "⚡ High Intelligence • Expert SQL engineer & schema specialist",
+                                "claude-3-5-haiku-20241022": "⚡ Ultra-Fast (~1s) • High speed and cost efficient",
+                                "claude-3-opus-20240229": "Deep complex schema reasoning",
+                                # OpenAI
+                                "gpt-4o": "⚡ Omni Flagship • High speed multimodal & complex SQL reasoning",
+                                "gpt-4o-mini": "⚡ Ultra-Fast (~1s) • High speed and cost efficient",
+                                "gpt-4.5-preview": "🧠 Next-Generation Reasoning model",
+                                "o3-mini": "🧠 Deep STEM & Advanced Coding Reasoning",
+                                "o1": "🧠 Maximum Reasoning & Math Architecture",
+                                # DeepSeek
+                                "deepseek-chat": "⚡ DeepSeek-V3 Ultra-Fast • Strong code & SQL",
+                                "deepseek-reasoner": "🧠 DeepSeek-R1 Full Chain-of-Thought Reasoning",
+                                # Mistral
+                                "codestral-latest": "⚡ Specialized Code & SQL Architect (22B)",
+                                "mistral-large-latest": "🧠 Flagship Reasoning & Multi-language",
+                                "mistral-small-latest": "⚡ Fast & lightweight",
+                                # Groq
+                                "llama-3.3-70b-versatile": "⚡ Llama 3.3 70B (500+ tokens/sec on Groq LPUs)",
+                                "llama-3.1-8b-instant": "⚡ Ultra-Fast Llama 3.1 8B (800+ tokens/sec)",
+                                "qwen-2.5-coder-32b": "⚡ Qwen 2.5 Coder 32B specialized SQL engineer",
                             }
                             for idx, m_name in enumerate(avail_models, 1):
                                 is_active = " [bold green]✓ Active[/bold green]" if m_name == curr_model else ""
                                 desc = model_descriptions.get(m_name, "")
                                 desc_str = f" - [dim]{desc}[/dim]" if desc else ""
                                 console.print(f"  [bold cyan]{idx}[/bold cyan]. [bold white]{m_name}[/bold white]{desc_str}{is_active}")
-                            console.print("\n[dim]Quick Switch: [bold]:model 1[/bold] (ultra-fast) | [bold]:model 3.7[/bold] | [bold]:model 3.6[/bold] | [bold]:model <name>[/bold][/dim]\n")
+                            console.print("\n[dim]Quick Switch: [bold]:model <number|name>[/bold] (e.g. [bold]:model 1[/bold] or [bold]:model 3.7[/bold] or [bold]:model 4o[/bold] or [bold]:model r1[/bold])[/dim]\n")
                         continue
 
                     # Handle numeric shortcut or name shortcut
@@ -731,13 +756,23 @@ def chat_command(
                         if 0 <= choice_idx < len(avail_models):
                             target_model = avail_models[choice_idx]
                     elif target_model in ["3.7", "37"]:
-                        target_model = "gemini-3.7-flash"
+                        target_model = "claude-3-7-sonnet-20250219" if llm.name == "claude" else "gemini-3.7-flash"
+                    elif target_model in ["3.5", "35"]:
+                        target_model = "claude-3-5-sonnet-20241022" if llm.name == "claude" else "gemini-3.5-flash"
                     elif target_model in ["3.6", "36"]:
                         target_model = "gemini-3.6-flash"
-                    elif target_model in ["lite", "fast", "flash-lite", "1"]:
-                        target_model = "gemini-flash-lite-latest"
-                    elif target_model in ["3.1"]:
-                        target_model = "gemini-3.1-flash-lite"
+                    elif target_model in ["4o", "gpt4o"]:
+                        target_model = "gpt-4o"
+                    elif target_model in ["mini", "4o-mini"]:
+                        target_model = "gpt-4o-mini"
+                    elif target_model in ["r1", "reasoner"]:
+                        target_model = "deepseek-reasoner"
+                    elif target_model in ["v3", "chat"]:
+                        target_model = "deepseek-chat"
+                    elif target_model in ["codestral"]:
+                        target_model = "codestral-latest"
+                    elif target_model in ["lite", "fast", "flash-lite"]:
+                        target_model = "gemini-flash-lite-latest" if llm.name == "gemini" else "claude-3-5-haiku-20241022"
                     elif avail_models:
                         matches = [m for m in avail_models if target_model.lower() in m.lower()]
                         if matches:
@@ -1586,7 +1621,7 @@ def run_command(
 
 @app.command(name="config")
 def config_command():
-    """Interactive wizard to configure AI providers and default settings."""
+    """Interactive wizard to configure AI providers and credentials."""
     print_banner()
     console.print("[bold cyan]DB-Agent Configuration Wizard[/bold cyan]\n")
 
@@ -1594,14 +1629,38 @@ def config_command():
     console.print(f"Current Default AI Provider: [bold green]{curr_provider}[/bold green]")
     provider_choice = Prompt.ask(
         "Select Default AI Provider",
-        choices=["ollama", "gemini", "groq", "openrouter", "keep"],
+        choices=["gemini", "claude", "openai", "deepseek", "mistral", "groq", "openrouter", "ollama", "keep"],
         default="keep",
     )
     if provider_choice != "keep":
         config_mgr.set_setting("default_provider", provider_choice)
         print_success(f"Default provider updated to [bold]{provider_choice}[/bold]")
 
-    if provider_choice == "gemini":
+    if provider_choice in ["claude", "anthropic"]:
+        console.print("[dim]Get your Anthropic API key at: [bold]https://console.anthropic.com[/bold][/dim]")
+        key = Prompt.ask("Enter ANTHROPIC_API_KEY", default=config_mgr.get_setting("anthropic_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("anthropic_api_key", key)
+            print_success("Anthropic Claude API key saved.")
+    elif provider_choice in ["openai", "chatgpt"]:
+        console.print("[dim]Get your OpenAI API key at: [bold]https://platform.openai.com/api-keys[/bold][/dim]")
+        key = Prompt.ask("Enter OPENAI_API_KEY", default=config_mgr.get_setting("openai_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("openai_api_key", key)
+            print_success("OpenAI API key saved.")
+    elif provider_choice == "deepseek":
+        console.print("[dim]Get your DeepSeek API key at: [bold]https://platform.deepseek.com[/bold][/dim]")
+        key = Prompt.ask("Enter DEEPSEEK_API_KEY", default=config_mgr.get_setting("deepseek_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("deepseek_api_key", key)
+            print_success("DeepSeek API key saved.")
+    elif provider_choice == "mistral":
+        console.print("[dim]Get your Mistral API key at: [bold]https://console.mistral.ai[/bold][/dim]")
+        key = Prompt.ask("Enter MISTRAL_API_KEY", default=config_mgr.get_setting("mistral_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("mistral_api_key", key)
+            print_success("Mistral API key saved.")
+    elif provider_choice == "gemini":
         console.print("[dim]Get your free Gemini API key at: [bold]https://aistudio.google.com/apikey[/bold][/dim]")
         key = Prompt.ask("Enter GEMINI_API_KEY", default=config_mgr.get_setting("gemini_api_key", "")).strip()
         if key:
@@ -1652,33 +1711,29 @@ def profiles_command():
 
 @app.command(name="models")
 def models_command():
-    """List available models across local Ollama and free cloud providers."""
+    """List available models across local Ollama and all major cloud providers."""
     print_banner()
-    console.print("[bold cyan]Supported Free & Standalone LLMs:[/bold cyan]\n")
-
-    ollama = get_llm_provider("ollama")
-    ollama_status = "[green]ONLINE (Ready)[/green]" if ollama.is_available() else "[red]OFFLINE (Run 'ollama serve')[/red]"
-    console.print(f"1. [bold white]Ollama (100% Local, Offline & Zero-Cost)[/bold white] - Status: {ollama_status}")
-    if ollama.is_available():
-        models = ollama.list_models()
-        console.print(f"   Installed Local Models: {', '.join(models) if models else 'None'}")
-    else:
-        console.print("   Recommended models: `ollama run qwen2.5-coder` or `ollama run llama3.2`")
-
-    gemini = get_llm_provider("gemini")
-    gemini_status = "[green]Configured[/green]" if gemini.is_available() else "[yellow]Not Configured (Free Key: aistudio.google.com)[/yellow]"
-    console.print(f"\n2. [bold white]Google Gemini (Free Tier)[/bold white] - Status: {gemini_status}")
-    console.print("   Available Models: `gemini-3.6-flash`, `gemini-2.5-flash`, `gemini-2.5-pro`")
-
-    groq = get_llm_provider("groq")
-    groq_status = "[green]Configured[/green]" if groq.is_available() else "[yellow]Not Configured (Free Key: console.groq.com)[/yellow]"
-    console.print(f"\n3. [bold white]Groq (Free Ultra-Fast Tier)[/bold white] - Status: {groq_status}")
-    console.print("   Available Models: `llama-3.3-70b-versatile`, `qwen-2.5-32b`")
+    console.print("[bold cyan]Supported AI Providers & Available Models:[/bold cyan]\n")
+
+    providers_to_show = [
+        ("gemini", "Google Gemini", "https://aistudio.google.com/apikey"),
+        ("claude", "Anthropic Claude", "https://console.anthropic.com"),
+        ("openai", "OpenAI / ChatGPT", "https://platform.openai.com"),
+        ("deepseek", "DeepSeek AI", "https://platform.deepseek.com"),
+        ("mistral", "Mistral AI", "https://console.mistral.ai"),
+        ("groq", "Groq (Ultra-Fast LPUs)", "https://console.groq.com"),
+        ("openrouter", "OpenRouter (100+ Models)", "https://openrouter.ai"),
+        ("ollama", "Ollama (100% Offline / Local)", "http://localhost:11434"),
+    ]
 
-    openrouter = get_llm_provider("openrouter")
-    openrouter_status = "[green]Configured[/green]" if openrouter.is_available() else "[yellow]Not Configured (openrouter.ai)[/yellow]"
-    console.print(f"\n4. [bold white]OpenRouter (Free Community Models)[/bold white] - Status: {openrouter_status}")
-    console.print("   Available Models: `meta-llama/llama-3.3-70b-instruct:free`, `qwen/qwen-2.5-coder-32b-instruct:free`\n")
+    for idx, (p_slug, p_label, p_url) in enumerate(providers_to_show, 1):
+        prov = get_llm_provider(p_slug, config_mgr=config_mgr)
+        status = "[bold green]✓ Configured & Ready[/bold green]" if prov.is_available() else f"[yellow]Not Configured ({p_url})[/yellow]"
+        console.print(f"{idx}. [bold white]{p_label}[/bold white] - Status: {status}")
+        models = prov.list_models() if hasattr(prov, "list_models") else []
+        if models:
+            console.print(f"   Models: [cyan]{', '.join(models[:5])}[/cyan]")
+        console.print("")
 
 
 # ---- setup ----
@@ -1699,7 +1754,7 @@ def setup_command(
     else:
         console.print("[bold white]Choose how you would like to setup DB-Agent:[/bold white]")
         console.print("  [bold green]1. Local Offline AI[/bold green] (Ollama + Coding Model) - [italic]100% Free, Private, Zero API Keys[/italic]")
-        console.print("  [bold cyan]2. Free Cloud AI[/bold cyan] (Google Gemini / Groq / OpenRouter) - [italic]Fast, requires free API key[/italic]")
+        console.print("  [bold cyan]2. Cloud AI[/bold cyan] (Claude / OpenAI / DeepSeek / Mistral / Gemini / Groq) - [italic]High speed & accuracy[/italic]")
         console.print("  [bold yellow]3. Normal Database CLI[/bold yellow] - [italic]No AI, use standard connect, scan & SQL tools only[/italic]\n")
 
         choice = Prompt.ask(
@@ -1720,17 +1775,41 @@ def setup_command(
             print_warning("Local setup incomplete. You can still use cloud AI or standard DB tools.")
             chosen_provider = "cloud"
     elif choice == "2":
-        console.print("\n[bold cyan]Setting up Free Cloud AI Provider...[/bold cyan]")
-        prov = Prompt.ask("Choose provider", choices=["gemini", "groq", "openrouter"], default="gemini")
+        console.print("\n[bold cyan]Setting up Cloud AI Provider...[/bold cyan]")
+        prov = Prompt.ask("Choose provider", choices=["gemini", "claude", "openai", "deepseek", "mistral", "groq", "openrouter"], default="gemini")
         config_mgr.set_setting("default_provider", prov)
-        if prov == "gemini":
-            console.print("[dim]Get free key at: [bold]https://aistudio.google.com/apikey[/bold][/dim]")
+        if prov in ["claude", "anthropic"]:
+            console.print("[dim]Get Anthropic key at: [bold]https://console.anthropic.com[/bold][/dim]")
+            k = Prompt.ask("Enter ANTHROPIC_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("anthropic_api_key", k)
+                print_success("Anthropic Claude API key saved.")
+        elif prov in ["openai", "chatgpt"]:
+            console.print("[dim]Get OpenAI key at: [bold]https://platform.openai.com/api-keys[/bold][/dim]")
+            k = Prompt.ask("Enter OPENAI_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("openai_api_key", k)
+                print_success("OpenAI API key saved.")
+        elif prov == "deepseek":
+            console.print("[dim]Get DeepSeek key at: [bold]https://platform.deepseek.com[/bold][/dim]")
+            k = Prompt.ask("Enter DEEPSEEK_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("deepseek_api_key", k)
+                print_success("DeepSeek API key saved.")
+        elif prov == "mistral":
+            console.print("[dim]Get Mistral key at: [bold]https://console.mistral.ai[/bold][/dim]")
+            k = Prompt.ask("Enter MISTRAL_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("mistral_api_key", k)
+                print_success("Mistral API key saved.")
+        elif prov == "gemini":
+            console.print("[dim]Get free Gemini key at: [bold]https://aistudio.google.com/apikey[/bold][/dim]")
             k = Prompt.ask("Enter GEMINI_API_KEY", default="")
             if k:
                 config_mgr.set_setting("gemini_api_key", k)
                 print_success("Gemini API key saved.")
         elif prov == "groq":
-            console.print("[dim]Get free key at: [bold]https://console.groq.com[/bold][/dim]")
+            console.print("[dim]Get free Groq key at: [bold]https://console.groq.com[/bold][/dim]")
             k = Prompt.ask("Enter GROQ_API_KEY", default="")
             if k:
                 config_mgr.set_setting("groq_api_key", k)

dbagent_cli-0.7.0/dbagent/llm/anthropic_provider.py

@@ -0,0 +1,126 @@
+"""
+Anthropic Claude LLM Provider.
+Supports claude-3-7-sonnet-20250219, claude-3-5-sonnet-20241022, claude-3-5-haiku-20241022, claude-3-opus-20240229.
+"""
+
+import json
+import os
+import requests
+from typing import Optional, Callable, List
+from dbagent.llm.base import BaseLLMProvider
+
+
+class ClaudeProvider(BaseLLMProvider):
+    """Anthropic Claude provider using direct HTTP REST API."""
+
+    FALLBACK_MODELS = [
+        "claude-3-7-sonnet-20250219",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+    ]
+
+    def __init__(self, api_key: Optional[str] = None, default_model: str = "claude-3-7-sonnet-20250219"):
+        if api_key is not None:
+            self.api_key = api_key
+        else:
+            self.api_key = os.getenv("ANTHROPIC_API_KEY") or os.getenv("CLAUDE_API_KEY")
+        self.default_model = default_model
+        self._session = requests.Session()
+        self._session.headers.update({
+            "User-Agent": "DB-Agent/0.7.0",
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        })
+        if self.api_key:
+            self._session.headers.update({"x-api-key": self.api_key})
+
+    @property
+    def name(self) -> str:
+        return "claude"
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def list_models(self) -> List[str]:
+        return self.FALLBACK_MODELS
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> str:
+        if not self.api_key:
+            raise ValueError(
+                "Anthropic API key is not configured. Set ANTHROPIC_API_KEY environment variable or run `db-agent config`."
+            )
+
+        requested_model = model or self.default_model
+        models_to_try = [requested_model]
+        for fb in self.FALLBACK_MODELS:
+            if fb != requested_model and fb not in models_to_try:
+                models_to_try.append(fb)
+
+        payload = {
+            "model": requested_model,
+            "max_tokens": 4096,
+            "temperature": 0.1,
+            "messages": [{"role": "user", "content": prompt}],
+        }
+        if system_prompt:
+            payload["system"] = system_prompt
+
+        endpoint = "https://api.anthropic.com/v1/messages"
+        last_error = None
+
+        for target_model in models_to_try:
+            payload["model"] = target_model
+            try:
+                if stream_callback:
+                    payload["stream"] = True
+                    response = self._session.post(endpoint, json=payload, stream=True, timeout=15)
+                    if response.status_code == 200:
+                        full_text = []
+                        for line in response.iter_lines():
+                            if line:
+                                decoded = line.decode("utf-8")
+                                if decoded.startswith("data: "):
+                                    raw_json = decoded[6:]
+                                    try:
+                                        chunk = json.loads(raw_json)
+                                        delta = chunk.get("delta", {})
+                                        text_piece = delta.get("text", "")
+                                        if text_piece:
+                                            full_text.append(text_piece)
+                                            stream_callback(text_piece)
+                                    except Exception:
+                                        pass
+                        return "".join(full_text)
+                    elif response.status_code in (404, 400, 503, 429):
+                        last_error = f"Model {target_model} status {response.status_code}"
+                        continue
+                    else:
+                        raise RuntimeError(f"Anthropic API error ({response.status_code}): {response.text}")
+                else:
+                    payload["stream"] = False
+                    response = self._session.post(endpoint, json=payload, timeout=20)
+                    if response.status_code == 200:
+                        data = response.json()
+                        content_blocks = data.get("content", [])
+                        text_blocks = [b.get("text", "") for b in content_blocks if b.get("type") == "text"]
+                        return "".join(text_blocks)
+                    elif response.status_code in (404, 400, 503, 429):
+                        last_error = f"Model {target_model} status {response.status_code}"
+                        continue
+                    else:
+                        raise RuntimeError(f"Anthropic API error ({response.status_code}): {response.text}")
+            except requests.exceptions.Timeout:
+                last_error = f"Model {target_model} timed out"
+                continue
+            except Exception as e:
+                last_error = str(e)
+                continue
+
+        raise RuntimeError(f"Anthropic generation error: {last_error or 'All model attempts failed'}")

dbagent_cli-0.7.0/dbagent/llm/deepseek_provider.py

@@ -0,0 +1,128 @@
+"""
+DeepSeek AI LLM Provider.
+Supports deepseek-chat (V3) and deepseek-reasoner (R1).
+"""
+
+import json
+import os
+import requests
+from typing import Optional, Callable, List
+from dbagent.llm.base import BaseLLMProvider
+
+
+class DeepSeekProvider(BaseLLMProvider):
+    """DeepSeek AI provider using direct HTTP REST API."""
+
+    FALLBACK_MODELS = [
+        "deepseek-chat",
+        "deepseek-reasoner",
+    ]
+
+    def __init__(self, api_key: Optional[str] = None, default_model: str = "deepseek-chat"):
+        if api_key is not None:
+            self.api_key = api_key
+        else:
+            self.api_key = os.getenv("DEEPSEEK_API_KEY")
+        self.default_model = default_model
+        self._session = requests.Session()
+        self._session.headers.update({
+            "User-Agent": "DB-Agent/0.7.0",
+            "content-type": "application/json",
+        })
+        if self.api_key:
+            self._session.headers.update({"Authorization": f"Bearer {self.api_key}"})
+
+    @property
+    def name(self) -> str:
+        return "deepseek"
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def list_models(self) -> List[str]:
+        return self.FALLBACK_MODELS
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> str:
+        if not self.api_key:
+            raise ValueError(
+                "DeepSeek API key is not configured. Set DEEPSEEK_API_KEY environment variable or run `db-agent config`."
+            )
+
+        requested_model = model or self.default_model
+        models_to_try = [requested_model]
+        for fb in self.FALLBACK_MODELS:
+            if fb != requested_model and fb not in models_to_try:
+                models_to_try.append(fb)
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        payload = {
+            "model": requested_model,
+            "messages": messages,
+            "temperature": 0.1,
+        }
+
+        endpoint = "https://api.deepseek.com/v1/chat/completions"
+        last_error = None
+
+        for target_model in models_to_try:
+            payload["model"] = target_model
+            try:
+                if stream_callback:
+                    payload["stream"] = True
+                    response = self._session.post(endpoint, json=payload, stream=True, timeout=15)
+                    if response.status_code == 200:
+                        full_text = []
+                        for line in response.iter_lines():
+                            if line:
+                                decoded = line.decode("utf-8")
+                                if decoded.startswith("data: ") and not decoded.startswith("data: [DONE]"):
+                                    raw_json = decoded[6:]
+                                    try:
+                                        chunk = json.loads(raw_json)
+                                        choices = chunk.get("choices", [])
+                                        if choices:
+                                            delta = choices[0].get("delta", {})
+                                            t = delta.get("content", "")
+                                            if t:
+                                                full_text.append(t)
+                                                stream_callback(t)
+                                    except Exception:
+                                        pass
+                        return "".join(full_text)
+                    elif response.status_code in (404, 400, 503, 429):
+                        last_error = f"Model {target_model} status {response.status_code}"
+                        continue
+                    else:
+                        raise RuntimeError(f"DeepSeek API error ({response.status_code}): {response.text}")
+                else:
+                    payload["stream"] = False
+                    response = self._session.post(endpoint, json=payload, timeout=20)
+                    if response.status_code == 200:
+                        data = response.json()
+                        choices = data.get("choices", [])
+                        if choices:
+                            return choices[0].get("message", {}).get("content", "")
+                        return ""
+                    elif response.status_code in (404, 400, 503, 429):
+                        last_error = f"Model {target_model} status {response.status_code}"
+                        continue
+                    else:
+                        raise RuntimeError(f"DeepSeek API error ({response.status_code}): {response.text}")
+            except requests.exceptions.Timeout:
+                last_error = f"Model {target_model} timed out"
+                continue
+            except Exception as e:
+                last_error = str(e)
+                continue
+
+        raise RuntimeError(f"DeepSeek generation error: {last_error or 'All model attempts failed'}")

{dbagent_cli-0.6.1 → dbagent_cli-0.7.0}/dbagent/llm/factory.py

@@ -1,6 +1,7 @@
 """
 LLM Provider Factory.
-Auto-detects available providers: Ollama (local) -> Gemini Free -> Groq Free -> OpenRouter Free -> Offline Fallback.
+Auto-detects and instantiates providers:
+Ollama (local) -> Claude (Anthropic) -> OpenAI (ChatGPT) -> DeepSeek -> Mistral -> Gemini -> Groq -> OpenRouter -> Mock.
 """
 
 from typing import Optional
@@ -8,6 +9,10 @@ from dbagent.config import ConfigManager
 from dbagent.llm.base import BaseLLMProvider
 from dbagent.llm.ollama_provider import OllamaProvider
 from dbagent.llm.gemini_provider import GeminiProvider
+from dbagent.llm.anthropic_provider import ClaudeProvider
+from dbagent.llm.openai_provider import OpenAIProvider
+from dbagent.llm.deepseek_provider import DeepSeekProvider
+from dbagent.llm.mistral_provider import MistralProvider
 from dbagent.llm.groq_provider import GroqProvider
 from dbagent.llm.openrouter_provider import OpenRouterProvider
 from dbagent.llm.mock_provider import MockProvider
@@ -23,17 +28,29 @@ def get_llm_provider(
 
     # 1. Explicit provider requested
     if provider_name:
-        p = provider_name.lower()
-        if p == "ollama":
+        p = provider_name.lower().strip()
+        if p in ["ollama", "local"]:
             base_url = cfg.get_setting("ollama_base_url", "http://localhost:11434")
             return OllamaProvider(base_url=base_url, default_model=model or "qwen2.5-coder")
-        elif p == "gemini":
+        elif p in ["claude", "anthropic"]:
+            key = cfg.get_setting("anthropic_api_key") or cfg.get_setting("claude_api_key")
+            return ClaudeProvider(api_key=key, default_model=model or "claude-3-7-sonnet-20250219")
+        elif p in ["openai", "chatgpt", "gpt"]:
+            key = cfg.get_setting("openai_api_key")
+            return OpenAIProvider(api_key=key, default_model=model or "gpt-4o")
+        elif p in ["deepseek", "r1", "v3"]:
+            key = cfg.get_setting("deepseek_api_key")
+            return DeepSeekProvider(api_key=key, default_model=model or "deepseek-chat")
+        elif p in ["mistral", "codestral"]:
+            key = cfg.get_setting("mistral_api_key")
+            return MistralProvider(api_key=key, default_model=model or "codestral-latest")
+        elif p in ["gemini", "google"]:
             key = cfg.get_setting("gemini_api_key")
             return GeminiProvider(api_key=key, default_model=model or "gemini-3.6-flash")
-        elif p == "groq":
+        elif p in ["groq"]:
             key = cfg.get_setting("groq_api_key")
             return GroqProvider(api_key=key, default_model=model or "llama-3.3-70b-versatile")
-        elif p == "openrouter":
+        elif p in ["openrouter", "router"]:
             key = cfg.get_setting("openrouter_api_key")
             return OpenRouterProvider(api_key=key, default_model=model or "meta-llama/llama-3.3-70b-instruct:free")
         elif p in ["mock", "offline"]:
@@ -54,20 +71,40 @@ def get_llm_provider(
     if ollama.is_available():
         return ollama
 
-    # B. Gemini if API key is present
+    # B. Claude / Anthropic if API key is present
+    claude_key = cfg.get_setting("anthropic_api_key") or cfg.get_setting("claude_api_key")
+    if claude_key:
+        return ClaudeProvider(api_key=claude_key, default_model=model or "claude-3-7-sonnet-20250219")
+
+    # C. OpenAI ChatGPT if API key is present
+    openai_key = cfg.get_setting("openai_api_key")
+    if openai_key:
+        return OpenAIProvider(api_key=openai_key, default_model=model or "gpt-4o")
+
+    # D. DeepSeek if API key is present
+    deepseek_key = cfg.get_setting("deepseek_api_key")
+    if deepseek_key:
+        return DeepSeekProvider(api_key=deepseek_key, default_model=model or "deepseek-chat")
+
+    # E. Mistral if API key is present
+    mistral_key = cfg.get_setting("mistral_api_key")
+    if mistral_key:
+        return MistralProvider(api_key=mistral_key, default_model=model or "codestral-latest")
+
+    # F. Gemini if API key is present
     gemini_key = cfg.get_setting("gemini_api_key")
     if gemini_key:
         return GeminiProvider(api_key=gemini_key)
 
-    # C. Groq if API key is present
+    # G. Groq if API key is present
     groq_key = cfg.get_setting("groq_api_key")
     if groq_key:
         return GroqProvider(api_key=groq_key)
 
-    # D. OpenRouter if API key is present
+    # H. OpenRouter if API key is present
     openrouter_key = cfg.get_setting("openrouter_api_key")
     if openrouter_key:
         return OpenRouterProvider(api_key=openrouter_key)
 
-    # E. Fallback to Ollama or Mock
+    # Fallback to Ollama or Mock
     return ollama