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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.3.4
+Version: 0.3.5
 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.5}/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.5}/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.5}/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()
-
-            # 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
+            # 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
 
-                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
@@ -232,11 +228,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
@@ -945,11 +943,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 +959,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 +967,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.5}/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)

{omnimancer_cli-0.3.4 → omnimancer_cli-0.3.5}/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.5/omnimancer/core/provider_resolver.py

@@ -0,0 +1,226 @@
+"""The single answer to "which provider entry is in force, and give me one".
+
+Every surface needs the same two things: the *effective* configuration
+(stored config with environment overrides applied, in that precedence) and an
+isolated provider instance built from one entry of it. Before this module each
+caller re-derived that independently: ``CoreEngine.initialize_providers``
+applied the overrides to a local variable and threw it away, H2L re-applied
+them per model ref, the prompt enhancer read the stored config and so never
+saw them, and subagents skipped resolution entirely and mutated the shared
+session provider's model. A provider configured purely through
+``OMNIMANCER_<PROVIDER>_API_KEY`` therefore existed for the engine and for
+nobody else.
+
+Two rules hold for everything here:
+
+* **Nothing is ever persisted.** :func:`effective_config` returns a deep copy
+  carrying ephemeral environment values; saving it would write env secrets
+  into ``~/.omnimancer/config.json``. Writers keep using
+  ``ConfigManager.get_config()``.
+* **Never hand out an object from ``engine.providers``.** Each resolution
+  builds its own instance from a ``model_copy`` of the entry, so parallel
+  work (H2L tiers, subagents) cannot interleave through a shared provider.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional, Union
+
+from ..providers.factory import ProviderFactory
+from .env_loader import apply_env_overrides
+from .models import Config, ProviderConfig
+
+logger = logging.getLogger(__name__)
+
+# Either a ConfigManager or an already-loaded Config is accepted, because the
+# callers have one or the other at hand and converting is this module's job.
+ConfigSource = Union[Config, Any]
+
+
+class ProviderResolutionError(ValueError):
+    """Base class: a provider entry could not be turned into an instance."""
+
+
+class EntryNotConfigured(ProviderResolutionError):
+    """No config entry, no environment entry, and no live instance."""
+
+    def __init__(self, provider: str) -> None:
+        self.provider = provider
+        self.env_var = "OMNIMANCER_" + provider.upper().replace("-", "_") + "_API_KEY"
+        super().__init__(
+            f"provider entry '{provider}' is not configured "
+            f"(see /providers, or set {self.env_var})"
+        )
+
+
+class ProviderInitFailed(ProviderResolutionError):
+    """The factory could not build the provider (bad credentials, bad model)."""
+
+    def __init__(self, provider: str, model: str, cause: Exception) -> None:
+        self.provider = provider
+        self.model = model
+        self.cause = cause
+        super().__init__(f"could not initialize {provider}:{model}: {cause}")
+
+
+class ToolsUnsupported(ProviderResolutionError):
+    """The caller required native tool calling and this provider has none."""
+
+    def __init__(self, provider: str) -> None:
+        self.provider = provider
+        super().__init__(f"provider '{provider}' does not support tool calling")
+
+
+def _as_config(source: ConfigSource) -> Config:
+    """Accept a ``Config``, a ``ConfigManager``, or any config-like object.
+
+    Config-like (anything exposing ``providers``) is allowed because callers
+    and tests pass lightweight stand-ins; environment overrides need a real
+    pydantic ``Config`` and degrade to a no-op for the rest.
+    """
+    if isinstance(source, Config):
+        return source
+    getter = getattr(source, "get_config", None)
+    if callable(getter):
+        config = getter()
+        if config is not None:
+            return config  # type: ignore[no-any-return,return-value]
+    if hasattr(source, "providers"):
+        return source  # type: ignore[no-any-return,return-value]
+    raise ProviderResolutionError(
+        "provider resolution needs a Config or a ConfigManager"
+    )
+
+
+def effective_config(source: ConfigSource) -> Config:
+    """Stored configuration with environment overrides applied.
+
+    This is the configuration the engine actually runs with. Never save it:
+    it carries ephemeral environment values, including API keys.
+    """
+    config = _as_config(source)
+    try:
+        return apply_env_overrides(config)
+    except Exception as exc:  # overrides must never block a run
+        logger.debug(f"Environment overrides unavailable: {exc}")
+        return config
+
+
+def effective_providers(source: ConfigSource) -> Dict[str, ProviderConfig]:
+    """The provider entries in force, including env-materialized ones."""
+    return effective_config(source).providers or {}
+
+
+def _entry_from_live_instance(
+    provider_name: str, engine: Optional[Any], model: str
+) -> Optional[ProviderConfig]:
+    """Rebuild an entry from a running instance (session flags, earlier init)."""
+    live = (getattr(engine, "providers", None) or {}) if engine is not None else {}
+    instance = live.get(provider_name) if isinstance(live, dict) else None
+    if instance is None:
+        return None
+
+    api_key = getattr(instance, "api_key", "") or ""
+    kwargs = {
+        k: v
+        for k, v in (getattr(instance, "config", None) or {}).items()
+        if v is not None and k not in ("api_key", "model")
+    }
+    for candidate in (kwargs, {}):
+        try:
+            return ProviderConfig(api_key=api_key, model=model, **candidate)
+        except Exception:
+            continue
+    return None
+
+
+def resolve_entry(
+    provider_name: str,
+    source: ConfigSource,
+    engine: Optional[Any] = None,
+    model: str = "",
+) -> ProviderConfig:
+    """The entry for ``provider_name``, from the first source that has it.
+
+    Environment-effective config first (what the engine initialized from),
+    then the stored config, then a live instance in ``engine.providers``.
+
+    Raises:
+        EntryNotConfigured: when no source knows this name.
+    """
+    config = _as_config(source)
+    stored = getattr(config, "providers", None) or {}
+    entry = effective_providers(config).get(provider_name) or stored.get(provider_name)
+    if entry is not None:
+        return entry
+
+    from_live = _entry_from_live_instance(provider_name, engine, model)
+    if from_live is not None:
+        return from_live
+
+    raise EntryNotConfigured(provider_name)
+
+
+def resolve_provider(
+    provider_name: str,
+    source: ConfigSource,
+    model: Optional[str] = None,
+    engine: Optional[Any] = None,
+    *,
+    min_output_tokens: Optional[int] = None,
+    require_tools: bool = False,
+    overrides: Optional[Dict[str, Any]] = None,
+) -> Any:
+    """Build a fresh provider instance for one entry.
+
+    Args:
+        provider_name: Config-entry name (may be an alias with provider_type).
+        source: ConfigManager or Config.
+        model: Model id to run; the entry's own model when omitted.
+        engine: Live engine, for the last-resort instance lookup.
+        min_output_tokens: Floor on ``max_tokens``; a larger configured value
+            wins. Providers default to 4096, which truncates long output.
+        require_tools: Reject a provider without native tool calling.
+        overrides: Extra entry fields to set (e.g. the enhancer's temperature).
+
+    Raises:
+        EntryNotConfigured, ProviderInitFailed, ToolsUnsupported
+    """
+    entry = resolve_entry(provider_name, source, engine, model or "")
+
+    update: Dict[str, Any] = dict(overrides or {})
+    if model:
+        update["model"] = model
+    if min_output_tokens is not None:
+        current = getattr(entry, "max_tokens", None) or 0
+        update["max_tokens"] = max(int(current), int(min_output_tokens))
+    effective = entry.model_copy(update=update) if update else entry
+
+    config_manager = None if isinstance(source, Config) else source
+    try:
+        provider = ProviderFactory.create_provider(
+            provider_name, effective, config_manager
+        )
+    except Exception as exc:
+        raise ProviderInitFailed(provider_name, effective.model, exc) from exc
+
+    if require_tools:
+        try:
+            supports_tools = bool(provider.supports_tools())
+        except Exception:  # a provider that cannot even answer is not usable
+            supports_tools = False
+        if not supports_tools:
+            raise ToolsUnsupported(provider_name)
+
+    # Belt and braces: the factory caches on (name, model), so an unchanged
+    # model can legitimately return the session's own object. Callers that
+    # need isolation pass a distinct model; warn when they do not get it.
+    shared = getattr(engine, "providers", None) if engine is not None else None
+    if isinstance(shared, dict) and any(provider is p for p in shared.values()):
+        logger.debug(
+            "Resolved %s to the session's own provider instance; work may "
+            "interleave with the main conversation",
+            provider_name,
+        )
+    return provider

omnimancer_cli-0.3.5/omnimancer/h2l/refs.py

@@ -0,0 +1,86 @@
+"""Resolve H2L model refs into isolated provider instances (PRD §1).
+
+Entry lookup and instance building live in
+:mod:`omnimancer.core.provider_resolver`, which every surface shares; this
+module is the H2L-flavoured wrapper that turns a resolution failure into an
+:class:`H2LConfigError` naming the tier. The rule that makes parallel tiers
+safe is the resolver's: never hand out an object from ``engine.providers``.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, List, Optional
+
+from ..core.provider_resolver import (
+    EntryNotConfigured,
+    ProviderInitFailed,
+    ProviderResolutionError,
+    ToolsUnsupported,
+    resolve_provider,
+)
+from .models import H2LConfig, H2LModelRef
+
+logger = logging.getLogger(__name__)
+
+
+class H2LConfigError(ValueError):
+    """A tier cannot run; the message says which one and why."""
+
+
+@dataclass
+class ResolvedTiers:
+    high: Any
+    low: List[Any] = field(default_factory=list)
+
+
+def resolve(
+    ref: H2LModelRef,
+    config_manager: Any,
+    engine: Optional[Any],
+    min_output_tokens: Optional[int] = None,
+) -> Any:
+    """Build a fresh, tool-capable provider for ``ref``.
+
+    ``min_output_tokens`` is a floor on the instance's ``max_tokens``: the
+    providers default to 4096, which truncates plans and verdict feedback (the
+    first live runs lost whole plans to it). A larger configured value wins.
+
+    Raises :class:`H2LConfigError` when the entry is not configured, the
+    factory cannot build it, or the provider reports no tool support.
+    """
+    try:
+        return resolve_provider(
+            ref.provider,
+            config_manager,
+            ref.model,
+            engine,
+            min_output_tokens=min_output_tokens,
+            require_tools=True,
+        )
+    except EntryNotConfigured as exc:
+        raise H2LConfigError(f"H2L: {exc}") from exc
+    except ToolsUnsupported as exc:
+        raise H2LConfigError(
+            f"H2L: {exc}; use an openai-compatible alias pointed at its "
+            "OpenAI endpoint (see docs/provider-setup.md)"
+        ) from exc
+    except ProviderInitFailed as exc:
+        raise H2LConfigError(
+            f"H2L: could not initialize {ref.label}: {exc.cause}"
+        ) from exc
+    except ProviderResolutionError as exc:  # future resolver failure modes
+        raise H2LConfigError(f"H2L: {exc}") from exc
+
+
+def validate_tiers(
+    config: H2LConfig, config_manager: Any, engine: Optional[Any]
+) -> ResolvedTiers:
+    """Resolve the high ref and every low ref before any model call (PRD §1)."""
+    high = resolve(config.high, config_manager, engine, config.high_max_tokens)
+    low = [
+        resolve(ref, config_manager, engine, config.low_max_tokens)
+        for ref in config.low
+    ]
+    return ResolvedTiers(high=high, low=low)

{omnimancer_cli-0.3.4 → omnimancer_cli-0.3.5}/omnimancer_cli.egg-info/PKG-INFO

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