omnimancer-cli 0.3.6__tar.gz → 0.3.7__tar.gz

{omnimancer_cli-0.3.6 → omnimancer_cli-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.3.6
+Version: 0.3.7
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT

{omnimancer_cli-0.3.6 → omnimancer_cli-0.3.7}/omnimancer/cli/h2l_command.py

@@ -251,6 +251,12 @@ class TUIPresenter:
                 f"{verdict.judge}): {failures}"
             )
 
+    async def on_model_dropped(self, ref: H2LModelRef, error: str) -> None:
+        self.console.print(
+            f"  [yellow]Dropped {ref.label}: it cannot call tools, so the "
+            f"remaining low models take its stories[/yellow] [dim]({error})[/dim]"
+        )
+
     async def on_escalation(self, story: Story, outcome: StoryOutcome) -> str:
         while True:
             answer = (

{omnimancer_cli-0.3.6 → omnimancer_cli-0.3.7}/omnimancer/cli/h2l_headless.py

@@ -232,6 +232,16 @@ class HeadlessPresenter:
             + (f" ({'; '.join(verdict.failures)})" if verdict.failures else "")
         )
 
+    async def on_model_dropped(self, ref: H2LModelRef, error: str) -> None:
+        self.emitter.emit_h2l(
+            "model_dropped",
+            {"provider": ref.provider, "model": ref.model, "error": error},
+        )
+        self._progress(
+            f"dropped {ref.label}: it cannot call tools, so the remaining low "
+            f"models take its stories ({error})"
+        )
+
     async def on_escalation(self, story: Story, outcome: StoryOutcome) -> str:
         return "high"
 

{omnimancer_cli-0.3.6 → omnimancer_cli-0.3.7}/omnimancer/h2l/orchestrator.py

@@ -18,7 +18,17 @@ import logging
 import uuid
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable, Dict, Iterator, List, Optional, Protocol, Tuple
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Protocol,
+    Set,
+    Tuple,
+)
 
 from ..core.agent.tool_definitions import CODING_AGENT_TOOLS
 from ..core.rate_limit_fallback import matches_rate_limit
@@ -50,6 +60,32 @@ _current_story: contextvars.ContextVar[str] = contextvars.ContextVar(
 _TERMINAL_BAD = (StoryState.BLOCKED, StoryState.SKIPPED, StoryState.CANCELLED)
 
 
+# Vendor wording for "this model cannot call tools" (Bedrock, Ollama,
+# OpenRouter, OpenAI-compatible gateways).
+_NO_TOOL_PATTERNS: Tuple[str, ...] = (
+    "support tool use",
+    "does not support tools",
+    "tool calling is not supported",
+    "tool use is not supported",
+    "does not support function calling",
+    "function calling is not supported",
+)
+
+
+def matches_no_tool_support(error: str) -> bool:
+    """True when *error* says the model itself cannot call tools."""
+    lowered = error.lower()
+    return any(p in lowered for p in _NO_TOOL_PATTERNS)
+
+
+# Returned by ``_attempt`` when the model, not the story, failed: the attempt
+# is retried on another model without spending a retry or consulting the judge.
+_MODEL_DROPPED = Verdict(
+    story_id="", passed=False, failures=["model cannot call tools"]
+)
+_NO_LOW_MODEL = "no_tool_capable_low_model"
+
+
 @dataclass
 class PlanDecision:
     accepted: bool
@@ -100,6 +136,8 @@ class H2LRun:
         self._stop_cause = "done"
         self._stopped = False
         self._pool_index = 0
+        # Labels of low models that reported they cannot call tools.
+        self._dropped: Set[str] = set()
         # Surfaces turn this off when Bash would only be denied (headless
         # without --dangerously-skip-permissions).
         self.planner_bash = True
@@ -299,30 +337,39 @@ class H2LRun:
         feedback: Optional[str] = None
         attempt = 0
         while True:
-            attempt += 1
-            ref, provider = self._next_ref()
-            verdict = await self._attempt(story, ref, provider, attempt, feedback)
-            if verdict is None:
-                return  # cancelled or the run stopped
-            if verdict.passed:
-                outcome.state = StoryState.PASSED
-                outcome.score = verdict.score
-                outcome.model = ref.label
-                return
-            feedback = verdict.feedback
-            if attempt < max_attempts:
-                continue
+            # None once every low model has been dropped for lacking tools;
+            # only the escalation policy is left then.
+            picked = self._next_ref()
+            if picked is not None:
+                attempt += 1
+                ref, provider = picked
+                verdict = await self._attempt(story, ref, provider, attempt, feedback)
+                if verdict is None:
+                    return  # cancelled or the run stopped
+                if verdict is _MODEL_DROPPED:
+                    attempt -= 1  # the model failed, not the story
+                    continue
+                if verdict.passed:
+                    outcome.state = StoryState.PASSED
+                    outcome.score = verdict.score
+                    outcome.model = ref.label
+                    return
+                feedback = verdict.feedback
+                if attempt < max_attempts:
+                    continue
             policy: str = self.config.escalation
             if policy == "ask":
                 policy = await self.presenter.on_escalation(story, outcome)
-            if policy == "retry":
+            if policy == "retry" and picked is not None:
                 max_attempts += 1
                 continue
             if policy == "high":
                 await self._escalate_high(story, outcome, attempt + 1, feedback)
                 return
             outcome.state = StoryState.BLOCKED
-            outcome.reason = "retries_exhausted"
+            outcome.reason = (
+                "retries_exhausted" if picked is not None else _NO_LOW_MODEL
+            )
             return
 
     async def _attempt(
@@ -372,6 +419,10 @@ class H2LRun:
             outcome.state = StoryState.PENDING
             outcome.attempts = attempt - 1
             return None
+        if not report.success and matches_no_tool_support(report.error or ""):
+            outcome.attempts = attempt - 1
+            await self._drop_model(ref, report.error or "")
+            return _MODEL_DROPPED
 
         with self._high_context():
             verdict: Verdict = await judge.check(story, report)
@@ -451,13 +502,33 @@ class H2LRun:
 
         return observe
 
-    def _next_ref(self) -> Tuple[H2LModelRef, Any]:
+    def _next_ref(self) -> Optional[Tuple[H2LModelRef, Any]]:
         tiers = self._ensure_tiers()
-        pool = list(zip(self.config.low, tiers.low))
+        pool = [
+            (ref, provider)
+            for ref, provider in zip(self.config.low, tiers.low)
+            if ref.label not in self._dropped
+        ]
+        if not pool:
+            return None
         ref, provider = pool[self._pool_index % len(pool)]
         self._pool_index += 1
         return ref, provider
 
+    async def _drop_model(self, ref: H2LModelRef, error: str) -> None:
+        """Take a tool-less low model out of rotation; tell the surface once."""
+        if ref.label in self._dropped:
+            return
+        self._dropped.add(ref.label)
+        logger.info("H2L dropped %s, which cannot call tools: %s", ref.label, error)
+        hook = getattr(self.presenter, "on_model_dropped", None)
+        if hook is None:
+            return
+        try:
+            await hook(ref, error)
+        except Exception as exc:  # presentation must never break the run
+            logger.debug("H2L on_model_dropped presenter hook failed: %s", exc)
+
     def _add_usage(self, tier: str, usage: UsageTotals) -> None:
         self.usage_by_tier[tier] = self.usage_by_tier[tier].add(usage)
 

{omnimancer_cli-0.3.6 → omnimancer_cli-0.3.7}/omnimancer/h2l/worker.py

@@ -9,6 +9,7 @@ carries the diff, verify output, and out-of-scope files the judge needs.
 
 from __future__ import annotations
 
+import difflib
 import logging
 import re
 import subprocess
@@ -41,6 +42,8 @@ class WorkerRunner:
         self.cwd = Path(cwd)
         # Overridable for tests; the real handler routes through the gate.
         self._tool_handler_factory: Callable[[Any], Any] = ToolHandler
+        # Story id -> {path: content or None}, taken before its first attempt.
+        self._baselines: Dict[str, Dict[str, Optional[str]]] = {}
 
     async def run(
         self,
@@ -102,6 +105,8 @@ class WorkerRunner:
         )
 
         agent_id = agent_id or f"h2l-{story.id}-{uuid.uuid4().hex[:8]}"
+        if story.id not in self._baselines:
+            self._baselines[story.id] = {p: _read_text(p) for p in story.files}
         before = self._dirty_files()
         status = 1
         with fleet_events.agent_context(agent_id, run_id):
@@ -247,6 +252,9 @@ class WorkerRunner:
     def _capture_changes(
         self, report: WorkerReport, story: Story, before: Dict[str, str]
     ) -> None:
+        if self._repo_root() is None:
+            self._capture_from_baseline(report, story)
+            return
         after = self._dirty_files()
         scope = set(story.files)
         new_or_changed = {p for p in after if p not in before or p in scope}
@@ -268,6 +276,48 @@ class WorkerRunner:
             return f"[git diff unavailable for {path}]"
         return proc.stdout
 
+    def _capture_from_baseline(self, report: WorkerReport, story: Story) -> None:
+        """Without git, diff the story's files against its first-attempt snapshot.
+
+        The snapshot stands in for HEAD, so retries accumulate as they do under
+        git. Out-of-scope writes cannot be seen this way; the tool-level scope
+        check is the guard there.
+        """
+        baseline = self._baselines.get(story.id, {})
+        changed: List[str] = []
+        chunks: List[str] = []
+        for path in story.files:
+            old, new = baseline.get(path), _read_text(path)
+            if old != new:
+                changed.append(path)
+                chunks.append(_unified_diff(path, old, new))
+        report.files_changed = changed
+        report.diff = "\n".join(chunks)
+
+
+def _read_text(path: str) -> Optional[str]:
+    try:
+        return Path(path).read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+
+
+def _unified_diff(path: str, old: Optional[str], new: Optional[str]) -> str:
+    fromfile = path if old is not None else "/dev/null"
+    tofile = path if new is not None else "/dev/null"
+    lines = list(
+        difflib.unified_diff(
+            (old or "").splitlines(),
+            (new or "").splitlines(),
+            fromfile=fromfile,
+            tofile=tofile,
+            lineterm="",
+        )
+    )
+    # An empty file created or removed has no hunks; keep the header so the
+    # change is still visible.
+    return "\n".join(lines or [f"--- {fromfile}", f"+++ {tofile}"])
+
 
 def worker_tool_names(tools: List[ToolDefinition]) -> List[str]:
     return [t.name for t in tools]

{omnimancer_cli-0.3.6 → omnimancer_cli-0.3.7}/omnimancer_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.3.6
+Version: 0.3.7
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT

{omnimancer_cli-0.3.6 → omnimancer_cli-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omnimancer-cli"
-version = "0.3.6"
+version = "0.3.7"
 description = "A unified command-line interface for multiple AI language models"
 readme = "README.md"
 requires-python = ">=3.10"