thwip-cli 1.0.0__py3-none-any.whl

thwip/agents/google_agent.py

@@ -0,0 +1,314 @@
+"""
+Google / Antigravity agent adapter.
+
+Full capabilities: chat, file editing, code execution, terminal, browser, search.
+Detects Antigravity IDE, Gemini CLI, and Google API keys.
+"""
+
+from __future__ import annotations
+
+import os
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, AsyncIterator
+
+from thwip.agents.base import (
+    AgentDone,
+    AgentEvent,
+    BaseAgent,
+    Capability,
+    LimitHit,
+    LimitStatus,
+    ModelInfo,
+    SubscriptionInfo,
+    SubscriptionTier,
+    TextDelta,
+    ThinkingDelta,
+    TokenUsage,
+    ToolUseStart,
+)
+
+
+class GoogleAgent(BaseAgent):
+    """
+    Google Antigravity / Gemini: full coding agent.
+    Capabilities: Chat, file editing, code execution, terminal, browser, web search.
+    Uses the google-genai SDK for API communication.
+    """
+
+    name = "google"
+    display_name = "Antigravity / Gemini"
+    company = "Google"
+    description = "Google's agentic coding assistant with full IDE, terminal, and browser access"
+    website = "https://gemini.google.com"
+
+    capabilities = {
+        Capability.CHAT,
+        Capability.FILE_EDIT,
+        Capability.FILE_READ,
+        Capability.CODE_RUN,
+        Capability.TERMINAL,
+        Capability.BROWSER,
+        Capability.SEARCH,
+        Capability.IMAGE_GEN,
+    }
+
+    available_models = [
+        ModelInfo(
+            id="gemini-2.5-pro",
+            name="Gemini 2.5 Pro",
+            context_window=1_048_576,
+            max_output=65_536,
+            supports_tools=True,
+            supports_streaming=True,
+            supports_vision=True,
+            supports_thinking=True,
+            is_default=True,
+            pricing_input=1.25,
+            pricing_output=10.0,
+        ),
+        ModelInfo(
+            id="gemini-2.5-flash",
+            name="Gemini 2.5 Flash",
+            context_window=1_048_576,
+            max_output=65_536,
+            supports_tools=True,
+            supports_streaming=True,
+            supports_vision=True,
+            supports_thinking=True,
+            pricing_input=0.15,
+            pricing_output=0.60,
+        ),
+    ]
+
+    def __init__(self, api_key: str | None = None) -> None:
+        self._api_key = api_key
+        self._client = None
+        self._last_limit_status = LimitStatus.UNKNOWN
+
+    def _get_api_key(self) -> str | None:
+        if self._api_key:
+            return self._api_key
+
+        # 1. Environment variables
+        for env_var in ("GEMINI_API_KEY", "GOOGLE_API_KEY"):
+            key = os.environ.get(env_var, "").strip()
+            if key:
+                return key
+
+        # 2. Gemini CLI / Antigravity config files
+        config_paths = [
+            Path.home() / ".config" / "gemini" / "config.json",
+            Path.home() / ".gemini" / "config.json",
+            Path.home() / ".config" / "antigravity" / "config.json",
+        ]
+        for p in config_paths:
+            if p.is_file():
+                try:
+                    data = json.loads(p.read_text())
+                    k = data.get("api_key") or data.get("apiKey") or ""
+                    if k:
+                        return k
+                except (json.JSONDecodeError, OSError):
+                    continue
+
+        return None
+
+    def _ensure_client(self) -> Any:
+        if self._client is None:
+            try:
+                from google import genai
+                key = self._get_api_key()
+                if key:
+                    self._client = genai.Client(api_key=key)
+                else:
+                    self._client = genai.Client()
+            except ImportError:
+                raise RuntimeError(
+                    "google-genai package not installed. Run: pip install google-genai"
+                )
+        return self._client
+
+    # --- Detection ---
+
+    def is_installed(self) -> bool:
+        """Check if Gemini CLI, Antigravity, or API is configured."""
+        return self.is_configured() or any(
+            shutil.which(cmd) is not None
+            for cmd in ("gemini", "agy", "antigravity")
+        )
+
+    def is_configured(self) -> bool:
+        return bool(self._get_api_key())
+
+    def get_install_info(self) -> dict[str, str]:
+        info: dict[str, str] = {"method": "not installed", "path": "", "version": ""}
+
+        for cmd in ("gemini", "agy", "antigravity"):
+            path = shutil.which(cmd)
+            if path:
+                info["path"] = path
+                info["method"] = "npm global" if cmd == "gemini" else "binary"
+                try:
+                    result = subprocess.run(
+                        [cmd, "--version"],
+                        capture_output=True, text=True, timeout=5,
+                    )
+                    if result.returncode == 0:
+                        info["version"] = result.stdout.strip().split("\n")[0]
+                except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+                    pass
+                break
+
+        # Also check for Antigravity IDE (macOS app)
+        if not info["path"]:
+            app_paths = [
+                Path("/Applications/Antigravity.app"),
+                Path.home() / "Applications" / "Antigravity.app",
+            ]
+            for app in app_paths:
+                if app.exists():
+                    info["method"] = "macOS app"
+                    info["path"] = str(app)
+                    break
+
+        return info
+
+    def get_subscription_info(self) -> SubscriptionInfo:
+        key = self._get_api_key()
+        if not key:
+            return SubscriptionInfo(
+                tier=SubscriptionTier.UNKNOWN,
+                is_active=False,
+                message="No API key found",
+            )
+
+        # Google Gemini API keys typically start with "AIza"
+        if key.startswith("AIza"):
+            return SubscriptionInfo(
+                tier=SubscriptionTier.FREE,  # Free tier by default
+                is_active=True,
+                message="Google API key detected",
+            )
+
+        return SubscriptionInfo(
+            tier=SubscriptionTier.UNKNOWN,
+            is_active=True,
+            message="API key detected",
+        )
+
+    # --- Chat ---
+
+    async def chat(
+        self,
+        messages: list[dict[str, Any]],
+        model: str | None = None,
+        system_prompt: str | None = None,
+        tools: list[dict[str, Any]] | None = None,
+        stream: bool = True,
+    ) -> AsyncIterator[AgentEvent]:
+        """Stream a chat response from Gemini."""
+        client = self._ensure_client()
+        model = model or self.get_default_model()
+
+        # Convert messages to Gemini format
+        gemini_contents = []
+        for msg in messages:
+            role = "user" if msg["role"] == "user" else "model"
+            gemini_contents.append({
+                "role": role,
+                "parts": [{"text": msg["content"]}],
+            })
+
+        config: dict[str, Any] = {}
+        if system_prompt:
+            config["system_instruction"] = system_prompt
+
+        model_info = self.get_model_info(model)
+        if model_info and model_info.supports_thinking:
+            config["thinking_config"] = {"thinking_budget": 8192}
+
+        try:
+            from google.genai import types
+
+            if stream:
+                response = client.models.generate_content_stream(
+                    model=model,
+                    contents=gemini_contents,
+                    config=types.GenerateContentConfig(**config) if config else None,
+                )
+
+                total_input = 0
+                total_output = 0
+
+                for chunk in response:
+                    if chunk.candidates:
+                        for candidate in chunk.candidates:
+                            if candidate.content and candidate.content.parts:
+                                for part in candidate.content.parts:
+                                    if hasattr(part, "thought") and part.thought:
+                                        yield ThinkingDelta(content=part.text or "")
+                                    elif hasattr(part, "text") and part.text:
+                                        yield TextDelta(content=part.text)
+
+                    if hasattr(chunk, "usage_metadata") and chunk.usage_metadata:
+                        um = chunk.usage_metadata
+                        total_input = getattr(um, "prompt_token_count", 0) or 0
+                        total_output = getattr(um, "candidates_token_count", 0) or 0
+
+                yield AgentDone(
+                    usage=TokenUsage(
+                        input_tokens=total_input,
+                        output_tokens=total_output,
+                    )
+                )
+                self._last_limit_status = LimitStatus.OK
+            else:
+                response = client.models.generate_content(
+                    model=model,
+                    contents=gemini_contents,
+                    config=types.GenerateContentConfig(**config) if config else None,
+                )
+
+                if response.candidates:
+                    for candidate in response.candidates:
+                        if candidate.content and candidate.content.parts:
+                            for part in candidate.content.parts:
+                                if hasattr(part, "text") and part.text:
+                                    yield TextDelta(content=part.text)
+
+                um = getattr(response, "usage_metadata", None)
+                yield AgentDone(
+                    usage=TokenUsage(
+                        input_tokens=getattr(um, "prompt_token_count", 0) or 0,
+                        output_tokens=getattr(um, "candidates_token_count", 0) or 0,
+                    )
+                )
+                self._last_limit_status = LimitStatus.OK
+
+        except Exception as e:
+            error_str = str(e).lower()
+            if "resource" in error_str and "exhaust" in error_str:
+                self._last_limit_status = LimitStatus.RATE_LIMITED
+                yield LimitHit(
+                    error_type=LimitStatus.RATE_LIMITED,
+                    message=str(e),
+                )
+            elif "quota" in error_str or "limit" in error_str:
+                self._last_limit_status = LimitStatus.QUOTA_EXHAUSTED
+                yield LimitHit(
+                    error_type=LimitStatus.QUOTA_EXHAUSTED,
+                    message=str(e),
+                )
+            else:
+                yield LimitHit(
+                    error_type=LimitStatus.UNKNOWN,
+                    message=str(e),
+                )
+
+    def check_limits(self) -> LimitStatus:
+        if not self.is_configured():
+            return LimitStatus.NO_KEY
+        return self._last_limit_status if self._last_limit_status != LimitStatus.UNKNOWN else LimitStatus.OK

thwip/agents/groq_agent.py

@@ -0,0 +1,181 @@
+"""
+Groq agent adapter.
+
+High speed LPU inference for Llama 3.3, Mixtral, and Gemma models.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from typing import Any, AsyncIterator
+
+from thwip.agents.base import (
+    AgentDone,
+    AgentEvent,
+    BaseAgent,
+    Capability,
+    LimitHit,
+    LimitStatus,
+    ModelInfo,
+    SubscriptionInfo,
+    SubscriptionTier,
+    TextDelta,
+    TokenUsage,
+    ToolUseStart,
+)
+
+
+class GroqAgent(BaseAgent):
+    """
+    Groq LPU Inference Agent.
+
+    Ultra-fast inference for rapid iteration.
+    """
+
+    name = "groq"
+    display_name = "Groq"
+    company = "Groq"
+    description = "Ultra high-speed LPU inference engine"
+    website = "https://groq.com"
+
+    capabilities = {
+        Capability.CHAT,
+        Capability.FILE_EDIT,
+        Capability.FILE_READ,
+        Capability.CODE_RUN,
+    }
+
+    available_models = [
+        ModelInfo(
+            id="llama-3.3-70b-versatile",
+            name="Llama 3.3 70B (Versatile)",
+            context_window=128_000,
+            max_output=32_768,
+            supports_tools=True,
+            supports_streaming=True,
+            is_default=True,
+            pricing_input=0.59,
+            pricing_output=0.79,
+        ),
+        ModelInfo(
+            id="mixtral-8x7b-32768",
+            name="Mixtral 8x7B",
+            context_window=32_768,
+            max_output=32_768,
+            supports_tools=True,
+            supports_streaming=True,
+            pricing_input=0.24,
+            pricing_output=0.24,
+        ),
+    ]
+
+    def __init__(self, api_key: str | None = None) -> None:
+        self._api_key = api_key
+        self._client = None
+        self._last_limit_status = LimitStatus.UNKNOWN
+
+    def _get_api_key(self) -> str | None:
+        if self._api_key:
+            return self._api_key
+        return os.environ.get("GROQ_API_KEY", "").strip() or None
+
+    def _ensure_client(self) -> Any:
+        if self._client is None:
+            try:
+                from openai import AsyncOpenAI
+                key = self._get_api_key()
+                self._client = AsyncOpenAI(
+                    api_key=key or "dummy",
+                    base_url="https://api.groq.com/openai/v1",
+                )
+            except ImportError:
+                raise RuntimeError("openai package required for Groq adapter.")
+        return self._client
+
+    def is_installed(self) -> bool:
+        return self.is_configured() or shutil.which("groq") is not None
+
+    def is_configured(self) -> bool:
+        return bool(self._get_api_key())
+
+    def get_install_info(self) -> dict[str, str]:
+        path = shutil.which("groq") or ""
+        return {
+            "method": "API / CLI" if path else "API Key Configured",
+            "path": path,
+            "version": "API v1",
+        }
+
+    def get_subscription_info(self) -> SubscriptionInfo:
+        key = self._get_api_key()
+        if not key:
+            return SubscriptionInfo(tier=SubscriptionTier.UNKNOWN, is_active=False, message="No API key found")
+        return SubscriptionInfo(tier=SubscriptionTier.FREE, is_active=True, message="Groq API key ready")
+
+    async def chat(
+        self,
+        messages: list[dict[str, Any]],
+        model: str | None = None,
+        system_prompt: str | None = None,
+        tools: list[dict[str, Any]] | None = None,
+        stream: bool = True,
+    ) -> AsyncIterator[AgentEvent]:
+        import openai
+
+        client = self._ensure_client()
+        model = model or self.get_default_model()
+
+        api_messages: list[dict[str, Any]] = []
+        if system_prompt:
+            api_messages.append({"role": "system", "content": system_prompt})
+        api_messages.extend(messages)
+
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "stream": stream,
+        }
+        if tools:
+            kwargs["tools"] = tools
+
+        try:
+            if stream:
+                response = await client.chat.completions.create(**kwargs)
+                total_usage = TokenUsage()
+                async for chunk in response:
+                    if chunk.choices:
+                        delta = chunk.choices[0].delta
+                        if delta.content:
+                            yield TextDelta(content=delta.content)
+                    if chunk.usage:
+                        total_usage = TokenUsage(
+                            input_tokens=chunk.usage.prompt_tokens or 0,
+                            output_tokens=chunk.usage.completion_tokens or 0,
+                        )
+                yield AgentDone(usage=total_usage)
+                self._last_limit_status = LimitStatus.OK
+            else:
+                response = await client.chat.completions.create(**kwargs)
+                msg = response.choices[0].message
+                if msg.content:
+                    yield TextDelta(content=msg.content)
+                usage = response.usage
+                yield AgentDone(
+                    usage=TokenUsage(
+                        input_tokens=usage.prompt_tokens if usage else 0,
+                        output_tokens=usage.completion_tokens if usage else 0,
+                    )
+                )
+                self._last_limit_status = LimitStatus.OK
+
+        except openai.RateLimitError as e:
+            self._last_limit_status = LimitStatus.RATE_LIMITED
+            yield LimitHit(error_type=LimitStatus.RATE_LIMITED, message=str(e))
+        except Exception as e:
+            yield LimitHit(error_type=LimitStatus.UNKNOWN, message=str(e))
+
+    def check_limits(self) -> LimitStatus:
+        if not self.is_configured():
+            return LimitStatus.NO_KEY
+        return self._last_limit_status if self._last_limit_status != LimitStatus.UNKNOWN else LimitStatus.OK

thwip/agents/ollama_agent.py

@@ -0,0 +1,180 @@
+"""
+Ollama agent adapter.
+
+Local offline models with unlimited quota, zero cost, and full privacy.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import urllib.request
+import urllib.error
+from typing import Any, AsyncIterator
+
+import httpx
+
+from thwip.agents.base import (
+    AgentDone,
+    AgentEvent,
+    BaseAgent,
+    Capability,
+    LimitStatus,
+    ModelInfo,
+    SubscriptionInfo,
+    SubscriptionTier,
+    TextDelta,
+    TokenUsage,
+    ToolUseStart,
+)
+
+
+class OllamaAgent(BaseAgent):
+    """
+    Ollama Local Agent.
+
+    Runs entirely on-device with zero rate limits and unlimited usage.
+    """
+
+    name = "ollama"
+    display_name = "Ollama (Local)"
+    company = "Ollama"
+    description = "Local models running entirely on-device (zero API limits, private)"
+    website = "https://ollama.com"
+
+    capabilities = {
+        Capability.CHAT,
+        Capability.FILE_EDIT,
+        Capability.FILE_READ,
+        Capability.CODE_RUN,
+    }
+
+    def __init__(self, host: str = "http://localhost:11434") -> None:
+        self.host = host.rstrip("/")
+        self._cached_models: list[ModelInfo] | None = None
+
+    @property
+    def available_models(self) -> list[ModelInfo]:
+        if self._cached_models is not None:
+            return self._cached_models
+
+        # Try to query running Ollama server for downloaded models
+        models = []
+        try:
+            req = urllib.request.Request(f"{self.host}/api/tags")
+            with urllib.request.urlopen(req, timeout=1.5) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+                for m in data.get("models", []):
+                    name = m.get("name", "")
+                    models.append(
+                        ModelInfo(
+                            id=name,
+                            name=f"{name} (Local)",
+                            context_window=32_768,
+                            max_output=8_192,
+                            supports_tools=True,
+                            supports_streaming=True,
+                            pricing_input=0.0,
+                            pricing_output=0.0,
+                        )
+                    )
+        except Exception:
+            pass
+
+        if not models:
+            # Defaults
+            models = [
+                ModelInfo(id="llama3.3", name="Llama 3.3", is_default=True),
+                ModelInfo(id="qwen2.5-coder", name="Qwen 2.5 Coder"),
+                ModelInfo(id="deepseek-r1", name="DeepSeek R1 Distill"),
+                ModelInfo(id="codellama", name="CodeLlama"),
+            ]
+        self._cached_models = models
+        return models
+
+    def is_installed(self) -> bool:
+        return shutil.which("ollama") is not None or self._is_server_reachable()
+
+    def _is_server_reachable(self) -> bool:
+        try:
+            req = urllib.request.Request(f"{self.host}/api/tags")
+            with urllib.request.urlopen(req, timeout=1.0) as resp:
+                return resp.status == 200
+        except Exception:
+            return False
+
+    def is_configured(self) -> bool:
+        return self._is_server_reachable()
+
+    def get_install_info(self) -> dict[str, str]:
+        path = shutil.which("ollama") or ""
+        return {
+            "method": "CLI / Local Daemon" if path else "Local Server",
+            "path": path or self.host,
+            "version": "Local",
+        }
+
+    def get_subscription_info(self) -> SubscriptionInfo:
+        return SubscriptionInfo(
+            tier=SubscriptionTier.UNLIMITED,
+            is_active=self.is_configured(),
+            message="Unlimited offline local compute",
+        )
+
+    async def chat(
+        self,
+        messages: list[dict[str, Any]],
+        model: str | None = None,
+        system_prompt: str | None = None,
+        tools: list[dict[str, Any]] | None = None,
+        stream: bool = True,
+    ) -> AsyncIterator[AgentEvent]:
+        model = model or self.get_default_model()
+        formatted_messages = []
+        if system_prompt:
+            formatted_messages.append({"role": "system", "content": system_prompt})
+        formatted_messages.extend(messages)
+
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": formatted_messages,
+            "stream": stream,
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            if stream:
+                async with client.stream(
+                    "POST", f"{self.host}/api/chat", json=payload
+                ) as resp:
+                    if resp.status_code != 200:
+                        yield AgentDone()
+                        return
+                    async for line in resp.aiter_lines():
+                        if not line:
+                            continue
+                        try:
+                            data = json.loads(line)
+                            msg = data.get("message", {})
+                            content = msg.get("content", "")
+                            if content:
+                                yield TextDelta(content=content)
+                            if data.get("done"):
+                                prompt_eval = data.get("prompt_eval_count", 0)
+                                eval_count = data.get("eval_count", 0)
+                                yield AgentDone(
+                                    usage=TokenUsage(
+                                        input_tokens=prompt_eval,
+                                        output_tokens=eval_count,
+                                    )
+                                )
+                        except json.JSONDecodeError:
+                            continue
+            else:
+                resp = await client.post(f"{self.host}/api/chat", json=payload)
+                if resp.status_code == 200:
+                    data = resp.json()
+                    yield TextDelta(content=data.get("message", {}).get("content", ""))
+                    yield AgentDone()
+
+    def check_limits(self) -> LimitStatus:
+        return LimitStatus.OK if self.is_configured() else LimitStatus.NO_KEY