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

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

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

{omnimancer_cli-0.3.5 → omnimancer_cli-0.3.6}/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.6}/omnimancer_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.3.5
+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.5 → omnimancer_cli-0.3.6}/pyproject.toml

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

{omnimancer_cli-0.3.5 → omnimancer_cli-0.3.6}/tests/test_bedrock_provider.py

@@ -421,6 +421,86 @@ class TestBedrockProviderRequestPreparation:
 # ---------------------------------------------------------------------------
 
 
+class TestBedrockProviderRequestTimeout:
+    """Bedrock hardcoded 30s while the base class already had the knob.
+
+    BaseProvider._resolve_request_timeout (explicit config, then
+    OMNIMANCER_REQUEST_TIMEOUT, then DEFAULT_REQUEST_TIMEOUT) existed for
+    exactly this reason: a long agent turn on a large model needs more than
+    30 seconds, and only the OpenAI family honoured it.
+    """
+
+    @pytest.fixture(autouse=True)
+    def no_env_timeout(self, monkeypatch):
+        monkeypatch.delenv("OMNIMANCER_REQUEST_TIMEOUT", raising=False)
+        yield
+
+    def test_default_is_the_shared_default_not_thirty(self):
+        provider = BedrockProvider(api_key="k", model=_SONNET_MODEL)
+        assert provider.request_timeout == BedrockProvider.DEFAULT_REQUEST_TIMEOUT
+        assert provider.request_timeout > 30.0
+
+    def test_configured_timeout_wins(self):
+        provider = BedrockProvider(api_key="k", model=_SONNET_MODEL, timeout=600)
+        assert provider.request_timeout == 600.0
+
+    def test_env_timeout_is_honoured(self, monkeypatch):
+        monkeypatch.setenv("OMNIMANCER_REQUEST_TIMEOUT", "300")
+        provider = BedrockProvider(api_key="k", model=_SONNET_MODEL)
+        assert provider.request_timeout == 300.0
+
+    @pytest.mark.asyncio
+    async def test_send_message_uses_the_resolved_timeout(
+        self, sample_chat_context, mock_converse_response
+    ):
+        provider = BedrockProvider(api_key="k", model=_SONNET_MODEL, timeout=450)
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_converse_response
+
+        with patch("httpx.AsyncClient") as mock_client:
+            mock_post = AsyncMock(return_value=mock_response)
+            mock_client.return_value.__aenter__.return_value.post = mock_post
+            await provider.send_message("Hello", sample_chat_context)
+
+        assert mock_post.call_args.kwargs["timeout"] == 450.0
+
+    @pytest.mark.asyncio
+    async def test_send_message_with_tools_uses_the_resolved_timeout(
+        self, sample_chat_context, sample_tools, mock_tool_response
+    ):
+        provider = BedrockProvider(api_key="k", model=_SONNET_MODEL, timeout=450)
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_tool_response
+
+        with patch("httpx.AsyncClient") as mock_client:
+            mock_post = AsyncMock(return_value=mock_response)
+            mock_client.return_value.__aenter__.return_value.post = mock_post
+            await provider.send_message_with_tools(
+                "Hello", sample_chat_context, sample_tools
+            )
+
+        assert mock_post.call_args.kwargs["timeout"] == 450.0
+
+    @pytest.mark.asyncio
+    async def test_timeout_error_names_the_limit_and_the_knob(
+        self, sample_chat_context
+    ):
+        """A bare "timed out" leaves the user nothing to act on."""
+        provider = BedrockProvider(api_key="k", model=_SONNET_MODEL, timeout=45)
+        with patch("httpx.AsyncClient") as mock_client:
+            mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+                side_effect=httpx.TimeoutException("too slow")
+            )
+            with pytest.raises(NetworkError) as exc:
+                await provider.send_message("Hello", sample_chat_context)
+
+        message = str(exc.value)
+        assert "45" in message
+        assert "OMNIMANCER_REQUEST_TIMEOUT" in message
+
+
 class TestBedrockProviderARNRoutingBehaviour:
     """Test that ARN-format models result in correct URL construction.
 
@@ -460,6 +540,29 @@ class TestBedrockProviderARNRoutingBehaviour:
             assert bare_model_id in call_url
             assert "arn:aws:bedrock:" not in call_url
 
+    @pytest.mark.asyncio
+    async def test_send_message_uses_extracted_id_in_url_for_arn(
+        self, bedrock_provider_arn, sample_chat_context, mock_converse_response
+    ):
+        """The no-tools path must extract the ARN too.
+
+        send_message_with_tools extracted the bare model id while
+        send_message interpolated the whole ARN, so the same configured
+        model worked in agent mode and built a malformed URL in plain chat.
+        """
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_converse_response
+
+        with patch("httpx.AsyncClient") as mock_client:
+            mock_post = AsyncMock(return_value=mock_response)
+            mock_client.return_value.__aenter__.return_value.post = mock_post
+            await bedrock_provider_arn.send_message("Hello", sample_chat_context)
+
+        call_url = mock_post.call_args[0][0]
+        assert _SONNET_ARN.split("/")[-1] in call_url
+        assert "arn:aws:bedrock:" not in call_url
+
     @pytest.mark.asyncio
     async def test_send_message_standard_model_uses_model_id_in_url(
         self, bedrock_provider, sample_chat_context