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

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

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

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

@@ -13,6 +13,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from ..core.env_loader import apply_env_overrides
 from ..core.models import ChatResponse, Config
 from ..h2l.models import (
     H2LConfig,
@@ -48,13 +49,28 @@ class H2LOptions:
     plan_iterations: Optional[int] = None
 
 
+def _effective_default_provider(config: Config) -> str:
+    """The default provider a bare ref should use.
+
+    Environment beats stored config everywhere else, so a bare ``--high
+    kimi-k2`` under OMNIMANCER_DEFAULT_PROVIDER=bedrock must resolve to
+    bedrock rather than to the stale entry on disk.
+    """
+    try:
+        effective = apply_env_overrides(config)
+    except Exception as exc:  # overrides must never block a run
+        logger.debug("H2L: env overrides unavailable: %s", exc)
+        effective = config
+    return getattr(effective, "default_provider", "") or ""
+
+
 def resolve_h2l_config(config: Config, options: H2LOptions) -> H2LConfig:
     """Flags override the config block field by field; never persisted."""
     base: Dict[str, Any] = {}
     block = getattr(config, "h2l", None)
     if block is not None:
         base = block.model_dump()
-    default_provider = getattr(config, "default_provider", "") or ""
+    default_provider = _effective_default_provider(config)
 
     if options.high:
         base["high"] = parse_model_ref(options.high, default_provider)

{omnimancer_cli-0.3.4 → omnimancer_cli-0.3.6}/omnimancer/cli/subagent.py

@@ -2,9 +2,12 @@
 
 A subagent (see :class:`~omnimancer.core.models.SubAgentDefinition`) handles a
 focused task with its own system prompt, a restricted tool allowlist, and an
-optional model override. It runs an isolated loop against the current provider
-using its *own* conversation context, so the parent conversation is never
-touched. This is the lightweight counterpart to Claude Code's AgentTool.
+optional model override. It runs an isolated loop using its *own* conversation
+context, so the parent conversation is never touched. A model override also
+gets its own provider instance from
+:mod:`omnimancer.core.provider_resolver` rather than reassigning the shared
+session provider's model. This is the lightweight counterpart to Claude
+Code's AgentTool.
 """
 
 import logging
@@ -13,7 +16,12 @@ from dataclasses import dataclass, field
 from typing import Any, List, Optional
 
 from ..core.agent.status_core import EventType
-from ..core.models import ChatContext, SubAgentDefinition
+from ..core.models import ChatContext, ProviderConfig, SubAgentDefinition
+from ..core.provider_resolver import (
+    ProviderResolutionError,
+    resolve_entry,
+    resolve_provider,
+)
 from ..events import emitter as fleet_events
 from .tool_handler import ToolHandler
 
@@ -48,6 +56,50 @@ class SubAgentRunner:
         allowed = set(definition.tools)
         return [t for t in all_tools if t.name in allowed]
 
+    def _provider_name(self, provider: Any) -> str:
+        """The config-entry name for the running provider, if we can tell."""
+        providers = getattr(self.engine, "providers", None)
+        if isinstance(providers, dict):
+            for name, instance in providers.items():
+                if instance is provider:
+                    return str(name)
+        getter = getattr(provider, "get_provider_name", None)
+        if callable(getter):
+            raw_name = getter()
+            if isinstance(raw_name, str):
+                return str(raw_name)
+        return ""
+
+    def _isolated_provider(self, provider_name: str, model: str) -> Optional[Any]:
+        """A provider instance of our own for a model override.
+
+        Returns None when the entry cannot be resolved, so the caller falls
+        back to the legacy mutate-and-restore behaviour rather than failing
+        a subagent over a provider-resolution detail.
+        """
+        config_manager = getattr(self.engine, "config_manager", None)
+        if not provider_name or config_manager is None:
+            return None
+        try:
+            # Only a real entry is safe to build from: anything else means we
+            # cannot tell what we would be constructing.
+            entry = resolve_entry(provider_name, config_manager, self.engine, model)
+            if not isinstance(entry, ProviderConfig):
+                return None
+            return resolve_provider(provider_name, config_manager, model, self.engine)
+        except ProviderResolutionError as exc:
+            logger.debug(
+                "Subagent model override falling back to the shared provider: %s",
+                exc,
+            )
+            return None
+        except Exception as exc:
+            logger.debug(
+                "Subagent model override falling back to the shared provider: %s",
+                exc,
+            )
+            return None
+
     async def run(self, definition: SubAgentDefinition, task: str) -> SubAgentResult:
         """Execute the subagent's isolated tool-calling loop for ``task``."""
         provider = getattr(self.engine, "current_provider", None)
@@ -62,26 +114,24 @@ class SubAgentRunner:
         tool_handler = ToolHandler(agent_engine)
         tools = self._scoped_tools(tool_handler, definition)
 
+        # Identity is read before any override so the entry name is the
+        # session's, not something derived from a swapped-in instance.
+        provider_name = self._provider_name(provider)
+
+        shared_provider = provider
         original_model = getattr(provider, "model", None)
+        restore_model = False
         if definition.model:
-            provider.model = definition.model
+            isolated = self._isolated_provider(provider_name, definition.model)
+            if isolated is not None:
+                provider = isolated
+            else:
+                # Last resort: the shared object, restored in the finally.
+                provider.model = definition.model
+                restore_model = True
 
-        # Compute the provider/model identity for fleet lifecycle events.
         raw_model = getattr(provider, "model", "")
         model_used: str = raw_model if isinstance(raw_model, str) else ""
-        provider_name = ""
-        providers = getattr(self.engine, "providers", None)
-        if isinstance(providers, dict):
-            for name, instance in providers.items():
-                if instance is provider:
-                    provider_name = name
-                    break
-        if not provider_name:
-            getter = getattr(provider, "get_provider_name", None)
-            if callable(getter):
-                raw_name = getter()
-                if isinstance(raw_name, str):
-                    provider_name = raw_name
 
         # Isolated context — the parent conversation is never modified. The
         # run id is unique per invocation so two runs of the same subagent
@@ -164,9 +214,10 @@ class SubAgentRunner:
             finally:
                 # Restore the shared provider BEFORE any await: a cancellation
                 # during the emit must never leave the parent conversation
-                # running on the subagent's model.
-                if definition.model and original_model is not None:
-                    provider.model = original_model
+                # running on the subagent's model. Only the fallback path
+                # touched it; a resolved instance leaves it alone entirely.
+                if restore_model and original_model is not None:
+                    shared_provider.model = original_model
                 try:
                     await fleet_events.emit_event(
                         EventType.SESSION_END,

{omnimancer_cli-0.3.4 → omnimancer_cli-0.3.6}/omnimancer/core/engine.py

@@ -136,17 +136,13 @@ class CoreEngine:
     async def initialize_providers(self) -> None:
         """Initialize all configured providers."""
         try:
-            config = self.config_manager.get_config()
+            # The effective configuration: stored config plus ephemeral
+            # environment overrides (API keys, base_url, model, default
+            # provider), never persisted. Every other surface resolves
+            # against this same view via core.provider_resolver.
+            from .provider_resolver import effective_config
 
-            # Apply ephemeral environment-variable overrides (API keys,
-            # base_url, model, default provider). Never persisted to disk.
-            # Overrides must never prevent startup, so fall back on any error.
-            try:
-                from .env_loader import apply_env_overrides
-
-                config = apply_env_overrides(config)
-            except Exception as e:
-                logger.warning(f"Skipping environment overrides: {e}")
+            config = effective_config(self.config_manager)
 
             # Use the optimized provider initializer with
             # config_manager for API key decryption
@@ -186,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.
@@ -232,11 +229,13 @@ class CoreEngine:
                     break
         if not provider_name or not model:
             try:
-                config = self.config_manager.get_config()
+                from .provider_resolver import effective_config
+
+                config = effective_config(self.config_manager)
                 if not provider_name:
                     provider_name = config.default_provider or "unknown"
                 if not model:
-                    entry = config.providers.get(config.default_provider)
+                    entry = (config.providers or {}).get(config.default_provider)
                     raw = getattr(entry, "model", "")
                     model = raw if isinstance(raw, str) else ""
             except Exception as e:  # identity is best-effort diagnostics
@@ -308,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
@@ -945,11 +974,13 @@ class CoreEngine:
             Dictionary with health status information
         """
         try:
-            config = self.config_manager.get_config()
+            from .provider_resolver import effective_providers
+
+            providers = effective_providers(self.config_manager)
 
             if provider_name:
                 # Check specific provider
-                if provider_name not in config.providers:
+                if provider_name not in providers:
                     return {
                         provider_name: {
                             "status": "error",
@@ -959,7 +990,7 @@ class CoreEngine:
                         }
                     }
 
-                provider_config = config.providers[provider_name]
+                provider_config = providers[provider_name]
                 status = await self.health_monitor.check_provider_health(
                     provider_name, provider_config, force=force
                 )
@@ -967,7 +998,7 @@ class CoreEngine:
             else:
                 # Check all providers
                 return await self.health_monitor.check_all_providers_health(
-                    config.providers, force=force
+                    providers, force=force
                 )
 
         except Exception as e:

{omnimancer_cli-0.3.4 → omnimancer_cli-0.3.6}/omnimancer/core/env_loader.py

@@ -7,13 +7,16 @@ and inject them into provider configurations.
 
 import logging
 import os
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Dict, Optional, Set
 
 if TYPE_CHECKING:
     from .models import Config
 
 logger = logging.getLogger(__name__)
 
+# Namespaced env-var suffixes recognized for every provider.
+ENV_VAR_SUFFIXES = ("API_KEY", "BASE_URL", "MODEL")
+
 # Mapping of provider names to (conventional) environment variable names for API keys.
 ENV_VAR_MAPPING = {
     "claude": "ANTHROPIC_API_KEY",
@@ -37,6 +40,31 @@ def _omnimancer_env_prefix(provider_name: str) -> str:
     return "OMNIMANCER_" + provider_name.upper().replace("-", "_")
 
 
+def env_configured_provider_names() -> Set[str]:
+    """Registered provider names that have OMNIMANCER_<PROVIDER>_* vars set.
+
+    ``ENV_VAR_MAPPING`` only lists providers that have a conventional
+    single-key variable, so without this a namespaced key for anything else
+    (bedrock, vertex, openai-compatible) was never even considered as a
+    candidate and was silently ignored. The registry is the source of names so
+    the underscore-to-hyphen mapping stays unambiguous.
+    """
+    try:
+        from ..providers.factory import ProviderFactory
+
+        registered = set(ProviderFactory.get_available_providers())
+    except Exception as exc:  # discovery must never block config loading
+        logger.debug(f"Provider registry unavailable for env discovery: {exc}")
+        return set()
+
+    names: Set[str] = set()
+    for name in registered:
+        prefix = _omnimancer_env_prefix(name)
+        if any(os.environ.get(f"{prefix}_{suffix}") for suffix in ENV_VAR_SUFFIXES):
+            names.add(name)
+    return names
+
+
 def load_provider_env_overrides(provider_name: str) -> Dict[str, str]:
     """
     Collect per-provider overrides from environment variables.
@@ -176,8 +204,13 @@ def apply_env_overrides(config: "Config") -> "Config":
     effective = config.model_copy(deep=True)
 
     # Consider providers already configured, those with a recognized API-key
-    # env var, plus any provider named by OMNIMANCER_DEFAULT_PROVIDER.
-    candidates = set(effective.providers.keys()) | set(ENV_VAR_MAPPING.keys())
+    # env var or a namespaced OMNIMANCER_<PROVIDER>_* var, plus any provider
+    # named by OMNIMANCER_DEFAULT_PROVIDER.
+    candidates = (
+        set(effective.providers.keys())
+        | set(ENV_VAR_MAPPING.keys())
+        | env_configured_provider_names()
+    )
     default_override = os.environ.get(DEFAULT_PROVIDER_ENV_VAR)
     if default_override:
         candidates.add(default_override)
@@ -197,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"]
@@ -208,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.4 → omnimancer_cli-0.3.6}/omnimancer/core/prompt_enhancer.py

@@ -264,23 +264,24 @@ async def enhance(
         if fallback_model is not None and fallback_model not in candidates:
             candidates.append(fallback_model)
 
-        from ..providers.factory import ProviderFactory
+        from .provider_resolver import ProviderResolutionError, resolve_provider
 
         for provider_name, model in candidates:
-            provider_config = config.providers.get(provider_name)
-            if provider_config is None:
+            try:
+                # The shared resolver so an entry materialized from
+                # OMNIMANCER_<PROVIDER>_* is as usable here as in the engine.
+                provider = resolve_provider(
+                    provider_name,
+                    config_manager,
+                    model,
+                    overrides={"temperature": temperature},
+                )
+            except ProviderResolutionError as exc:
                 logger.warning(
-                    "Enhancement provider %r is not configured", provider_name
+                    "Enhancement provider %r unusable: %s", provider_name, exc
                 )
                 continue
             try:
-                effective = provider_config.model_copy(
-                    update={"model": model, "temperature": temperature}
-                )
-                provider = ProviderFactory.create_provider(
-                    provider_name, effective, config_manager
-                )
-
                 # Isolated context: the session conversation never leaks
                 # into the rewrite, and the rewrite never lands in session
                 # history.

{omnimancer_cli-0.3.4 → omnimancer_cli-0.3.6}/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:
         """