ouroboros-ai 0.26.5.dev7__tar.gz → 0.26.5.dev8__tar.gz

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.5.dev7
+Version: 0.26.5.dev8
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.26.5.dev7'
-__version_tuple__ = version_tuple = (0, 26, 5, 'dev7')
+__version__ = version = '0.26.5.dev8'
+__version_tuple__ = version_tuple = (0, 26, 5, 'dev8')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/src/ouroboros/providers/claude_code_adapter.py

@@ -89,9 +89,11 @@ class ClaudeCodeAdapter:
         self,
         permission_mode: str = "default",
         cli_path: str | Path | None = None,
+        cwd: str | Path | None = None,
         allowed_tools: list[str] | None = None,
         max_turns: int = 1,
         on_message: Callable[[str, str], None] | None = None,
+        timeout: float | None = None,
     ) -> None:
         """Initialize Claude Code adapter.
 
@@ -102,23 +104,34 @@ class ClaudeCodeAdapter:
             cli_path: Path to the Claude CLI binary. If not provided,
                 checks OUROBOROS_CLI_PATH env var, then falls back to
                 SDK's bundled CLI.
-            allowed_tools: List of tools to allow. None means no tools.
-                For interview mode with codebase access, use ["Read", "Glob", "Grep"].
+            cwd: Working directory passed to the Claude Agent SDK.
+            allowed_tools: Explicit allow-list for Claude tools. ``None`` keeps
+                the default permissive mode while still blocking dangerous tools.
+                Use ``[]`` to forbid all Claude tools.
             max_turns: Maximum turns for the conversation. Default 1 for
                 single-response completions (most MCP use cases).
             on_message: Callback for streaming messages. Called with (type, content):
                 - ("thinking", "content") for agent reasoning
                 - ("tool", "tool_name") for tool usage
+            timeout: Optional application-level timeout in seconds for a
+                single completion request. When set, aborts before outer
+                transport timeouts and returns a ProviderError.
         """
         self._permission_mode: str = permission_mode
         self._cli_path: Path | None = self._resolve_cli_path(cli_path)
-        self._allowed_tools: list[str] = allowed_tools or []
+        self._cwd: str = str(Path(cwd).expanduser()) if cwd is not None else os.getcwd()
+        self._allowed_tools: list[str] | None = (
+            list(allowed_tools) if allowed_tools is not None else None
+        )
         self._max_turns: int = max_turns
         self._on_message: Callable[[str, str], None] | None = on_message
+        self._timeout: float | None = timeout if timeout and timeout > 0 else None
         log.info(
             "claude_code_adapter.initialized",
             permission_mode=permission_mode,
             cli_path=str(self._cli_path) if self._cli_path else None,
+            cwd=self._cwd,
+            timeout_seconds=self._timeout,
         )
 
     def _resolve_cli_path(self, cli_path: str | Path | None) -> Path | None:
@@ -260,9 +273,15 @@ class ClaudeCodeAdapter:
 
         for attempt in range(_MAX_RETRIES):
             try:
-                result = await self._execute_single_request(
-                    prompt, config, system_prompt=system_prompt
-                )
+                if self._timeout is None:
+                    result = await self._execute_single_request(
+                        prompt, config, system_prompt=system_prompt
+                    )
+                else:
+                    async with asyncio.timeout(self._timeout):
+                        result = await self._execute_single_request(
+                            prompt, config, system_prompt=system_prompt
+                        )
 
                 if result.is_ok:
                     if attempt > 0:
@@ -290,6 +309,22 @@ class ClaudeCodeAdapter:
                 # Non-retryable error
                 return result
 
+            except TimeoutError:
+                log.warning(
+                    "claude_code_adapter.request_timed_out",
+                    timeout_seconds=self._timeout,
+                    attempt=attempt + 1,
+                )
+                return Result.err(
+                    ProviderError(
+                        message=f"Claude Code request timed out after {self._timeout:.1f}s",
+                        details={
+                            "timed_out": True,
+                            "timeout_seconds": self._timeout,
+                            "attempt": attempt + 1,
+                        },
+                    )
+                )
             except Exception as e:
                 error_str = str(e)
                 error_type = type(e).__name__
@@ -405,16 +440,17 @@ class ClaudeCodeAdapter:
             log.debug("claude_code_adapter.stderr", line=line[:200])
 
         options_kwargs: dict = {
-            "allowed_tools": self._allowed_tools if self._allowed_tools is not None else [],
             "disallowed_tools": disallowed,
             "max_turns": self._max_turns,
             # Allow MCP and other ~/.claude/ settings to be inherited
             "permission_mode": self._permission_mode,
-            "cwd": os.getcwd(),
+            "cwd": self._cwd,
             "cli_path": self._cli_path,
             "stderr": _stderr_callback,
             "env": env_overrides,
         }
+        if self._allowed_tools is not None:
+            options_kwargs["allowed_tools"] = self._allowed_tools
 
         # Pass model from CompletionConfig if specified
         # "default" is not a valid SDK model — treat it as None (use SDK default)

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/src/ouroboros/providers/codex_cli_adapter.py

@@ -81,7 +81,7 @@ class CodexCliLLMAdapter:
         self._cli_path = self._resolve_cli_path(cli_path)
         self._cwd = str(Path(cwd).expanduser()) if cwd is not None else os.getcwd()
         self._permission_mode = self._resolve_permission_mode(permission_mode)
-        self._allowed_tools = allowed_tools or []
+        self._allowed_tools = list(allowed_tools) if allowed_tools is not None else None
         self._max_turns = max_turns
         self._on_message = on_message
         self._max_retries = max_retries
@@ -150,12 +150,22 @@ class CodexCliLLMAdapter:
                 "If you need tools, prefer using only the following tools:\n"
                 + "\n".join(f"- {tool}" for tool in self._allowed_tools)
             )
+        elif self._allowed_tools is not None:
+            # Explicit empty list means no tools allowed — text-only response
+            parts.append("## Tool Constraints")
+            parts.append("Do NOT use any tools or MCP calls. Respond with plain text only.")
 
         if self._max_turns > 0:
             parts.append("## Execution Budget")
-            parts.append(
-                f"Keep the work within at most {self._max_turns} tool-assisted turns if possible."
-            )
+            if self._allowed_tools == []:
+                parts.append(
+                    "Answer directly in plain text and avoid turning this into a "
+                    "multi-step tool workflow."
+                )
+            else:
+                parts.append(
+                    f"Keep the work within at most {self._max_turns} tool-assisted turns if possible."
+                )
 
         for message in messages:
             if message.role == MessageRole.SYSTEM:

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/src/ouroboros/providers/factory.py

@@ -94,9 +94,11 @@ def create_llm_adapter(
         return ClaudeCodeAdapter(
             permission_mode=resolved_permission_mode,
             cli_path=cli_path,
+            cwd=cwd,
             allowed_tools=allowed_tools,
             max_turns=max_turns,
             on_message=on_message,
+            timeout=timeout,
         )
     if resolved_backend == "codex":
         return CodexCliLLMAdapter(
@@ -110,7 +112,14 @@ def create_llm_adapter(
             max_retries=max_retries,
         )
     # opencode is rejected at resolve time; this is a defensive fallback
-    from ouroboros.providers.litellm_adapter import LiteLLMAdapter
+    try:
+        from ouroboros.providers.litellm_adapter import LiteLLMAdapter
+    except ImportError as exc:
+        msg = (
+            "litellm backend requested but litellm is not installed. "
+            "Install with: pip install 'ouroboros-ai[litellm]'"
+        )
+        raise RuntimeError(msg) from exc
 
     return LiteLLMAdapter(
         api_key=api_key,

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/tests/unit/providers/test_claude_code_adapter.py

@@ -293,3 +293,66 @@ class TestExecuteSingleRequestSystemPrompt:
 
         options_call_kwargs = mock_options_cls.call_args.kwargs
         assert "output_format" not in options_call_kwargs
+
+    @pytest.mark.asyncio
+    async def test_default_tool_policy_omits_allowed_tools_and_uses_configured_cwd(self) -> None:
+        """Default Claude adapters should not force a blanket no-tools policy."""
+        adapter = ClaudeCodeAdapter(cwd="/tmp/project")
+        config = CompletionConfig(model="claude-sonnet-4-6")
+
+        mock_options_cls = MagicMock()
+
+        async def fake_query(*args, **kwargs):
+            msg = MagicMock()
+            type(msg).__name__ = "ResultMessage"
+            msg.structured_output = None
+            msg.result = "test response"
+            msg.is_error = False
+            yield msg
+
+        sdk_module = _make_sdk_mock(mock_options_cls, MagicMock(side_effect=fake_query))
+
+        with patch.dict(
+            "sys.modules",
+            {
+                "claude_agent_sdk": sdk_module,
+                "claude_agent_sdk._errors": sdk_module._errors,
+            },
+        ):
+            await adapter._execute_single_request("test prompt", config)
+
+        options_call_kwargs = mock_options_cls.call_args.kwargs
+        assert "allowed_tools" not in options_call_kwargs
+        assert options_call_kwargs["cwd"] == "/tmp/project"
+        assert "Write" in options_call_kwargs["disallowed_tools"]
+
+    @pytest.mark.asyncio
+    async def test_explicit_empty_allowed_tools_blocks_all_sdk_tools(self) -> None:
+        """An explicit empty list keeps the strict no-tools interview policy."""
+        adapter = ClaudeCodeAdapter(allowed_tools=[])
+        config = CompletionConfig(model="claude-sonnet-4-6")
+
+        mock_options_cls = MagicMock()
+
+        async def fake_query(*args, **kwargs):
+            msg = MagicMock()
+            type(msg).__name__ = "ResultMessage"
+            msg.structured_output = None
+            msg.result = "test response"
+            msg.is_error = False
+            yield msg
+
+        sdk_module = _make_sdk_mock(mock_options_cls, MagicMock(side_effect=fake_query))
+
+        with patch.dict(
+            "sys.modules",
+            {
+                "claude_agent_sdk": sdk_module,
+                "claude_agent_sdk._errors": sdk_module._errors,
+            },
+        ):
+            await adapter._execute_single_request("test prompt", config)
+
+        options_call_kwargs = mock_options_cls.call_args.kwargs
+        assert options_call_kwargs["allowed_tools"] == []
+        assert "Read" in options_call_kwargs["disallowed_tools"]

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/tests/unit/providers/test_codex_cli_adapter.py

@@ -132,6 +132,26 @@ class TestCodexCliLLMAdapter:
         assert "## Execution Budget" in prompt
         assert "5 tool-assisted turns" in prompt
 
+    def test_build_prompt_omits_tool_constraints_when_tools_unspecified(self) -> None:
+        """Default adapters keep tool policy unspecified for non-interview flows."""
+        adapter = CodexCliLLMAdapter(cli_path="codex")
+
+        prompt = adapter._build_prompt([Message(role=MessageRole.USER, content="Summarize this.")])
+
+        assert "## Tool Constraints" not in prompt
+        assert "Do NOT use any tools or MCP calls" not in prompt
+
+    def test_build_prompt_explicit_empty_tools_forbids_tool_use(self) -> None:
+        """An explicit empty tool list requests a text-only response."""
+        adapter = CodexCliLLMAdapter(cli_path="codex", allowed_tools=[], max_turns=5)
+
+        prompt = adapter._build_prompt([Message(role=MessageRole.USER, content="Summarize this.")])
+
+        assert "## Tool Constraints" in prompt
+        assert "Do NOT use any tools or MCP calls" in prompt
+        assert "tool-assisted turns" not in prompt
+        assert "avoid turning this into a multi-step tool workflow" in prompt
+
     def test_normalize_model_omits_default_sentinel(self) -> None:
         """The backend-safe default sentinel is translated to no explicit model."""
         adapter = CodexCliLLMAdapter(cli_path="codex")

{ouroboros_ai-0.26.5.dev7 → ouroboros_ai-0.26.5.dev8}/tests/unit/providers/test_factory.py

@@ -1,5 +1,8 @@
 """Unit tests for provider factory helpers."""
 
+import builtins
+import sys
+
 import pytest
 
 from ouroboros.providers.claude_code_adapter import ClaudeCodeAdapter
@@ -63,11 +66,43 @@ class TestCreateLLMAdapter:
         adapter = create_llm_adapter(backend="claude_code")
         assert isinstance(adapter, ClaudeCodeAdapter)
 
+    def test_passes_timeout_to_claude_code_adapter(self) -> None:
+        """Claude backend forwards application-level timeout to the adapter."""
+        adapter = create_llm_adapter(backend="claude_code", timeout=42.0)
+        assert isinstance(adapter, ClaudeCodeAdapter)
+        assert adapter._timeout == 42.0
+
+    def test_passes_cwd_to_claude_code_adapter(self) -> None:
+        """Claude backend forwards cwd to the SDK adapter."""
+        adapter = create_llm_adapter(backend="claude_code", cwd="/tmp/project")
+        assert isinstance(adapter, ClaudeCodeAdapter)
+        assert adapter._cwd == "/tmp/project"
+
     def test_creates_litellm_adapter(self) -> None:
         """LiteLLM backend returns LiteLLMAdapter."""
         adapter = create_llm_adapter(backend="litellm")
         assert isinstance(adapter, LiteLLMAdapter)
 
+    def test_litellm_import_error_raises_runtime_error(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Missing litellm dependency raises a helpful RuntimeError."""
+        module_name = "ouroboros.providers.litellm_adapter"
+        real_import = builtins.__import__
+
+        def fake_import(name, globals=None, locals=None, fromlist=(), level=0):  # type: ignore[no-untyped-def]
+            if name == module_name:
+                raise ImportError("No module named 'litellm'")
+            return real_import(name, globals, locals, fromlist, level)
+
+        monkeypatch.delitem(sys.modules, module_name, raising=False)
+        monkeypatch.setattr(builtins, "__import__", fake_import)
+
+        with pytest.raises(
+            RuntimeError, match="litellm backend requested but litellm is not installed"
+        ):
+            create_llm_adapter(backend="litellm")
+
     def test_creates_codex_adapter(self) -> None:
         """Codex backend returns CodexCliLLMAdapter."""
         adapter = create_llm_adapter(backend="codex", cwd="/tmp/project")