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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.3.5
+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.5 → 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.5 → 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.5 → omnimancer_cli-0.3.7}/omnimancer/core/engine.py

@@ -182,11 +182,12 @@ class CoreEngine:
                     # DigitalOcean request). Leave it unset so the user gets a
                     # clear error naming the provider.
                     self._unavailable_default_provider = config.default_provider
+                    # One accurate line instead of a guess; the full
+                    # explanation is built on demand by _no_provider_error.
                     logger.error(
-                        "Default provider '%s' is configured but failed to "
-                        "initialize (missing or invalid API key?). Not falling "
-                        "back to another provider.",
+                        "Default provider '%s' is not available: %s",
                         config.default_provider,
+                        self._no_provider_error(),
                     )
             elif self.providers:
                 # No default configured — use first available provider.
@@ -306,14 +307,44 @@ class CoreEngine:
         missing, rather than a generic "no provider" message.
         """
         unavailable = getattr(self, "_unavailable_default_provider", None)
-        if unavailable:
+        if not unavailable:
+            return "No provider available. Please configure a provider first."
+
+        env_prefix = "OMNIMANCER_" + unavailable.upper().replace("-", "_")
+        try:
+            from .provider_resolver import effective_providers
+
+            entry = effective_providers(self.config_manager).get(unavailable)
+        except Exception as exc:  # diagnostics must not raise
+            logger.debug(f"Could not inspect entry for {unavailable}: {exc}")
+            entry = None
+
+        if entry is None:
             return (
-                f"Provider '{unavailable}' is selected but failed to initialize "
-                f"— most likely a missing or invalid API key. Configure it (e.g. "
-                f"'/config set-provider {unavailable}' or the provider's API-key "
-                f"environment variable) and try again."
+                f"Provider '{unavailable}' is selected as the default but is "
+                f"not configured: there is no entry for it and no "
+                f"{env_prefix}_API_KEY in the environment. Add it with "
+                f"'/config set-provider {unavailable}', or pick a different "
+                f"default with '/switch'."
             )
-        return "No provider available. Please configure a provider first."
+
+        if not (getattr(entry, "model", "") or "").strip():
+            return (
+                f"Provider '{unavailable}' has no model configured, so it was "
+                f"not started. Set {env_prefix}_MODEL, or run '/model' to pick "
+                f"one."
+            )
+
+        from .provider_initializer import ProviderInitializer
+
+        reason = ProviderInitializer.get_last_init_errors().get(unavailable)
+        if reason:
+            return f"Provider '{unavailable}' did not start: {reason}"
+        return (
+            f"Provider '{unavailable}' is configured but did not start. Check "
+            f"its credentials ('/config set-provider {unavailable}' or "
+            f"{env_prefix}_API_KEY) and try again."
+        )
 
     # ------------------------------------------------------------------
     # Fallback wiring

{omnimancer_cli-0.3.5 → omnimancer_cli-0.3.7}/omnimancer/core/env_loader.py

@@ -230,7 +230,7 @@ def apply_env_overrides(config: "Config") -> "Config":
                 model=overrides.get("model", ""),
             )
             effective.providers[name] = provider_config
-            logger.info(f"Created provider '{name}' from environment overrides")
+            logger.debug(f"Created provider '{name}' from environment overrides")
 
         if "api_key" in overrides:
             provider_config.api_key = overrides["api_key"]
@@ -241,6 +241,8 @@ def apply_env_overrides(config: "Config") -> "Config":
 
     if default_override:
         effective.default_provider = default_override
-        logger.info(f"Default provider overridden from environment: {default_override}")
+        logger.debug(
+            f"Default provider overridden from environment: {default_override}"
+        )
 
     return effective

{omnimancer_cli-0.3.5 → omnimancer_cli-0.3.7}/omnimancer/core/provider_initializer.py

@@ -44,6 +44,8 @@ class ProviderInitializer:
     # Configuration
     _lazy_loading_enabled: bool = True
     _cache_enabled: bool = True
+    # provider name -> why it failed, from the most recent initialization
+    _last_init_errors: Dict[str, str] = {}
 
     @classmethod
     def get_provider_class(cls, provider_name: str) -> Type[BaseProvider]:
@@ -447,14 +449,35 @@ class ProviderInitializer:
             provider_configs: Dictionary of provider configurations
             config_manager: Optional config manager for API key decryption
 
+        An entry with no model id is *incomplete*, not broken: environment
+        materialized entries (``OMNIMANCER_<PROVIDER>_API_KEY`` with no
+        ``_MODEL``) are legitimate when the model comes from somewhere else,
+        such as an H2L ``--high <entry>:<model>`` ref. Those are skipped
+        without an error; real failures are recorded so callers can report
+        the actual cause instead of guessing at one.
+
         Returns:
             Dictionary of initialized provider instances
         """
         from ..providers.factory import ProviderFactory
 
         providers = {}
+        errors: Dict[str, str] = {}
 
         for provider_name, config in provider_configs.items():
+            if not (getattr(config, "model", "") or "").strip():
+                env_var = (
+                    "OMNIMANCER_" + provider_name.upper().replace("-", "_") + "_MODEL"
+                )
+                logger.info(
+                    "Provider '%s' has no model configured; not started. "
+                    "Set %s or '/config set-provider %s'. Model refs that "
+                    "carry their own model (H2L tiers) still work.",
+                    provider_name,
+                    env_var,
+                    provider_name,
+                )
+                continue
             try:
                 # Use ProviderFactory instead of direct class loading
                 provider = ProviderFactory.create_provider(
@@ -463,12 +486,19 @@ class ProviderInitializer:
                 providers[provider_name] = provider
                 logger.info(f"Initialized provider: {provider_name}")
             except Exception as e:
-                logger.error(f"Failed to initialize provider {provider_name}: {e}")
+                errors[provider_name] = str(e)
+                logger.error(f"Provider '{provider_name}' did not start: {e}")
                 # Continue with other providers instead of failing completely
                 continue
 
+        cls._last_init_errors = errors
         return providers
 
+    @classmethod
+    def get_last_init_errors(cls) -> Dict[str, str]:
+        """Why each provider failed during the most recent initialization."""
+        return dict(getattr(cls, "_last_init_errors", {}) or {})
+
     @classmethod
     def preload_model_info(cls, provider_names: List[str]) -> None:
         """

{omnimancer_cli-0.3.5 → 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.5 → 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.5 → omnimancer_cli-0.3.7}/omnimancer/providers/bedrock.py

@@ -70,6 +70,14 @@ class BedrockProvider(BaseProvider):
         # AWS-specific configuration
         self.aws_region = kwargs.get("aws_region", "us-east-1")
 
+        # Chat-completion timeout. ProviderConfig's field is `timeout`;
+        # `request_timeout` is accepted as an alias, then
+        # OMNIMANCER_REQUEST_TIMEOUT, then DEFAULT_REQUEST_TIMEOUT. A long
+        # agent turn on a large model does not fit in the old hardcoded 30s.
+        self.request_timeout = self._resolve_request_timeout(
+            kwargs.get("request_timeout") or kwargs.get("timeout")
+        )
+
         # Standard parameters. Bedrock fronts third-party models that reject
         # temperature/topP in inferenceConfig outright, and nothing in
         # Omnimancer lets a user pick these values, so an unset param stays
@@ -82,6 +90,21 @@ class BedrockProvider(BaseProvider):
         # Build base URL for Bedrock API key authentication
         self.base_url = f"https://bedrock-runtime.{self.aws_region}.amazonaws.com"
 
+    def _timeout_network_error(self) -> NetworkError:
+        """The NetworkError raised when a Converse request times out."""
+        return NetworkError(
+            f"Request to AWS Bedrock API timed out after "
+            f"{self.request_timeout:.0f}s. Raise it with this provider's "
+            f"timeout (providers.<name>.timeout in config.json) or the "
+            f"OMNIMANCER_REQUEST_TIMEOUT environment variable."
+        )
+
+    def _model_for_url(self) -> str:
+        """The path segment for this model: ARNs carry an unusable prefix."""
+        if self._is_arn(self.model):
+            return self._extract_model_id_from_arn(self.model)
+        return self.model
+
     def _is_arn(self, model_id: str) -> bool:
         """Check if the model ID is in ARN format."""
         return model_id.startswith("arn:aws:bedrock:")
@@ -144,7 +167,7 @@ class BedrockProvider(BaseProvider):
             request_body = self._prepare_bedrock_request(message, context)
 
             # Build URL for the specific model
-            url = f"{self.base_url}/model/{self.model}/converse"
+            url = f"{self.base_url}/model/{self._model_for_url()}/converse"
 
             # Create headers with Bearer token authentication
             headers = {
@@ -155,14 +178,17 @@ class BedrockProvider(BaseProvider):
             # Make API request
             async with httpx.AsyncClient() as client:
                 response = await client.post(
-                    url, headers=headers, content=request_body, timeout=30.0
+                    url,
+                    headers=headers,
+                    content=request_body,
+                    timeout=self.request_timeout,
                 )
 
             # Handle response
             return self._handle_response(response)
 
         except httpx.TimeoutException:
-            raise NetworkError("Request to AWS Bedrock API timed out")
+            raise self._timeout_network_error()
         except httpx.RequestError as e:
             raise NetworkError(f"Network error: {e}")
         except Exception as e:
@@ -191,13 +217,8 @@ class BedrockProvider(BaseProvider):
                 message, context, available_tools
             )
 
-            # Build URL - use appropriate endpoint based on model format
-            if self._is_arn(self.model):
-                # For ARN format, extract the actual model ID for the URL
-                model_for_url = self._extract_model_id_from_arn(self.model)
-                url = f"{self.base_url}/model" f"/{model_for_url}/converse"
-            else:
-                url = f"{self.base_url}/model" f"/{self.model}/converse"
+            # Build URL - an ARN model id is not usable as a path segment
+            url = f"{self.base_url}/model/{self._model_for_url()}/converse"
 
             # Create headers with Bearer token authentication
             headers = {
@@ -211,14 +232,14 @@ class BedrockProvider(BaseProvider):
                     url,
                     headers=headers,
                     content=request_body,
-                    timeout=30.0,
+                    timeout=self.request_timeout,
                 )
 
             # Handle response with tool calls
             return self._handle_response_with_tools(response)
 
         except httpx.TimeoutException:
-            raise NetworkError("Request to AWS Bedrock API timed out")
+            raise self._timeout_network_error()
         except httpx.RequestError as e:
             raise NetworkError(f"Network error: {e}")
         except Exception as e:

{omnimancer_cli-0.3.5 → 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.5
+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.5 → omnimancer_cli-0.3.7}/pyproject.toml

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