polymath-agent 0.4.0__py3-none-any.whl

polymath/adapters/ollama.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import json as _json_module
+from typing import Any, AsyncIterator
+
+import httpx
+
+from polymath.adapters.base import (
+    BaseAdapter, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_MAX_TOKENS,
+    Message, ToolCall,
+)
+
+
+class OllamaAdapter(BaseAdapter):
+    provider = "ollama"
+
+    def __init__(self, base_url: str = "http://localhost:11434") -> None:
+        self._base = base_url.rstrip("/")
+
+    def _to_messages(self, messages: list[Message], system: str) -> list[dict]:
+        result = []
+        if system:
+            result.append({"role": "system", "content": system})
+        for m in messages:
+            if m.role == "system":
+                continue
+            result.append({"role": m.role, "content": m.content})
+        return result
+
+    def _convert_tools(self, tools: list[Any] | None) -> list[dict] | None:
+        if not tools:
+            return None
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": t.name,
+                    "description": t.description,
+                    "parameters": t.parameters,
+                },
+            }
+            for t in tools
+        ]
+
+    async def complete(
+        self,
+        messages: list[Message],
+        model_id: str,
+        system: str = "",
+        tools: list[Any] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = DEFAULT_MAX_TOKENS,
+    ) -> str | Message:
+        body: dict[str, Any] = {
+            "model": model_id,
+            "messages": self._to_messages(messages, system),
+            "stream": False,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        ollama_tools = self._convert_tools(tools)
+        if ollama_tools:
+            body["tools"] = ollama_tools
+
+        async with httpx.AsyncClient(timeout=120) as client:
+            resp = await client.post(f"{self._base}/api/chat", json=body)
+            resp.raise_for_status()
+            data = resp.json()
+
+        msg = data.get("message", {})
+        raw_tool_calls = msg.get("tool_calls", [])
+        if raw_tool_calls:
+            tc_list = []
+            for tc in raw_tool_calls:
+                fn = tc.get("function", {})
+                tc_id = tc.get("id", fn.get("name", ""))
+                args = fn.get("arguments", {})
+                if isinstance(args, str):
+                    try:
+                        args = _json_module.loads(args)
+                    except Exception:
+                        args = {}
+                tc_list.append(ToolCall(id=tc_id, name=fn.get("name", ""), arguments=args))
+            return Message(
+                role="assistant",
+                content=msg.get("content", ""),
+                tool_calls=tc_list,
+            )
+
+        return msg.get("content", "")
+
+    async def stream(
+        self,
+        messages: list[Message],
+        model_id: str,
+        system: str = "",
+        tools: list[Any] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = DEFAULT_STREAM_MAX_TOKENS,
+    ) -> AsyncIterator[str]:
+        body: dict[str, Any] = {
+            "model": model_id,
+            "messages": self._to_messages(messages, system),
+            "stream": True,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        ollama_tools = self._convert_tools(tools)
+        if ollama_tools:
+            body["tools"] = ollama_tools
+
+        async with httpx.AsyncClient(timeout=120) as client:
+            async with client.stream("POST", f"{self._base}/api/chat", json=body) as resp:
+                async for line in resp.aiter_lines():
+                    if line.strip():
+                        chunk = _json_module.loads(line)
+                        content = chunk.get("message", {}).get("content", "")
+                        if content:
+                            yield content

polymath/adapters/openai_adapter.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+from typing import Any, AsyncIterator
+
+from polymath.adapters.base import (
+    AuthExpiredError, BaseAdapter, DEFAULT_MAX_TOKENS,
+    DEFAULT_STREAM_MAX_TOKENS, Message, ToolCall,
+    is_auth_failure, resolve_exception_types, truncation_notice,
+)
+
+
+def _auth_types() -> tuple[type, ...]:
+    return resolve_exception_types(
+        "openai", "AuthenticationError", "PermissionDeniedError",
+    )
+
+
+class OpenAIAdapter(BaseAdapter):
+    provider = "openai"
+
+    def __init__(self, api_key: str, base_url: str = "") -> None:
+        from openai import AsyncOpenAI
+        client_kwargs: dict[str, Any] = {}
+        if base_url:
+            client_kwargs["base_url"] = base_url
+        if api_key.startswith("chatgpt_oauth:"):
+            # Codex CLI ChatGPT OAuth — use as bearer token
+            token = api_key[len("chatgpt_oauth:"):]
+            self._client = AsyncOpenAI(
+                api_key="unused",
+                default_headers={"Authorization": f"Bearer {token}"},
+                **client_kwargs,
+            )
+        else:
+            self._client = AsyncOpenAI(api_key=api_key or "lm-studio", **client_kwargs)
+        self._last_input_tokens: int = 0
+        self._last_output_tokens: int = 0
+
+    def _convert_tools(self, tools: list[Any] | None) -> list[dict] | None:
+        if not tools:
+            return None
+        oai_tools = []
+        for t in tools:
+            oai_tools.append({
+                "type": "function",
+                "function": t.to_json_schema()
+            })
+        return oai_tools
+
+    def _to_oai(self, messages: list[Message], system: str) -> list[dict]:
+        result = []
+        if system:
+            result.append({"role": "system", "content": system})
+        for m in messages:
+            if m.role == "system":
+                continue
+            
+            msg = {"role": m.role, "content": m.content or ""}
+            
+            if m.tool_calls:
+                msg["tool_calls"] = [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.name,
+                            "arguments": json.dumps(tc.arguments)
+                        }
+                    } for tc in m.tool_calls
+                ]
+            
+            if m.role == "tool":
+                msg["tool_call_id"] = m.tool_call_id
+
+            result.append(msg)
+        return result
+
+    async def complete(
+        self,
+        messages: list[Message],
+        model_id: str,
+        system: str = "",
+        tools: list[Any] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = DEFAULT_MAX_TOKENS,
+    ) -> str | Message:
+        oai_tools = self._convert_tools(tools)
+        kwargs = dict(
+            model=model_id,
+            messages=self._to_oai(messages, system),
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        if oai_tools:
+            kwargs["tools"] = oai_tools
+
+        try:
+            resp = await self._client.chat.completions.create(**kwargs)
+        except Exception as e:
+            if is_auth_failure(e, _auth_types()):
+                raise AuthExpiredError("openai", "codex login") from e
+            raise
+
+        if hasattr(resp, "usage") and resp.usage:
+            self._last_input_tokens = getattr(resp.usage, "prompt_tokens", 0)
+            self._last_output_tokens = getattr(resp.usage, "completion_tokens", 0)
+
+        choice = resp.choices[0]
+        oai_msg = choice.message
+        truncated = getattr(choice, "finish_reason", None) == "length"
+
+        if oai_msg.tool_calls:
+            tool_calls = [
+                ToolCall(
+                    id=tc.id,
+                    name=tc.function.name,
+                    arguments=json.loads(tc.function.arguments)
+                ) for tc in oai_msg.tool_calls
+            ]
+            content = oai_msg.content or ""
+            if truncated:
+                content += truncation_notice(max_tokens)
+            return Message(
+                role="assistant",
+                content=content,
+                tool_calls=tool_calls
+            )
+
+        if truncated:
+            return (oai_msg.content or "") + truncation_notice(max_tokens)
+        return oai_msg.content
+
+    async def stream(
+        self,
+        messages: list[Message],
+        model_id: str,
+        system: str = "",
+        tools: list[Any] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = DEFAULT_STREAM_MAX_TOKENS,
+    ) -> AsyncIterator[str | ToolCall]:
+        # Simplified stream for text only for now
+        stream = await self._client.chat.completions.create(
+            model=model_id,
+            messages=self._to_oai(messages, system),
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=True,
+        )
+        try:
+            async for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content:
+                    yield chunk.choices[0].delta.content
+        except Exception as e:
+            if is_auth_failure(e, _auth_types()):
+                raise AuthExpiredError("openai", "codex login") from e
+            raise
+
+    def count_tokens(self, text: str) -> int:
+        """tiktoken is OpenAI's own tokenizer, so it belongs here and only
+        here. cl100k_base covers the GPT-4 family; a model it does not know
+        falls back to the character estimate."""
+        try:
+            import tiktoken
+            return len(tiktoken.get_encoding("cl100k_base").encode(text))
+        except Exception:
+            return len(text) // 4

polymath/bootstrap.py

@@ -0,0 +1,159 @@
+"""
+Dependency bootstrap — runs before any other import in main.py.
+
+Checks the dependencies polymath needs and reports what is missing. It does
+NOT install anything unless the user opts in with POLYMATH_AUTO_INSTALL=1,
+because a published CLI must never mutate the environment it is run from:
+`polymath --help` would otherwise pip-install into whatever interpreter is
+active, which may be a shared or read-only one.
+"""
+from __future__ import annotations
+
+import importlib
+import os
+import subprocess
+import sys
+
+#: Distribution name to suggest in the "run this to fix it" hint.
+DIST_EXTRA = "polymath-agent[orchestrator]"
+
+
+def auto_install_enabled() -> bool:
+    """Auto-install is opt-in, via POLYMATH_AUTO_INSTALL=1."""
+    return os.environ.get("POLYMATH_AUTO_INSTALL", "").strip().lower() in {
+        "1", "true", "yes", "on",
+    }
+
+
+# (import_name, pip_package, min_version_check)
+REQUIRED: list[tuple[str, str]] = [
+    ("anthropic",       "anthropic>=0.40.0"),
+    ("openai",          "openai>=1.50.0"),
+    ("rich",            "rich>=13.0.0"),
+    ("prompt_toolkit",  "prompt_toolkit>=3.0.0"),
+    ("tiktoken",        "tiktoken>=0.7.0"),
+    ("httpx",           "httpx>=0.27.0"),
+    ("sqlite_vec",      "sqlite-vec>=0.1.6"),
+]
+
+OPTIONAL: list[tuple[str, str, str]] = [
+    # (import_name, pip_package, human_label)
+    ("google.genai",  "google-genai>=1.0.0",  "Gemini"),
+]
+
+# Old package → new package (auto-upgrade)
+DEPRECATED: list[tuple[str, str, str]] = [
+    # (old_import, old_pip_pkg, new_pip_pkg)
+    ("google.generativeai", "google-generativeai", "google-genai>=1.0.0"),
+]
+
+
+def _pip(*args: str) -> bool:
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "install", "-q", *args],
+        capture_output=True, text=True,
+    )
+    return result.returncode == 0
+
+
+def _importable(module: str) -> bool:
+    import warnings
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            importlib.import_module(module)
+        return True
+    except ImportError:
+        return False
+
+
+def run() -> None:
+    """
+    Check deps and report. Only prints if something is missing.
+    Safe to call every startup — returns immediately if everything is fine.
+
+    With POLYMATH_AUTO_INSTALL=1 it also repairs what it finds, which is the
+    old self-healing behaviour and is meant for local development only.
+    """
+    auto = auto_install_enabled()
+    missing: list[str] = []
+    fixes:  list[str] = []
+    failures: list[str] = []
+
+    # 1. Detect deprecated packages
+    for old_import, old_pkg, new_pkg in DEPRECATED:
+        if _importable(old_import):
+            if not auto:
+                missing.append(new_pkg)
+                continue
+            ok = _pip("--upgrade", new_pkg)
+            if ok:
+                fixes.append(f"upgraded {old_pkg} → {new_pkg.split('>=')[0]}")
+            else:
+                failures.append(f"could not upgrade {old_pkg} → {new_pkg}")
+
+    # 2. Check required packages
+    for module, package in REQUIRED:
+        if _importable(module):
+            continue
+        if not auto:
+            missing.append(package)
+            continue
+        ok = _pip(package)
+        if ok:
+            fixes.append(f"installed {package.split('>=')[0]}")
+        else:
+            failures.append(f"could not install {package}")
+
+    # 3. Check optional packages — only warn, don't force-install
+    missing_optional: list[tuple[str, str]] = []
+    for module, package, label in OPTIONAL:
+        if not _importable(module):
+            missing_optional.append((label, package))
+
+    # 4. Print summary (only if anything happened)
+    if not missing and not missing_optional and not fixes and not failures:
+        return
+
+    try:
+        from rich.console import Console
+        console = Console()
+
+        for fix in fixes:
+            console.print(f"[green]✓ {fix}[/green]")
+        for fail in failures:
+            console.print(f"[red]✗ {fail}[/red]")
+        if missing:
+            # escape() matters: DIST_EXTRA contains "[orchestrator]", which
+            # rich would otherwise parse as a style tag and drop.
+            from rich.markup import escape
+            console.print(
+                f"[yellow]missing: {escape(', '.join(sorted(missing)))}[/yellow]\n"
+                f"[dim]run: pip install \"{escape(DIST_EXTRA)}\"[/dim]"
+            )
+        if missing_optional:
+            names = ", ".join(label for label, _ in missing_optional)
+            pkgs  = " ".join(pkg for _, pkg in missing_optional)
+            console.print(
+                f"[dim]optional: {names} not installed "
+                f"(run: pip install {pkgs})[/dim]"
+            )
+        if fixes:
+            console.print()
+    except Exception:
+        # rich itself might not be installed yet
+        for fix in fixes:
+            print(f"✓ {fix}")
+        for fail in failures:
+            print(f"✗ {fail}")
+        if missing:
+            print(f"missing: {', '.join(sorted(missing))}")
+            print(f'run: pip install "{DIST_EXTRA}"')
+
+
+def check_models_available() -> tuple[bool, str]:
+    """
+    Returns (ok, warning_message).
+    Called after detect() — if zero models available, returns actionable message.
+    """
+    return True, ""

polymath/command_registry.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from prompt_toolkit.completion import WordCompleter
+
+
+BUILTIN_COMMANDS = [
+    "/help",
+    "/exit",
+    "/models",
+    "/sessions",
+    "/session",
+    "/new",
+    "/project",
+    "/project list",
+    "/project new",
+    "/project use",
+    "/project init",
+    "/context",
+    "/context show",
+    "/context add",
+    "/context edit",
+    "/commands",
+    "/subagents",
+    "/parallel",
+    "/accounts",
+    "/state",
+    "/queue",
+    "/memory",
+    "/memory show",
+    "/memory search",
+    "/memory rebuild",
+    "/memory confirm",
+    "/memory diff",
+    "/memory test",
+]
+
+
+def build_repl_completer(custom_commands: list[str]) -> WordCompleter:
+    words = BUILTIN_COMMANDS + [f"/{name}" for name in sorted(custom_commands)]
+    words += ["@claude", "@gemini", "@openai", "@ollama", "@all", "--ask", "--cheap", "--fast", "--verify", "--simplify", "--ensemble", "--fanout"]
+    return WordCompleter(words, ignore_case=True, sentence=True)