polymath-agent 0.4.0__py3-none-any.whl

polymath/orchestrator/state_responder.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import re
+
+from polymath.config import PRIORITY_PROFILES, TaskType
+from polymath.router import select_primary
+
+
+class StateResponder:
+    _MODEL_PATTERNS = (
+        "what all models are you using",
+        "what all models do you use",
+        "which all models are you using",
+        "which all models do you use",
+        "what models are you using",
+        "which models are you using",
+        "what model are you using",
+        "which model are you using",
+        "show models you are using",
+        "what models do you have",
+        "which models do you have",
+    )
+    _CAPABILITY_PATTERNS = (
+        "what can you do",
+        "what all can you do",
+        "what do you do",
+        "what all do you do",
+        "what are your capabilities",
+        "what can polymath do",
+        "help me with",
+    )
+    _COMPARISON_PATTERNS = (
+        "better than",
+        "stronger than",
+        "why not",
+        "why are you using",
+        "shouldn't you use",
+        "isn't",
+    )
+    _PROVIDER_WORDS = ("claude", "gemini", "gpt", "openai", "ollama", "lm studio", "llama", "mistral", "opus", "sonnet", "haiku")
+
+    def can_answer(self, text: str) -> bool:
+        lowered = text.lower().strip()
+        return (
+            any(pattern in lowered for pattern in self._MODEL_PATTERNS)
+            or any(pattern in lowered for pattern in self._CAPABILITY_PATTERNS)
+            or self._is_model_policy_question(lowered)
+        )
+
+    def _is_model_policy_question(self, lowered: str) -> bool:
+        return (
+            any(pattern in lowered for pattern in self._COMPARISON_PATTERNS)
+            and any(word in lowered for word in self._PROVIDER_WORDS)
+        )
+
+    def _resolve_primary(self, available, profile: str):
+        primary = select_primary(list(available), TaskType.GENERAL, profile)
+        if primary:
+            return primary
+        ordered = sorted(
+            available,
+            key=PRIORITY_PROFILES.get(profile, PRIORITY_PROFILES["quality-first"]),
+        )
+        return ordered[0]
+
+    def _model_aliases(self, model) -> list[tuple[str, int]]:
+        display = model.display_name.lower()
+        aliases: list[tuple[str, int]] = [
+            (display, 120),
+            (re.sub(r"[^a-z0-9]+", "", display), 100),
+            (model.id.lower(), 90),
+        ]
+        tokens = [token for token in re.findall(r"[a-z0-9]+", display) if len(token) > 2]
+        for token in tokens:
+            aliases.append((token, 18))
+        aliases.append((model.provider.lower(), 4))
+        return aliases
+
+    def _score_model_match(self, text: str, model) -> int:
+        lowered = text.lower()
+        compact_text = re.sub(r"[^a-z0-9]+", "", lowered)
+        score = 0
+        for alias, weight in self._model_aliases(model):
+            if not alias:
+                continue
+            if alias == model.provider.lower():
+                if re.search(rf"\b{re.escape(alias)}\b", lowered):
+                    score += weight
+                continue
+            if alias == re.sub(r"[^a-z0-9]+", "", alias):
+                if alias in compact_text:
+                    score += weight
+            elif alias in lowered:
+                score += weight
+            elif re.search(rf"\b{re.escape(alias)}\b", lowered):
+                score += weight
+        return score
+
+    def _best_match(self, text: str, registry):
+        scored = []
+        for model in registry:
+            score = self._score_model_match(text, model)
+            if score > 0:
+                scored.append((score, model))
+        if not scored:
+            return None
+        scored.sort(key=lambda item: (-item[0], -item[1].quality, -item[1].context_window, -item[1].speed))
+        return scored[0][1]
+
+    def _split_comparison_sides(self, text: str) -> tuple[str, str] | None:
+        lowered = text.lower().strip()
+        for marker in ("better than", "stronger than", "over"):
+            if marker in lowered:
+                left, right = lowered.split(marker, 1)
+                return left.strip(), right.strip()
+        return None
+
+    def _find_mentions(self, text: str, registry) -> list:
+        parts = self._split_comparison_sides(text)
+        if parts:
+            left = self._best_match(parts[0], registry)
+            right = self._best_match(parts[1], registry)
+            resolved = []
+            for model in (left, right):
+                if model and all(existing.id != model.id for existing in resolved):
+                    resolved.append(model)
+            if len(resolved) >= 2:
+                return resolved[:2]
+        scored_matches: list[tuple[int, object]] = []
+        for model in registry:
+            score = self._score_model_match(text, model)
+            if score > 0:
+                scored_matches.append((score, model))
+        scored_matches.sort(key=lambda item: (-item[0], -item[1].quality, -item[1].context_window, -item[1].speed))
+        seen = set()
+        unique = []
+        for _, model in scored_matches:
+            if model.id not in seen:
+                unique.append(model)
+                seen.add(model.id)
+        return unique[:2]
+
+    def answer(self, text: str, registry, profile: str) -> str | None:
+        if not self.can_answer(text):
+            return None
+        available = [m for m in registry if m.available]
+        if not available:
+            return "I don't currently have any available models."
+        lowered = text.lower().strip()
+        if any(pattern in lowered for pattern in self._CAPABILITY_PATTERNS):
+            return (
+                "I can route across available models, answer direct questions, run the multi-step planning/execution/review pipeline, "
+                "use repo or detached project context, manage queued prompts, run slash commands and subagents, and work with git-backed shared `.polymath/` project metadata."
+            )
+        ordered = sorted(
+            available,
+            key=PRIORITY_PROFILES.get(profile, PRIORITY_PROFILES["quality-first"]),
+        )
+        primary = self._resolve_primary(available, profile)
+        if self._is_model_policy_question(lowered):
+            mentioned = self._find_mentions(lowered, available)
+            if len(mentioned) >= 2:
+                left, right = mentioned[0], mentioned[1]
+                left_score = (left.quality, left.context_window, left.speed)
+                right_score = (right.quality, right.context_window, right.speed)
+                if left_score == right_score:
+                    verdict = f"In the current registry, {left.display_name} and {right.display_name} are effectively tied on the stored policy metrics."
+                elif left_score > right_score:
+                    verdict = f"Yes. In the current registry, {left.display_name} ranks above {right.display_name} on raw policy strength."
+                else:
+                    verdict = f"No. In the current registry, {right.display_name} ranks above {left.display_name} on raw policy strength."
+                return (
+                    f"{verdict} Under `{profile}`, the current primary choice for a general task is {primary.display_name}. "
+                    f"`quality-first` now breaks ties by quality, then context window, then speed, then cost."
+                )
+            return (
+                f"Under `{profile}`, my current primary choice for a general task is {primary.display_name}. "
+                f"`quality-first` now breaks ties by quality, then context window, then speed, then cost."
+            )
+        names = ", ".join(m.display_name for m in ordered)
+        return (
+            f"I'm currently orchestrating across {len(ordered)} available models: {names}. "
+            f"My current primary choice under the `{profile}` profile is {primary.display_name}."
+        )

polymath/orchestrator/worker_pool.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable
+
+
+@dataclass
+class WorkerPool:
+    tasks: set[asyncio.Task[Any]] = field(default_factory=set)
+
+    async def run(self, factory: Callable[[], Awaitable[Any]]) -> Any:
+        task = asyncio.create_task(factory())
+        self.tasks.add(task)
+        try:
+            return await task
+        finally:
+            self.tasks.discard(task)
+
+    async def gather(self, factories: list[Callable[[], Awaitable[Any]]]) -> list[Any]:
+        if not factories:
+            return []
+        tasks = [asyncio.create_task(factory()) for factory in factories]
+        self.tasks.update(tasks)
+        try:
+            return await asyncio.gather(*tasks, return_exceptions=True)
+        finally:
+            for task in tasks:
+                self.tasks.discard(task)
+
+    async def cancel_all(self) -> None:
+        if not self.tasks:
+            return
+        for task in list(self.tasks):
+            task.cancel()
+        await asyncio.gather(*list(self.tasks), return_exceptions=True)
+        self.tasks.clear()

polymath/permissions.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from polymath.domain import PermissionRequest
+from polymath.project_config import LocalProject, is_shell_command_allowed, is_tool_allowed
+from polymath.tools import permission_scope
+
+
+#: Tools whose first argument is a command line, so the shell allowlist
+#: applies to them as well as the tool allowlist.
+SHELL_TOOLS = ("run_shell_command",)
+
+
+def build_permission_request(
+    tool_name: str,
+    arguments: dict[str, Any] | None = None,
+) -> PermissionRequest:
+    """Build a permission request straight from the tool call.
+
+    The decision is made on `tool_name` and `arguments`. `action` is derived
+    from them only so the prompt has something to show, which means what the
+    user is asked about and what is checked are the same values.
+
+    This replaces an earlier version that rendered the call to a sentence and
+    recovered the command from it with a regular expression. That recovery
+    stopped at the first quote, so a command containing one was approved on
+    the strength of a truncated fragment.
+    """
+    arguments = dict(arguments or {})
+    shell_command = ""
+    if tool_name in SHELL_TOOLS:
+        raw = arguments.get("command", "")
+        shell_command = raw if isinstance(raw, str) else ""
+    reason = permission_scope(tool_name, arguments)
+    return PermissionRequest(
+        action=render_action(tool_name, arguments, reason),
+        tool_name=tool_name,
+        shell_command=shell_command,
+        arguments=arguments,
+        escalation_reason=reason,
+        requires_prompt=True,
+    )
+
+
+def render_action(
+    tool_name: str,
+    arguments: dict[str, Any],
+    escalation_reason: str = "",
+) -> str:
+    """Human-readable one-liner for the permission prompt. Display only."""
+    line = f"Execute {tool_name} with {arguments}"
+    if escalation_reason:
+        line += f"  [{escalation_reason}]"
+    return line
+
+
+def is_preapproved(request: PermissionRequest, local_project: LocalProject | None) -> bool:
+    # A project's allowed_tools list says "read_file is fine here". It does
+    # not say "and my ssh key too" — an escalated call is always asked about.
+    if request.escalation_reason:
+        return False
+    if not local_project or not request.tool_name:
+        return False
+    if not is_tool_allowed(request.tool_name, local_project.settings):
+        return False
+    if request.tool_name != "run_shell_command":
+        return True
+    return bool(request.shell_command) and is_shell_command_allowed(
+        request.shell_command,
+        local_project.settings,
+    )
+
+
+def decide_permission(
+    request: PermissionRequest,
+    local_project: LocalProject | None,
+    prompt_user: Callable[[str], bool],
+) -> bool:
+    if is_preapproved(request, local_project):
+        return True
+    return prompt_user(request.action)