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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.19
+Version: 0.2.22
 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.22}/omnimancer/cli/headless.py

@@ -5,6 +5,8 @@ results to stdout. No Rich console, no readline, no interactive UI.
 """
 
 import json
+import logging
+import os
 import sys
 import uuid
 from enum import Enum
@@ -24,6 +26,53 @@ from .tool_handler import (
     ToolHandler,
 )
 
+logger = logging.getLogger(__name__)
+
+# A turn with no tool calls used to end the run immediately. Models that
+# narrate their plan ("Let me look into X...") without attaching a tool call
+# made headless runs "complete" with zero work done, so the runner now nudges
+# the model to either keep working or explicitly declare completion.
+NO_TOOL_CALL_NUDGE = (
+    "You did not call any tools. If the task is fully complete, reply with "
+    "exactly DONE. Otherwise continue working now by calling tools — do not "
+    "describe what you plan to do without doing it."
+)
+
+# Consecutive tool-less turns tolerated before the run is ended anyway.
+MAX_NO_TOOL_NUDGES = 2
+
+
+def _is_done_reply(content: Optional[str]) -> bool:
+    """True when the model explicitly declares completion per the nudge."""
+    if not content:
+        return False
+    lines = content.strip().splitlines()
+    if not lines:
+        return False
+    return lines[-1].strip().rstrip(".!").upper() == "DONE"
+
+
+def _resolve_max_iterations(explicit: Optional[int]) -> int:
+    """Resolve the tool-iteration cap: explicit value wins, then the
+    OMNIMANCER_MAX_ITERATIONS environment variable, then the default.
+
+    The default (25) suits interactive use; orchestrators running real
+    coding tasks inject a higher cap — exhausting it mid-task previously
+    looked like a clean "completed" run with no changes.
+    """
+    if explicit:
+        return explicit
+    raw = os.environ.get("OMNIMANCER_MAX_ITERATIONS")
+    if raw:
+        try:
+            value = int(raw)
+            if value > 0:
+                return value
+            logger.warning("Ignoring non-positive OMNIMANCER_MAX_ITERATIONS %r", raw)
+        except ValueError:
+            logger.warning("Ignoring invalid OMNIMANCER_MAX_ITERATIONS %r", raw)
+    return MAX_TOOL_ITERATIONS
+
 
 class OutputFormat(Enum):
     TEXT = "text"
@@ -229,7 +278,7 @@ class HeadlessRunner:
         self._verbose = verbose
         # Headless runs are unattended, so a cap (not a check-in prompt) is
         # the safety net; --max-iterations sizes it to the job.
-        self._max_iterations = max_iterations or MAX_TOOL_ITERATIONS
+        self._max_iterations = _resolve_max_iterations(max_iterations)
         session_id = str(uuid.uuid4())
         self._emitter = HeadlessOutputEmitter(output_format, session_id, verbose)
         self._tokens = TokenAccumulator()
@@ -296,6 +345,7 @@ class HeadlessRunner:
 
         current_message = f"{agent_prompt}\n\nUser: {prompt}"
         last_content = ""
+        prev_content = ""
         last_model = model
         last_stop_reason = "end_turn"
         # Record of the actions the agent took, surfaced in the JSON result.
@@ -304,6 +354,7 @@ class HeadlessRunner:
         # Identical repeated calls get skipped with a corrective nudge; the
         # run is aborted only if the model keeps repeating despite nudges.
         repeat_tracker = RepeatedCallTracker()
+        no_tool_nudges = 0
 
         for iteration in range(self._max_iterations):
             turns = iteration + 1
@@ -322,6 +373,7 @@ class HeadlessRunner:
             last_stop_reason = response.stop_reason or "end_turn"
 
             if response.content:
+                prev_content = last_content
                 last_content = response.content
                 self._emitter.emit_assistant(
                     response.content,
@@ -334,9 +386,30 @@ class HeadlessRunner:
             # those so the run doesn't end with the work undone.
             if not response.tool_calls:
                 recovered = parse_described_tool_calls(response.content)
-                if not recovered:
-                    break
-                response.tool_calls = recovered
+                if recovered:
+                    response.tool_calls = recovered
+                else:
+                    # No tool call: either the final answer or narration from
+                    # a model that stopped without acting. End the run only on
+                    # an explicit DONE or after repeated nudges — breaking
+                    # immediately made agents "complete" with zero changes.
+                    if (
+                        _is_done_reply(response.content)
+                        or no_tool_nudges >= MAX_NO_TOOL_NUDGES
+                    ):
+                        # A bare "DONE" acknowledgment must not replace the
+                        # model's actual final summary in the result payload.
+                        if (
+                            response.content
+                            and response.content.strip().rstrip(".!").upper() == "DONE"
+                            and prev_content
+                        ):
+                            last_content = prev_content
+                        break
+                    no_tool_nudges += 1
+                    current_message = NO_TOOL_CALL_NUDGE
+                    continue
+            no_tool_nudges = 0
 
             repeat_tracker.record(response.tool_calls)
             offender = repeat_tracker.abort_offender(response.tool_calls)

{omnimancer_cli-0.2.19 → omnimancer_cli-0.2.22}/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.22}/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.22}/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.22/omnimancer_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.19
+Version: 0.2.22
 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.22}/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.22}/pyproject.toml

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

omnimancer_cli-0.2.22/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