omnimancer-cli 0.2.19__tar.gz → 0.2.20__tar.gz

{omnimancer_cli-0.2.19/omnimancer_cli.egg-info → omnimancer_cli-0.2.20}/PKG-INFO

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

{omnimancer_cli-0.2.19 → omnimancer_cli-0.2.20}/omnimancer/providers/base.py

@@ -6,6 +6,8 @@ to ensure consistent behavior across different AI services.
 """
 
 import json
+import logging
+import os
 from abc import ABC, abstractmethod
 from typing import Any, AsyncIterator, Dict, List, Union
 
@@ -19,6 +21,8 @@ from ..core.models import (
     ToolDefinition,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class BaseProvider(ABC):
     """
@@ -28,6 +32,32 @@ class BaseProvider(ABC):
     the required abstract methods to ensure consistent behavior.
     """
 
+    # Default chat-completion timeout. Large models on serverless backends
+    # (e.g. 300B+ models on DigitalOcean inference) can take well over a
+    # minute to first byte with tool-heavy agent prompts — hardcoded 30s/60s
+    # timeouts made those models unusable in headless runs.
+    DEFAULT_REQUEST_TIMEOUT = 120.0
+
+    @classmethod
+    def _resolve_request_timeout(cls, configured: Any) -> float:
+        """
+        Resolve the chat-completion timeout: explicit config wins, then the
+        OMNIMANCER_REQUEST_TIMEOUT environment variable, then the default.
+        Invalid or non-positive values fall back to the default.
+        """
+        for raw in (configured, os.environ.get("OMNIMANCER_REQUEST_TIMEOUT")):
+            if raw is None or raw == "":
+                continue
+            try:
+                value = float(raw)
+            except (TypeError, ValueError):
+                logger.warning("Ignoring invalid request timeout %r", raw)
+                continue
+            if value > 0:
+                return value
+            logger.warning("Ignoring non-positive request timeout %r", raw)
+        return cls.DEFAULT_REQUEST_TIMEOUT
+
     def __init__(self, api_key: str, model: str, **kwargs: Any) -> None:
         """
         Initialize the provider.

{omnimancer_cli-0.2.19 → omnimancer_cli-0.2.20}/omnimancer/providers/openai.py

@@ -57,13 +57,18 @@ class OpenAIProvider(BaseProvider):
         Args:
             api_key: OpenAI API key
             model: OpenAI model to use (e.g., 'gpt-4', 'gpt-4o', 'gpt-3.5-turbo')
-            **kwargs: Additional configuration
+            **kwargs: Additional configuration. Supports ``request_timeout``
+                (seconds) for chat completions; the ``OMNIMANCER_REQUEST_TIMEOUT``
+                environment variable is used when the kwarg is not given.
         """
         super().__init__(api_key, model or "gpt-4", **kwargs)
         # Allow overriding the API endpoint for OpenAI-compatible services
         self.base_url = (kwargs.get("base_url") or self.BASE_URL).rstrip("/")
         self.max_tokens = kwargs.get("max_tokens", 4096)
         self.temperature = kwargs.get("temperature", 0.7)
+        self.request_timeout = self._resolve_request_timeout(
+            kwargs.get("request_timeout")
+        )
 
     async def send_message(self, message: str, context: ChatContext) -> ChatResponse:
         """
@@ -88,7 +93,7 @@ class OpenAIProvider(BaseProvider):
                     "max_tokens": self.max_tokens,
                     "temperature": self.temperature,
                 },
-                timeout=30.0,
+                timeout=self.request_timeout,
             )
 
             # Handle response
@@ -249,6 +254,19 @@ class OpenAIProvider(BaseProvider):
             provider=provider,
         )
 
+    async def _post_once(self, body: Dict[str, Any], timeout: float) -> httpx.Response:
+        """Single POST to the chat completions endpoint."""
+        async with httpx.AsyncClient() as client:
+            return await client.post(
+                f"{self.base_url}/chat/completions",
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self.api_key}",
+                },
+                json=body,
+                timeout=timeout,
+            )
+
     async def _post_chat(
         self, request_body: Dict[str, Any], timeout: float
     ) -> httpx.Response:
@@ -264,16 +282,18 @@ class OpenAIProvider(BaseProvider):
         self._require_api_key()
 
         async def _do_post(body: Dict[str, Any]) -> httpx.Response:
-            async with httpx.AsyncClient() as client:
-                return await client.post(
-                    f"{self.base_url}/chat/completions",
-                    headers={
-                        "Content-Type": "application/json",
-                        "Authorization": f"Bearer {self.api_key}",
-                    },
-                    json=body,
-                    timeout=timeout,
+            # Serverless backends (notably DigitalOcean inference) sporadically
+            # time out on an otherwise-fine request; one retry absorbs those
+            # transient stalls instead of failing the whole agent run.
+            try:
+                return await self._post_once(body, timeout)
+            except httpx.TimeoutException:
+                logger.warning(
+                    "%s chat completion timed out after %.0fs — retrying once",
+                    self.PROVIDER_LABEL,
+                    timeout,
                 )
+                return await self._post_once(body, timeout)
 
         body = request_body
         response = await _do_post(body)
@@ -414,7 +434,7 @@ class OpenAIProvider(BaseProvider):
             if tools:
                 request_body["tools"] = tools
 
-            response = await self._post_chat(request_body, timeout=60.0)
+            response = await self._post_chat(request_body, timeout=self.request_timeout)
 
             return self._handle_response_with_tools(response)
 

{omnimancer_cli-0.2.19 → omnimancer_cli-0.2.20}/omnimancer/providers/openrouter.py

@@ -67,6 +67,9 @@ class OpenRouterProvider(BaseProvider):
         self.top_p = kwargs.get("top_p", 1.0)
         self.frequency_penalty = kwargs.get("frequency_penalty", 0.0)
         self.presence_penalty = kwargs.get("presence_penalty", 0.0)
+        self.request_timeout = self._resolve_request_timeout(
+            kwargs.get("request_timeout")
+        )
 
         # Cost optimization settings
         self.enable_fallback = kwargs.get("enable_fallback", True)
@@ -115,7 +118,7 @@ class OpenRouterProvider(BaseProvider):
                         f"{self.base_url}/chat/completions",
                         headers=self._get_headers(),
                         json=payload,
-                        timeout=30.0,
+                        timeout=self.request_timeout,
                     )
 
                 # If we get here, the request succeeded
@@ -201,7 +204,7 @@ class OpenRouterProvider(BaseProvider):
                         f"{self.base_url}/chat/completions",
                         headers=self._get_headers(),
                         json=payload,
-                        timeout=30.0,
+                        timeout=self.request_timeout,
                     )
 
                 # If we get here, the request succeeded

{omnimancer_cli-0.2.19 → omnimancer_cli-0.2.20/omnimancer_cli.egg-info}/PKG-INFO

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

{omnimancer_cli-0.2.19 → omnimancer_cli-0.2.20}/omnimancer_cli.egg-info/SOURCES.txt

@@ -132,6 +132,7 @@ tests/test_models.py
 tests/test_ollama_provider.py
 tests/test_openai_context_fit.py
 tests/test_openai_provider_tools.py
+tests/test_openai_request_timeout.py
 tests/test_openrouter_provider.py
 tests/test_permission_rules.py
 tests/test_perplexity_provider.py

{omnimancer_cli-0.2.19 → omnimancer_cli-0.2.20}/pyproject.toml

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

omnimancer_cli-0.2.20/tests/test_openai_request_timeout.py

@@ -0,0 +1,129 @@
+"""Tests for chat-completion request timeouts and timeout retry.
+
+Covers the OpenAI provider and, by inheritance, the DigitalOcean and other
+OpenAI-compatible providers. Large models on serverless backends (e.g.
+DigitalOcean inference) exceed the old hardcoded 30s/60s timeouts, and the
+backend also stalls sporadically — headless agent runs died with
+"Request to OpenAI API timed out" and no output.
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from omnimancer.core.models import ChatContext
+from omnimancer.providers.digitalocean import DigitalOceanProvider
+from omnimancer.providers.openai import OpenAIProvider
+from omnimancer.providers.openrouter import OpenRouterProvider
+from omnimancer.utils.errors import NetworkError
+
+
+def _ok_response(content="done"):
+    resp = MagicMock()
+    resp.status_code = 200
+    resp.json = MagicMock(
+        return_value={
+            "choices": [{"message": {"content": content}, "finish_reason": "stop"}],
+            "usage": {"prompt_tokens": 1, "completion_tokens": 1},
+        }
+    )
+    return resp
+
+
+@pytest.fixture
+def context():
+    return ChatContext(messages=[], current_model="m", session_id="s")
+
+
+class TestTimeoutResolution:
+    def test_default(self, monkeypatch):
+        monkeypatch.delenv("OMNIMANCER_REQUEST_TIMEOUT", raising=False)
+        provider = OpenAIProvider(api_key="k")
+        assert provider.request_timeout == OpenAIProvider.DEFAULT_REQUEST_TIMEOUT
+
+    def test_kwarg_wins_over_env(self, monkeypatch):
+        monkeypatch.setenv("OMNIMANCER_REQUEST_TIMEOUT", "300")
+        provider = OpenAIProvider(api_key="k", request_timeout=45)
+        assert provider.request_timeout == 45.0
+
+    def test_env_var(self, monkeypatch):
+        monkeypatch.setenv("OMNIMANCER_REQUEST_TIMEOUT", "300")
+        provider = DigitalOceanProvider(api_key="k", model="qwen-x")
+        assert provider.request_timeout == 300.0
+
+    @pytest.mark.parametrize("bad", ["not-a-number", "-5", "0"])
+    def test_invalid_values_fall_back(self, monkeypatch, bad):
+        monkeypatch.setenv("OMNIMANCER_REQUEST_TIMEOUT", bad)
+        provider = OpenAIProvider(api_key="k")
+        assert provider.request_timeout == OpenAIProvider.DEFAULT_REQUEST_TIMEOUT
+
+    def test_openrouter_env_var(self, monkeypatch):
+        monkeypatch.setenv("OMNIMANCER_REQUEST_TIMEOUT", "300")
+        provider = OpenRouterProvider(api_key="k")
+        assert provider.request_timeout == 300.0
+
+
+class TestOpenRouterTimeoutUsed:
+    async def test_send_message_uses_configured_timeout(self, context):
+        provider = OpenRouterProvider(api_key="k", request_timeout=250)
+        seen = []
+
+        async def fake_post(url, **kwargs):
+            seen.append(kwargs["timeout"])
+            return _ok_response()
+
+        with patch("httpx.AsyncClient") as client:
+            inst = client.return_value.__aenter__.return_value
+            inst.post = AsyncMock(side_effect=fake_post)
+            await provider.send_message("hi", context)
+
+        assert seen == [250]
+
+
+class TestTimeoutUsedOnRequests:
+    async def test_send_message_uses_configured_timeout(self, context):
+        provider = OpenAIProvider(api_key="k", request_timeout=222)
+        seen = []
+
+        async def fake_post(url, **kwargs):
+            seen.append(kwargs["timeout"])
+            return _ok_response()
+
+        with patch("httpx.AsyncClient") as client:
+            inst = client.return_value.__aenter__.return_value
+            inst.post = AsyncMock(side_effect=fake_post)
+            await provider.send_message("hi", context)
+
+        assert seen == [222]
+
+
+class TestTimeoutRetry:
+    async def test_retries_once_on_timeout_then_succeeds(self, context):
+        provider = DigitalOceanProvider(api_key="k", model="qwen-x")
+        calls = []
+
+        async def fake_post(url, **kwargs):
+            calls.append(url)
+            if len(calls) == 1:
+                raise httpx.ReadTimeout("stalled")
+            return _ok_response("recovered")
+
+        with patch("httpx.AsyncClient") as client:
+            inst = client.return_value.__aenter__.return_value
+            inst.post = AsyncMock(side_effect=fake_post)
+            result = await provider.send_message("hi", context)
+
+        assert result.content == "recovered"
+        assert len(calls) == 2
+
+    async def test_second_timeout_raises_network_error(self, context):
+        provider = DigitalOceanProvider(api_key="k", model="qwen-x")
+
+        with patch("httpx.AsyncClient") as client:
+            inst = client.return_value.__aenter__.return_value
+            inst.post = AsyncMock(side_effect=httpx.ReadTimeout("stalled"))
+            with pytest.raises(NetworkError):
+                await provider.send_message("hi", context)
+
+        assert inst.post.await_count == 2