polymath-agent 0.4.0__py3-none-any.whl

polymath/memory/__init__.py

@@ -0,0 +1,15 @@
+"""
+Legacy facade — re-exports the brain's memory module at its old path.
+
+Implementation lives in `nexus.memory`. This package will keep
+existing forever for backwards compatibility with old imports.
+
+    # Legacy
+    from polymath.memory.store import Chunk, MemoryStore
+
+    # Preferred (post-decoupling)
+    from nexus import Chunk, MemoryStore
+"""
+from nexus.memory.store import Chunk, MemoryStore, resolve_memory_root
+
+__all__ = ["Chunk", "MemoryStore", "resolve_memory_root"]

polymath/memory/chunker.py

@@ -0,0 +1,6 @@
+"""Legacy facade — see nexus.memory.chunker."""
+from nexus.memory.chunker import *  # noqa: F401,F403
+from nexus.memory.chunker import (  # noqa: F401
+    CHARS_PER_TOKEN,
+    chunk_markdown,
+)

polymath/memory/embedder.py

@@ -0,0 +1,179 @@
+"""
+Embedding adapters: Gemini text-embedding-004 (primary), OpenAI text-embedding-3-small (fallback).
+
+Reuses key resolution from polymath.config / polymath.detector. Same provider
+ordering as the chat adapters — Gemini's free tier first, OpenAI as paid fallback.
+"""
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Sequence
+
+from polymath.adapters.base import AuthExpiredError
+from polymath.config import get_api_key
+from polymath.detector import _read_codex_cli_key, _read_gemini_cli_key
+
+
+GEMINI_MODEL = "text-embedding-004"
+GEMINI_DIM = 768
+OPENAI_MODEL = "text-embedding-3-small"
+OPENAI_DIM = 1536
+
+PROVIDER_DIMS = {
+    ("gemini", "text-embedding-004"): 768,
+    ("openai", "text-embedding-3-small"): 1536,
+    ("openai", "text-embedding-3-large"): 3072,
+}
+
+
+@dataclass
+class EmbedResult:
+    provider: str
+    model: str
+    dim: int
+    vectors: list[list[float]]
+
+
+class EmbedderUnavailable(RuntimeError):
+    pass
+
+
+class Embedder:
+    """Tries Gemini first, then OpenAI. Caller picks an instance and stays on it
+    for the lifetime of a memory write — switching mid-batch would mix dims."""
+
+    def __init__(self, cfg: dict, prefer: str = "gemini") -> None:
+        self.cfg = cfg
+        self.prefer = prefer
+        self._gemini_client = None
+        self._openai_client = None
+        self._gemini_types = None
+        self._active: tuple[str, str, int] | None = None
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    async def embed(self, texts: Sequence[str]) -> EmbedResult:
+        if not texts:
+            return EmbedResult(provider="", model="", dim=0, vectors=[])
+
+        order = ["gemini", "openai"] if self.prefer == "gemini" else ["openai", "gemini"]
+        failures: list[str] = []
+        for provider in order:
+            try:
+                if provider == "gemini":
+                    return await self._embed_gemini(list(texts))
+                return await self._embed_openai(list(texts))
+            except (EmbedderUnavailable, AuthExpiredError, Exception) as e:
+                failures.append(f"{provider}: {e}")
+        guidance = (
+            "no embedding provider available.\n  " + "\n  ".join(failures) +
+            "\nfix: set GOOGLE_API_KEY (free at https://aistudio.google.com/apikey) "
+            "or OPENAI_API_KEY (codex OAuth tokens are chat-only and cannot embed)."
+        )
+        raise EmbedderUnavailable(guidance)
+
+    def active_model(self) -> tuple[str, str, int] | None:
+        return self._active
+
+    # ── Gemini ────────────────────────────────────────────────────────────────
+
+    def _ensure_gemini(self) -> None:
+        if self._gemini_client is not None:
+            return
+        try:
+            from google import genai
+            from google.genai import types as genai_types
+        except ImportError as e:
+            raise EmbedderUnavailable(f"google-genai not installed: {e}")
+
+        key = get_api_key("gemini", self.cfg) or _read_gemini_cli_key() or ""
+        if not key:
+            raise EmbedderUnavailable("no gemini api key")
+
+        if key.startswith("ya29."):
+            self._gemini_client = genai.Client(
+                http_options={"headers": {"Authorization": f"Bearer {key}"}}
+            )
+        else:
+            self._gemini_client = genai.Client(api_key=key)
+        self._gemini_types = genai_types
+
+    async def _embed_gemini(self, texts: list[str]) -> EmbedResult:
+        self._ensure_gemini()
+        client = self._gemini_client
+        all_vectors: list[list[float]] = []
+        for batch in _batches(texts, 100):
+            try:
+                resp = await client.aio.models.embed_content(
+                    model=GEMINI_MODEL,
+                    contents=batch,
+                )
+            except Exception as e:
+                msg = str(e).lower()
+                if "401" in msg or "unauthenticated" in msg or "invalid_grant" in msg:
+                    raise AuthExpiredError("gemini", "gemini auth login") from e
+                raise
+            for embedding in resp.embeddings:
+                values = list(getattr(embedding, "values", []) or [])
+                all_vectors.append(values)
+        self._active = ("gemini", GEMINI_MODEL, GEMINI_DIM)
+        return EmbedResult(provider="gemini", model=GEMINI_MODEL, dim=GEMINI_DIM, vectors=all_vectors)
+
+    # ── OpenAI ────────────────────────────────────────────────────────────────
+
+    def _ensure_openai(self) -> None:
+        if self._openai_client is not None:
+            return
+        try:
+            from openai import AsyncOpenAI
+        except ImportError as e:
+            raise EmbedderUnavailable(f"openai not installed: {e}")
+
+        key = get_api_key("openai", self.cfg) or _read_codex_cli_key() or ""
+        if not key:
+            raise EmbedderUnavailable("no openai api key")
+        if key.startswith("chatgpt_oauth:"):
+            token = key[len("chatgpt_oauth:"):]
+            self._openai_client = AsyncOpenAI(
+                api_key="unused",
+                default_headers={"Authorization": f"Bearer {token}"},
+            )
+        else:
+            self._openai_client = AsyncOpenAI(api_key=key)
+
+    async def _embed_openai(self, texts: list[str]) -> EmbedResult:
+        self._ensure_openai()
+        client = self._openai_client
+        all_vectors: list[list[float]] = []
+        for batch in _batches(texts, 100):
+            try:
+                resp = await client.embeddings.create(
+                    model=OPENAI_MODEL,
+                    input=batch,
+                )
+            except Exception as e:
+                msg = str(e).lower()
+                if "401" in msg or "authentication" in msg:
+                    raise AuthExpiredError("openai", "codex login") from e
+                raise
+            for item in resp.data:
+                all_vectors.append(list(item.embedding))
+        self._active = ("openai", OPENAI_MODEL, OPENAI_DIM)
+        return EmbedResult(provider="openai", model=OPENAI_MODEL, dim=OPENAI_DIM, vectors=all_vectors)
+
+
+def _batches(items: list, size: int):
+    for i in range(0, len(items), size):
+        yield items[i:i + size]
+
+
+def cosine(a: list[float], b: list[float]) -> float:
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b))
+    na = sum(x * x for x in a) ** 0.5
+    nb = sum(y * y for y in b) ** 0.5
+    if na == 0 or nb == 0:
+        return 0.0
+    return dot / (na * nb)

polymath/memory/migrate.py

@@ -0,0 +1,2 @@
+"""Legacy facade — see nexus.memory.migrate."""
+from nexus.memory.migrate import *  # noqa: F401,F403

polymath/memory/retriever.py

@@ -0,0 +1,2 @@
+"""Legacy facade — see nexus.memory.retriever."""
+from nexus.memory.retriever import *  # noqa: F401,F403

polymath/memory/store.py

@@ -0,0 +1,9 @@
+"""Legacy facade — see nexus.memory.store for the implementation."""
+from nexus.memory.store import *  # noqa: F401,F403
+from nexus.memory.store import (  # noqa: F401
+    CHUNK_SCHEMA_VERSION,
+    CHUNK_TYPES,
+    Chunk,
+    MemoryStore,
+    resolve_memory_root,
+)

polymath/memory/sync.py

@@ -0,0 +1,2 @@
+"""Legacy facade — see nexus.memory.sync."""
+from nexus.memory.sync import *  # noqa: F401,F403

polymath/memory/writer.py

@@ -0,0 +1,9 @@
+"""Legacy facade — see nexus.memory.writer."""
+from nexus.memory.writer import *  # noqa: F401,F403
+from nexus.memory.writer import (  # noqa: F401
+    HarvestResult,
+    WriteBackResult,
+    harvest_session,
+    preview,
+    write_back,
+)

polymath/model_policy.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from polymath.adapters import ClaudeAdapter, GeminiAdapter, OllamaAdapter, OpenAIAdapter
+from polymath.adapters.base import BaseAdapter
+from polymath.compressor import build_context
+from polymath.config import TaskType, get_api_key
+from polymath.context_manager import build_context_injection
+from polymath.detector import _read_claude_cli_key, _read_codex_cli_key, _read_gemini_cli_key
+from polymath.router import select_primary, select_reviewer, select_summarizer
+from polymath.workspace import get_workspace_context
+
+
+CONTEXT_HEADROOM_TOKENS = 2048
+
+
+def adapter_for(provider: str, cfg: dict) -> BaseAdapter | None:
+    key = ""
+    try:
+        if provider in ("claude", "gemini", "openai"):
+            key = get_api_key(provider, cfg) or ""
+            if not key:
+                readers = {
+                    "claude": _read_claude_cli_key,
+                    "gemini": _read_gemini_cli_key,
+                    "openai": _read_codex_cli_key,
+                }
+                key = readers[provider]() or ""
+        if provider == "claude":
+            return ClaudeAdapter(api_key=key)
+        if provider == "gemini":
+            return GeminiAdapter(api_key=key)
+        if provider == "openai":
+            return OpenAIAdapter(api_key=key)
+        if provider == "ollama":
+            return OllamaAdapter(base_url=cfg.get("ollama_url", "http://localhost:11434"))
+        if provider == "lmstudio":
+            url = cfg.get("lmstudio_url", "http://localhost:1234").rstrip("/") + "/v1"
+            return OpenAIAdapter(api_key="", base_url=url)
+    except Exception:
+        return None
+    return None
+
+
+async def estimate_prompt_tokens(
+    session_id: str,
+    user_input: str,
+    active_project: str,
+    task_type: TaskType,
+    adapter: BaseAdapter,
+    summarizer_adapter: BaseAdapter | None,
+    summarizer_model_id: str,
+    is_ask: bool,
+    model_id: str = "",
+) -> int:
+    context = await build_context(
+        session_id,
+        summarizer=summarizer_adapter,
+        summarizer_model=summarizer_model_id,
+    )
+    prompt_parts = [f"{m.role}: {m.content}" for m in context]
+    prompt_parts.append(f"user: {user_input}")
+    project_ctx = build_context_injection(active_project, task_type) if active_project else ""
+    if is_ask:
+        system = "Answer concisely and directly."
+        if project_ctx:
+            system += f"\n\n{project_ctx}"
+    else:
+        system = (
+            "You are an autonomous agent capable of using tools to interact with your environment. "
+            "When a task requires information you don't have, use a tool to get it. "
+            "Always reason out loud before taking an action. "
+            "If you have all the information needed, provide a final answer. "
+            "Be precise and thorough."
+        )
+        if project_ctx:
+            system += f"\n\n{project_ctx}"
+        system += f"\n\n{get_workspace_context()}"
+    return await adapter.count_tokens_async(
+        system + "\n\n" + "\n".join(prompt_parts), model_id,
+    )
+
+
+@dataclass
+class ModelResolution:
+    primary_info: object | None
+    primary_adapter: BaseAdapter | None
+    reviewer_info: object | None
+    reviewer_adapter: BaseAdapter | None
+    summarizer_info: object | None
+    summarizer_adapter: BaseAdapter | None
+    estimated_prompt_tokens: int = 0
+
+
+async def resolve_models(
+    registry,
+    cfg: dict,
+    session_id: str,
+    user_input: str,
+    active_project: str,
+    task_type: TaskType,
+    profile: str,
+    force_provider: str = "",
+    cheap: bool = False,
+    fast: bool = False,
+    is_ask: bool = False,
+) -> ModelResolution:
+    summarizer_info = select_summarizer(registry)
+    summarizer_adapter = adapter_for(summarizer_info.provider, cfg) if summarizer_info else None
+
+    excluded: set[str] = set()
+    primary_info = None
+    primary_adapter = None
+    estimated_prompt_tokens = 0
+    while True:
+        candidates = [m for m in registry if m.id not in excluded]
+        primary_info = select_primary(
+            candidates,
+            task_type,
+            profile,
+            force_provider=force_provider,
+            force_cheap=cheap,
+            force_fast=fast,
+        )
+        if not primary_info:
+            break
+        primary_adapter = adapter_for(primary_info.provider, cfg)
+        if not primary_adapter:
+            excluded.add(primary_info.id)
+            continue
+        estimated_prompt_tokens = await estimate_prompt_tokens(
+            model_id=primary_info.id,
+            session_id=session_id,
+            user_input=user_input,
+            active_project=active_project,
+            task_type=task_type,
+            adapter=primary_adapter,
+            summarizer_adapter=summarizer_adapter,
+            summarizer_model_id=summarizer_info.id if summarizer_info else "",
+            is_ask=is_ask,
+        )
+        if primary_info.context_window - estimated_prompt_tokens > CONTEXT_HEADROOM_TOKENS:
+            break
+        excluded.add(primary_info.id)
+    reviewer_info = select_reviewer(registry, primary_info, profile) if primary_info else None
+    reviewer_adapter = adapter_for(reviewer_info.provider, cfg) if reviewer_info else None
+    return ModelResolution(
+        primary_info=primary_info,
+        primary_adapter=primary_adapter,
+        reviewer_info=reviewer_info,
+        reviewer_adapter=reviewer_adapter,
+        summarizer_info=summarizer_info,
+        summarizer_adapter=summarizer_adapter,
+        estimated_prompt_tokens=estimated_prompt_tokens,
+    )
+
+
+def try_fallback_adapter(registry, failed_model, profile: str, cfg: dict, tried_model_ids: set[str] | None = None):
+    tried = set(tried_model_ids or set())
+    tried.add(failed_model.id)
+    available = [m for m in registry if m.available and m.id not in tried]
+    while available:
+        candidate = select_primary(available, TaskType.GENERAL, profile)
+        if not candidate or candidate.id in tried:
+            break
+        tried.add(candidate.id)
+        adapter = adapter_for(candidate.provider, cfg)
+        if adapter:
+            return candidate, adapter
+        available = [m for m in available if m.id not in tried]
+    return None

polymath/orchestrator/__init__.py

@@ -0,0 +1,68 @@
+from polymath.orchestrator.attempt_ledger import AttemptLedger
+from polymath.orchestrator.ensemble import (
+    EnsembleResult,
+    EnsembleWorker,
+    WorkerResult,
+    run_ensemble,
+    select_ensemble_workers,
+)
+from polymath.orchestrator.fanout import (
+    FanoutResult,
+    Subtask,
+    SubtaskResult,
+    run_fanout,
+    select_splitter_and_joiner,
+)
+from polymath.orchestrator.speculative_review import SpeculativeReviewer
+from polymath.orchestrator.output_policy import FailureDecision, OutputPolicy
+from polymath.orchestrator.race import (
+    AllCandidatesFailed,
+    RaceCandidate,
+    RaceOutcome,
+    StreamCandidate,
+    StreamOutcome,
+    gather_all,
+    race_first_success,
+    race_streams,
+    with_failover,
+)
+from polymath.orchestrator.run_controller import (
+    ExecutionStrategy,
+    RunController,
+    RunDecision,
+    RunRequest,
+)
+from polymath.orchestrator.state_responder import StateResponder
+from polymath.orchestrator.worker_pool import WorkerPool
+
+__all__ = [
+    "AllCandidatesFailed",
+    "AttemptLedger",
+    "EnsembleResult",
+    "EnsembleWorker",
+    "ExecutionStrategy",
+    "FailureDecision",
+    "FanoutResult",
+    "Subtask",
+    "SubtaskResult",
+    "OutputPolicy",
+    "RaceCandidate",
+    "RaceOutcome",
+    "StreamCandidate",
+    "StreamOutcome",
+    "RunController",
+    "RunDecision",
+    "RunRequest",
+    "SpeculativeReviewer",
+    "StateResponder",
+    "WorkerPool",
+    "WorkerResult",
+    "gather_all",
+    "race_first_success",
+    "race_streams",
+    "run_ensemble",
+    "run_fanout",
+    "select_ensemble_workers",
+    "select_splitter_and_joiner",
+    "with_failover",
+]

polymath/orchestrator/attempt_ledger.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class AttemptFailure:
+    model_id: str
+    reason: str
+    retryable: bool = True
+
+
+@dataclass
+class AttemptLedger:
+    attempted_by_phase: dict[str, set[str]] = field(default_factory=dict)
+    failures: dict[str, list[AttemptFailure]] = field(default_factory=dict)
+
+    def note_attempt(self, phase: str, model_id: str) -> None:
+        self.attempted_by_phase.setdefault(phase, set()).add(model_id)
+
+    def note_failure(self, phase: str, model_id: str, reason: str, *, retryable: bool = True) -> None:
+        self.failures.setdefault(phase, []).append(
+            AttemptFailure(model_id=model_id, reason=reason, retryable=retryable)
+        )
+        self.note_attempt(phase, model_id)
+
+    def attempted(self, phase: str) -> set[str]:
+        return set(self.attempted_by_phase.get(phase, set()))
+
+    def has_attempted(self, phase: str, model_id: str) -> bool:
+        return model_id in self.attempted_by_phase.get(phase, set())
+
+    def failures_for_phase(self, phase: str) -> list[AttemptFailure]:
+        return list(self.failures.get(phase, []))