gemi-cli 0.1.0__py3-none-any.whl

gemi/providers/openai_compat.py

@@ -0,0 +1,140 @@
+import json
+from typing import AsyncIterator
+
+from openai import AsyncOpenAI
+
+from gemi.providers.base import BaseProvider, Chunk, Message
+
+
+class OpenAICompatProvider(BaseProvider):
+    def __init__(self, api_key: str, base_url: str = "https://api.openai.com/v1", provider_name: str = ""):
+        extra_headers = {}
+        if "openrouter" in base_url:
+            extra_headers["HTTP-Referer"] = "https://github.com/gemi-cli/gemi"
+            extra_headers["X-Title"] = "gemi"
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            default_headers=extra_headers or None,
+        )
+
+    def update_key(self, api_key: str):
+        self.client.api_key = api_key
+
+    async def chat(
+        self,
+        messages: list[Message],
+        tools: list[dict] | None = None,
+        model: str | None = None,
+        stream: bool = True,
+    ) -> AsyncIterator[Chunk]:
+        model = model or "gpt-4o-mini"
+        formatted_messages = self._build_messages(messages)
+        formatted_tools = self.format_tools(tools) if tools else None
+
+        kwargs = {"model": model, "messages": formatted_messages}
+        if formatted_tools:
+            kwargs["tools"] = formatted_tools
+
+        if stream:
+            kwargs["stream"] = True
+            response = await self.client.chat.completions.create(**kwargs)
+            tool_calls_acc = {}
+            async for chunk in response:
+                if not chunk.choices:
+                    continue
+                choice = chunk.choices[0]
+                if choice.finish_reason == "error":
+                    error_msg = choice.delta.content if choice.delta and choice.delta.content else "Provider returned error"
+                    raise Exception(f"Provider returned error: {error_msg}")
+                delta = choice.delta
+                if not delta:
+                    continue
+                if delta.content:
+                    yield Chunk(text=delta.content)
+                if delta.tool_calls:
+                    for tc in delta.tool_calls:
+                        idx = tc.index
+                        if idx not in tool_calls_acc:
+                            tool_calls_acc[idx] = {
+                                "id": tc.id or "",
+                                "function": {"name": "", "arguments": ""},
+                            }
+                        if tc.id:
+                            tool_calls_acc[idx]["id"] = tc.id
+                        if tc.function:
+                            if tc.function.name:
+                                tool_calls_acc[idx]["function"]["name"] = tc.function.name
+                            if tc.function.arguments:
+                                tool_calls_acc[idx]["function"]["arguments"] += tc.function.arguments
+
+            if tool_calls_acc:
+                calls = []
+                for tc_data in tool_calls_acc.values():
+                    try:
+                        tc_data["function"]["arguments"] = json.loads(
+                            tc_data["function"]["arguments"]
+                        )
+                    except json.JSONDecodeError:
+                        pass
+                    calls.append(tc_data)
+                yield Chunk(tool_calls=calls)
+        else:
+            response = await self.client.chat.completions.create(**kwargs)
+            choice = response.choices[0]
+            if choice.message.content:
+                yield Chunk(text=choice.message.content)
+            if choice.message.tool_calls:
+                calls = []
+                for tc in choice.message.tool_calls:
+                    args = tc.function.arguments
+                    try:
+                        args = json.loads(args)
+                    except json.JSONDecodeError:
+                        pass
+                    calls.append({
+                        "id": tc.id,
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": args,
+                        },
+                    })
+                yield Chunk(tool_calls=calls)
+
+    def _build_messages(self, messages: list[Message]) -> list[dict]:
+        result = []
+        for msg in messages:
+            entry = {"role": msg.role, "content": msg.content}
+            if msg.tool_calls:
+                entry["tool_calls"] = [
+                    {
+                        "id": tc["id"],
+                        "type": "function",
+                        "function": {
+                            "name": tc["function"]["name"],
+                            "arguments": json.dumps(tc["function"]["arguments"])
+                            if isinstance(tc["function"]["arguments"], dict)
+                            else tc["function"]["arguments"],
+                        },
+                    }
+                    for tc in msg.tool_calls
+                ]
+            if msg.tool_call_id:
+                entry["tool_call_id"] = msg.tool_call_id
+            if msg.name:
+                entry["name"] = msg.name
+            result.append(entry)
+        return result
+
+    def format_tools(self, tools: list[dict]) -> list[dict]:
+        formatted = []
+        for tool in tools:
+            formatted.append({
+                "type": "function",
+                "function": {
+                    "name": tool["name"],
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get("parameters", {}),
+                },
+            })
+        return formatted

gemi/registry.py

@@ -0,0 +1,201 @@
+PROVIDERS = {
+    "gemini": {
+        "name": "Google Gemini",
+        "type": "gemini",
+        "base_url": None,
+        "default_model": "gemini-2.5-flash",
+        "models": [
+            "gemini-2.5-flash",
+            "gemini-2.5-flash-lite",
+            "gemini-2.5-pro",
+        ],
+        "free_tier": True,
+        "key_url": "https://aistudio.google.com/apikey",
+        "key_prefix": "AIza",
+        "needs_key": True,
+        "context_window": 1_000_000,
+    },
+    "groq": {
+        "name": "Groq",
+        "type": "openai_compat",
+        "base_url": "https://api.groq.com/openai/v1",
+        "default_model": "llama-3.3-70b-versatile",
+        "models": [
+            "llama-3.3-70b-versatile",
+            "llama-3.1-8b-instant",
+            "meta-llama/llama-4-scout-17b-16e-instruct",
+            "openai/gpt-oss-120b",
+            "openai/gpt-oss-20b",
+            "qwen/qwen3-32b",
+            "allam-2-7b",
+        ],
+        "free_tier": True,
+        "key_url": "https://console.groq.com/keys",
+        "key_prefix": "gsk_",
+        "needs_key": True,
+        "context_window": 128_000,
+    },
+    "deepseek": {
+        "name": "DeepSeek",
+        "type": "openai_compat",
+        "base_url": "https://api.deepseek.com",
+        "default_model": "deepseek-chat",
+        "models": [
+            "deepseek-chat",
+            "deepseek-reasoner",
+        ],
+        "free_tier": False,
+        "key_url": "https://platform.deepseek.com/api_keys",
+        "key_prefix": "sk-",
+        "needs_key": True,
+        "context_window": 128_000,
+    },
+    "openrouter": {
+        "name": "OpenRouter",
+        "type": "openai_compat",
+        "base_url": "https://openrouter.ai/api/v1",
+        "default_model": "qwen/qwen3-coder:free",
+        "models": [
+            "qwen/qwen3-coder:free",
+            "nvidia/nemotron-3-ultra-550b-a55b:free",
+            "nvidia/nemotron-3-super-120b-a12b:free",
+            "openai/gpt-oss-120b:free",
+            "google/gemma-4-31b-it:free",
+            "qwen/qwen3-next-80b-a3b-instruct:free",
+            "moonshotai/kimi-k2.6:free",
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "nousresearch/hermes-3-llama-3.1-405b:free",
+            "poolside/laguna-m.1:free",
+            "z-ai/glm-4.5-air:free",
+        ],
+        "free_tier": True,
+        "key_url": "https://openrouter.ai/keys",
+        "key_prefix": "sk-or-",
+        "needs_key": True,
+        "context_window": 1_000_000,
+    },
+    "mistral": {
+        "name": "Mistral AI",
+        "type": "openai_compat",
+        "base_url": "https://api.mistral.ai/v1",
+        "default_model": "codestral-latest",
+        "models": [
+            "codestral-latest",
+            "mistral-large-latest",
+            "mistral-small-latest",
+            "pixtral-large-latest",
+        ],
+        "free_tier": True,
+        "key_url": "https://console.mistral.ai/api-keys",
+        "key_prefix": "",
+        "needs_key": True,
+        "context_window": 128_000,
+    },
+    "openai": {
+        "name": "OpenAI",
+        "type": "openai_compat",
+        "base_url": "https://api.openai.com/v1",
+        "default_model": "gpt-4o-mini",
+        "models": [
+            "gpt-4o-mini",
+            "gpt-4o",
+            "gpt-4.1-mini",
+            "gpt-4.1-nano",
+        ],
+        "free_tier": False,
+        "key_url": "https://platform.openai.com/api-keys",
+        "key_prefix": "sk-",
+        "needs_key": True,
+        "context_window": 128_000,
+    },
+    "together": {
+        "name": "Together AI",
+        "type": "openai_compat",
+        "base_url": "https://api.together.xyz/v1",
+        "default_model": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        "models": [
+            "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+            "deepseek-ai/DeepSeek-R1",
+            "Qwen/Qwen2.5-Coder-32B-Instruct",
+        ],
+        "free_tier": False,
+        "key_url": "https://api.together.ai/settings/api-keys",
+        "key_prefix": "",
+        "needs_key": True,
+        "context_window": 128_000,
+    },
+    "cerebras": {
+        "name": "Cerebras",
+        "type": "openai_compat",
+        "base_url": "https://api.cerebras.ai/v1",
+        "default_model": "llama-3.3-70b",
+        "models": [
+            "llama-3.3-70b",
+            "llama-4-scout-17b-16e-instruct",
+        ],
+        "free_tier": True,
+        "key_url": "https://cloud.cerebras.ai/",
+        "key_prefix": "csk-",
+        "needs_key": True,
+        "context_window": 128_000,
+    },
+    "ollama": {
+        "name": "Ollama (Local)",
+        "type": "ollama",
+        "base_url": "http://localhost:11434",
+        "default_model": "qwen3",
+        "models": [
+            "qwen3",
+            "gemma4",
+            "mistral-small",
+            "llama3.3",
+            "deepseek-v3.2",
+            "llama4-scout",
+        ],
+        "free_tier": True,
+        "key_url": None,
+        "key_prefix": "",
+        "needs_key": False,
+        "context_window": 32_768,
+    },
+}
+
+ALL_PROVIDER_NAMES = list(PROVIDERS.keys())
+
+
+def get_provider_info(name: str) -> dict | None:
+    return PROVIDERS.get(name)
+
+
+def get_provider_type(name: str) -> str:
+    info = PROVIDERS.get(name)
+    if not info:
+        return "openai_compat"
+    return info["type"]
+
+
+def get_base_url(name: str) -> str | None:
+    info = PROVIDERS.get(name)
+    if not info:
+        return None
+    return info["base_url"]
+
+
+def get_default_model(name: str) -> str:
+    info = PROVIDERS.get(name)
+    if not info:
+        return "gpt-4o-mini"
+    return info["default_model"]
+
+
+def get_context_window(name: str, model: str | None = None) -> int:
+    if name == "gemini":
+        return 1_000_000
+    info = PROVIDERS.get(name)
+    if info:
+        return info["context_window"]
+    return 128_000
+
+
+def list_free_providers() -> list[str]:
+    return [name for name, info in PROVIDERS.items() if info["free_tier"]]

gemi/sessions.py

@@ -0,0 +1,84 @@
+import json
+import time
+from pathlib import Path
+
+from gemi.config import GEMI_DIR
+from gemi.providers.base import Message
+
+SESSIONS_DIR = GEMI_DIR / "sessions"
+
+
+def _ensure_dir():
+    SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def save_session(session_id: str, messages: list[Message], metadata: dict | None = None):
+    _ensure_dir()
+    data = {
+        "session_id": session_id,
+        "saved_at": time.time(),
+        "metadata": metadata or {},
+        "messages": [
+            {
+                "role": m.role,
+                "content": m.content,
+                "tool_calls": m.tool_calls,
+                "tool_call_id": m.tool_call_id,
+                "name": m.name,
+            }
+            for m in messages
+        ],
+    }
+    path = SESSIONS_DIR / f"{session_id}.json"
+    path.write_text(json.dumps(data, indent=2))
+
+
+def load_session(session_id: str) -> list[Message] | None:
+    path = SESSIONS_DIR / f"{session_id}.json"
+    if not path.exists():
+        return None
+    data = json.loads(path.read_text())
+    return [
+        Message(
+            role=m["role"],
+            content=m.get("content", ""),
+            tool_calls=m.get("tool_calls"),
+            tool_call_id=m.get("tool_call_id"),
+            name=m.get("name"),
+        )
+        for m in data["messages"]
+    ]
+
+
+def list_sessions() -> list[dict]:
+    _ensure_dir()
+    sessions = []
+    for path in sorted(SESSIONS_DIR.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True):
+        try:
+            data = json.loads(path.read_text())
+            msg_count = len(data.get("messages", []))
+            user_msgs = [m for m in data.get("messages", []) if m["role"] == "user"]
+            preview = user_msgs[0]["content"][:80] if user_msgs else "(empty)"
+            sessions.append({
+                "id": data["session_id"],
+                "saved_at": data.get("saved_at", 0),
+                "messages": msg_count,
+                "preview": preview,
+                "cwd": data.get("metadata", {}).get("cwd", ""),
+            })
+        except (json.JSONDecodeError, KeyError):
+            continue
+    return sessions
+
+
+def delete_session(session_id: str) -> bool:
+    path = SESSIONS_DIR / f"{session_id}.json"
+    if path.exists():
+        path.unlink()
+        return True
+    return False
+
+
+def generate_session_id() -> str:
+    import hashlib
+    return hashlib.md5(str(time.time()).encode()).hexdigest()[:8]