zwarm 1.1.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

zwarm/adapters/__init__.py

@@ -0,0 +1,21 @@
+"""
+Adapters: Executor wrappers for CLI coding agents.
+
+Adapters provide a unified interface to different coding CLIs (Codex, Claude Code).
+Use the registry to discover and instantiate adapters by name.
+"""
+
+from zwarm.adapters.base import ExecutorAdapter
+from zwarm.adapters.registry import register_adapter, get_adapter, list_adapters, adapter_exists
+
+# Import built-in adapters to register them
+from zwarm.adapters import codex_mcp as _codex_mcp  # noqa: F401
+from zwarm.adapters import claude_code as _claude_code  # noqa: F401
+
+__all__ = [
+    "ExecutorAdapter",
+    "register_adapter",
+    "get_adapter",
+    "list_adapters",
+    "adapter_exists",
+]

zwarm/adapters/claude_code.py

@@ -18,6 +18,7 @@ from typing import Any, Literal
 import weave
 
 from zwarm.adapters.base import ExecutorAdapter
+from zwarm.adapters.registry import register_adapter
 from zwarm.core.models import (
     ConversationSession,
     SessionMode,
@@ -25,14 +26,13 @@ from zwarm.core.models import (
 )
 
 
+@register_adapter("claude_code")
 class ClaudeCodeAdapter(ExecutorAdapter):
     """
     Claude Code adapter using the claude CLI.
 
     Supports both sync (conversational) and async (fire-and-forget) modes.
     """
-
-    name = "claude_code"
     DEFAULT_MODEL = "claude-sonnet-4-5-20250514"  # Best balance of speed and capability
 
     def __init__(self, model: str | None = None):
@@ -186,6 +186,7 @@ class ClaudeCodeAdapter(ExecutorAdapter):
             "exit_code": result.returncode,
         }
 
+    @weave.op()
     async def start_session(
         self,
         task: str,
@@ -195,7 +196,7 @@ class ClaudeCodeAdapter(ExecutorAdapter):
         permission_mode: str = "bypassPermissions",
         **kwargs,
     ) -> ConversationSession:
-        """Start a Claude Code session."""
+        """Start a Claude Code session (sync or async mode)."""
         session = ConversationSession(
             adapter=self.name,
             mode=SessionMode(mode),
@@ -277,6 +278,7 @@ class ClaudeCodeAdapter(ExecutorAdapter):
 
         return response_text
 
+    @weave.op()
     async def check_status(
         self,
         session: ConversationSession,

zwarm/adapters/codex_mcp.py

@@ -20,6 +20,7 @@ from typing import Any, Literal
 import weave
 
 from zwarm.adapters.base import ExecutorAdapter
+from zwarm.adapters.registry import register_adapter
 from zwarm.core.models import (
     ConversationSession,
     SessionMode,
@@ -450,6 +451,7 @@ class MCPClient:
         return self._proc is not None and self._proc.poll() is None
 
 
+@register_adapter("codex_mcp")
 class CodexMCPAdapter(ExecutorAdapter):
     """
     Codex adapter using MCP server for sync conversations.
@@ -458,8 +460,6 @@ class CodexMCPAdapter(ExecutorAdapter):
     The MCP client uses subprocess.Popen (not asyncio) so it persists across
     multiple asyncio.run() calls, preserving conversation state.
     """
-
-    name = "codex_mcp"
     DEFAULT_MODEL = "gpt-5.1-codex-mini"  # Default codex model
 
     def __init__(self, model: str | None = None):
@@ -549,22 +549,36 @@ class CodexMCPAdapter(ExecutorAdapter):
         """
         client = self._ensure_client()
 
+        logger.debug(f"Calling codex-reply with conversation_id={conversation_id}")
+
         result = client.call_tool("codex-reply", {
             "conversationId": conversation_id,
             "prompt": message,
         })
 
+        # Check for conversation loss - MCP returns empty result when session not found
+        if not result.get("messages") and not result.get("output"):
+            logger.error(
+                f"codex-reply returned empty result for conversation_id={conversation_id}. "
+                f"The MCP server may have lost the conversation state. Result: {result}"
+            )
+
         # Track usage
         usage = result.get("usage", {})
         self._accumulate_usage(usage)
 
+        response = self._extract_response(result)
+        logger.debug(f"codex-reply response length: {len(response)} chars")
+
         return {
-            "response": self._extract_response(result),
+            "response": response,
             "raw_messages": result.get("messages", []),
             "usage": usage,
             "total_usage": self.total_usage,
+            "conversation_lost": not result.get("messages") and not result.get("output"),
         }
 
+    @weave.op()
     async def start_session(
         self,
         task: str,
@@ -574,7 +588,7 @@ class CodexMCPAdapter(ExecutorAdapter):
         sandbox: str = "workspace-write",
         **kwargs,
     ) -> ConversationSession:
-        """Start a Codex session."""
+        """Start a Codex session (sync or async mode)."""
         effective_model = model or self._model
         session = ConversationSession(
             adapter=self.name,
@@ -597,6 +611,13 @@ class CodexMCPAdapter(ExecutorAdapter):
             session.conversation_id = result["conversation_id"]
             if session.conversation_id:
                 self._sessions[session.id] = session.conversation_id
+                logger.debug(f"Session {session.id[:8]} mapped to conversation {session.conversation_id}")
+            else:
+                # This is bad - we won't be able to continue this conversation
+                logger.warning(
+                    f"Session {session.id[:8]} started but MCP didn't return a conversation ID. "
+                    "Further converse() calls will fail."
+                )
 
             session.add_message("user", task)
             session.add_message("assistant", result["response"])
@@ -606,15 +627,18 @@ class CodexMCPAdapter(ExecutorAdapter):
 
         else:
             # Async mode: use codex exec (fire-and-forget)
-            # This runs in a subprocess without MCP
+            # This runs in a subprocess without MCP, outputs JSONL events
             cmd = [
                 "codex", "exec",
                 "--dangerously-bypass-approvals-and-sandbox",
                 "--skip-git-repo-check",
                 "--json",
                 "--model", effective_model,
+                "-C", str(working_dir.absolute()),  # Explicit working directory
+                "--", task,
             ]
-            cmd.extend(["--", task])
+
+            logger.info(f"Starting async codex: {' '.join(cmd[:8])}...")
 
             proc = subprocess.Popen(
                 cmd,
@@ -648,6 +672,16 @@ class CodexMCPAdapter(ExecutorAdapter):
         )
 
         response_text = result["response"]
+
+        # Check if conversation was lost
+        if result.get("conversation_lost"):
+            logger.warning(
+                f"Conversation {session.conversation_id} was lost. "
+                f"Session {session.id} will be marked as needing re-delegation."
+            )
+            # Mark the session as having a lost conversation so orchestrator can handle it
+            session.conversation_id = None  # Clear the stale ID
+
         session.add_message("user", message)
         session.add_message("assistant", response_text)
 
@@ -656,6 +690,54 @@ class CodexMCPAdapter(ExecutorAdapter):
 
         return response_text
 
+    @weave.op()
+    def _parse_jsonl_output(self, stdout: str) -> dict[str, Any]:
+        """
+        Parse JSONL output from codex exec --json.
+
+        Returns dict with:
+        - response: The agent's message text
+        - usage: Token usage stats
+        - thread_id: The conversation thread ID
+        - events: All parsed events (for debugging)
+        """
+        response_parts = []
+        usage = {}
+        thread_id = None
+        events = []
+
+        for line in stdout.strip().split("\n"):
+            if not line.strip():
+                continue
+            try:
+                event = json.loads(line)
+                events.append(event)
+
+                event_type = event.get("type", "")
+
+                if event_type == "thread.started":
+                    thread_id = event.get("thread_id")
+
+                elif event_type == "item.completed":
+                    item = event.get("item", {})
+                    if item.get("type") == "agent_message":
+                        response_parts.append(item.get("text", ""))
+
+                elif event_type == "turn.completed":
+                    usage = event.get("usage", {})
+
+            except json.JSONDecodeError:
+                logger.warning(f"Failed to parse JSONL line: {line[:100]}")
+                continue
+
+        return {
+            "response": "\n".join(response_parts),
+            "usage": usage,
+            "thread_id": thread_id,
+            "events": events,
+        }
+
+    @weave.op()
     async def check_status(
         self,
         session: ConversationSession,
@@ -672,14 +754,50 @@ class CodexMCPAdapter(ExecutorAdapter):
         if poll is None:
             return {"status": "running"}
 
-        # Process finished
+        # Process finished - parse the JSONL output
         stdout, stderr = session.process.communicate()
+
         if poll == 0:
-            session.complete(stdout[:1000] if stdout else "Completed")
-            return {"status": "completed", "output": stdout}
+            # Parse JSONL to extract actual response
+            parsed = self._parse_jsonl_output(stdout)
+            response_text = parsed["response"] or "(no response captured)"
+
+            # Add the response as a message
+            session.add_message("assistant", response_text)
+
+            # Track token usage
+            if parsed["usage"]:
+                session.add_usage({
+                    "input_tokens": parsed["usage"].get("input_tokens", 0),
+                    "output_tokens": parsed["usage"].get("output_tokens", 0),
+                    "total_tokens": (
+                        parsed["usage"].get("input_tokens", 0) +
+                        parsed["usage"].get("output_tokens", 0)
+                    ),
+                })
+
+            session.complete(response_text[:500])
+            return {
+                "status": "completed",
+                "response": response_text,
+                "usage": parsed["usage"],
+                "thread_id": parsed["thread_id"],
+            }
         else:
-            session.fail(stderr[:1000] if stderr else f"Exit code: {poll}")
-            return {"status": "failed", "error": stderr, "exit_code": poll}
+            # Try to parse stderr or stdout for error info
+            error_msg = stderr.strip() if stderr else f"Exit code: {poll}"
+
+            # Sometimes errors come through stdout as JSONL too
+            if stdout and not stderr:
+                try:
+                    parsed = self._parse_jsonl_output(stdout)
+                    if not parsed["response"]:
+                        error_msg = f"Process failed with no response. Exit code: {poll}"
+                except Exception:
+                    error_msg = stdout[:500] if stdout else f"Exit code: {poll}"
+
+            session.fail(error_msg[:500])
+            return {"status": "failed", "error": error_msg, "exit_code": poll}
 
     async def stop(
         self,
@@ -709,6 +827,15 @@ class CodexMCPAdapter(ExecutorAdapter):
 
     def _extract_response(self, result: dict) -> str:
         """Extract response text from MCP result."""
+        # Check for error indicators - empty result suggests lost conversation
+        if (
+            result.get("conversationId") is None
+            and not result.get("messages")
+            and not result.get("output")
+        ):
+            logger.warning(f"MCP returned empty result - conversation may be lost: {result}")
+            return "[ERROR] Conversation lost - the MCP server no longer has this session. Please re-delegate the task."
+
         # First check for our collected output
         if result.get("output"):
             return result["output"]
@@ -735,5 +862,6 @@ class CodexMCPAdapter(ExecutorAdapter):
         if "text" in result:
             return result["text"]
 
-        # Fallback: stringify the result
+        # Fallback: stringify the result (but log it as unexpected)
+        logger.warning(f"Unexpected MCP result format, returning raw: {list(result.keys())}")
         return json.dumps(result, indent=2)

zwarm/adapters/registry.py

@@ -0,0 +1,69 @@
+"""
+Adapter registry for discovering and instantiating executor adapters.
+
+This follows the same pattern as the watcher registry, enabling:
+- Easy addition of new adapters without modifying orchestrator code
+- Runtime discovery of available adapters
+- Consistent instantiation across CLI and orchestrator
+"""
+
+from __future__ import annotations
+
+from typing import Any, Type
+
+from zwarm.adapters.base import ExecutorAdapter
+
+
+# Global adapter registry
+_ADAPTERS: dict[str, Type[ExecutorAdapter]] = {}
+
+
+def register_adapter(name: str):
+    """
+    Decorator to register an adapter class.
+
+    Example:
+        @register_adapter("codex_mcp")
+        class CodexMCPAdapter(ExecutorAdapter):
+            ...
+    """
+
+    def decorator(cls: Type[ExecutorAdapter]) -> Type[ExecutorAdapter]:
+        cls.name = name
+        _ADAPTERS[name] = cls
+        return cls
+
+    return decorator
+
+
+def get_adapter(name: str, model: str | None = None, **kwargs: Any) -> ExecutorAdapter:
+    """
+    Get an adapter instance by name.
+
+    Args:
+        name: Registered adapter name (e.g., "codex_mcp", "claude_code")
+        model: Optional model override to pass to adapter
+        **kwargs: Additional kwargs passed to adapter constructor
+
+    Returns:
+        Instantiated adapter
+
+    Raises:
+        ValueError: If adapter not found
+    """
+    if name not in _ADAPTERS:
+        available = list(_ADAPTERS.keys())
+        raise ValueError(
+            f"Unknown adapter: {name}. Available: {available}"
+        )
+    return _ADAPTERS[name](model=model, **kwargs)
+
+
+def list_adapters() -> list[str]:
+    """List all registered adapter names."""
+    return list(_ADAPTERS.keys())
+
+
+def adapter_exists(name: str) -> bool:
+    """Check if an adapter is registered."""
+    return name in _ADAPTERS

zwarm/adapters/test_codex_mcp.py

@@ -177,6 +177,56 @@ class TestCodexMCPAdapter:
         response = adapter._extract_response(result)
         assert "unknown" in response
 
+    def test_parse_jsonl_output(self, adapter):
+        """Test parsing JSONL output from codex exec --json."""
+        jsonl_output = """{"type":"thread.started","thread_id":"abc123"}
+{"type":"turn.started"}
+{"type":"item.completed","item":{"id":"item_0","type":"reasoning","text":"Thinking..."}}
+{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"The answer is 4"}}
+{"type":"turn.completed","usage":{"input_tokens":100,"output_tokens":10}}"""
+
+        parsed = adapter._parse_jsonl_output(jsonl_output)
+
+        assert parsed["response"] == "The answer is 4"
+        assert parsed["thread_id"] == "abc123"
+        assert parsed["usage"]["input_tokens"] == 100
+        assert parsed["usage"]["output_tokens"] == 10
+        assert len(parsed["events"]) == 5
+
+    def test_parse_jsonl_output_multiple_messages(self, adapter):
+        """Test parsing JSONL with multiple agent messages."""
+        jsonl_output = """{"type":"thread.started","thread_id":"xyz"}
+{"type":"item.completed","item":{"type":"agent_message","text":"First part"}}
+{"type":"item.completed","item":{"type":"agent_message","text":"Second part"}}
+{"type":"turn.completed","usage":{"input_tokens":50,"output_tokens":20}}"""
+
+        parsed = adapter._parse_jsonl_output(jsonl_output)
+
+        assert parsed["response"] == "First part\nSecond part"
+        assert parsed["thread_id"] == "xyz"
+
+    def test_parse_jsonl_output_empty(self, adapter):
+        """Test parsing empty JSONL output."""
+        parsed = adapter._parse_jsonl_output("")
+        assert parsed["response"] == ""
+        assert parsed["usage"] == {}
+        assert parsed["thread_id"] is None
+
+    def test_parse_jsonl_output_malformed_lines(self, adapter):
+        """Test parsing JSONL with some malformed lines."""
+        jsonl_output = """{"type":"thread.started","thread_id":"test123"}
+not valid json
+{"type":"item.completed","item":{"type":"agent_message","text":"Valid response"}}
+also not json
+{"type":"turn.completed","usage":{"input_tokens":10,"output_tokens":5}}"""
+
+        parsed = adapter._parse_jsonl_output(jsonl_output)
+
+        # Should still extract valid data
+        assert parsed["response"] == "Valid response"
+        assert parsed["thread_id"] == "test123"
+        assert len(parsed["events"]) == 3  # Only valid JSON lines
+
 
 @pytest.mark.integration
 class TestCodexMCPIntegration:

zwarm/adapters/test_registry.py

@@ -0,0 +1,68 @@
+"""Tests for the adapter registry."""
+
+import pytest
+
+from zwarm.adapters import (
+    get_adapter,
+    list_adapters,
+    adapter_exists,
+    ExecutorAdapter,
+)
+
+
+class TestAdapterRegistry:
+    """Test adapter registration and retrieval."""
+
+    def test_list_adapters_includes_builtins(self):
+        """Built-in adapters are registered on import."""
+        adapters = list_adapters()
+        assert "codex_mcp" in adapters
+        assert "claude_code" in adapters
+
+    def test_get_adapter_codex(self):
+        """Can retrieve codex adapter by name."""
+        adapter = get_adapter("codex_mcp")
+        assert isinstance(adapter, ExecutorAdapter)
+        assert adapter.name == "codex_mcp"
+
+    def test_get_adapter_claude(self):
+        """Can retrieve claude adapter by name."""
+        adapter = get_adapter("claude_code")
+        assert isinstance(adapter, ExecutorAdapter)
+        assert adapter.name == "claude_code"
+
+    def test_get_adapter_with_model(self):
+        """Model parameter is passed to adapter."""
+        adapter = get_adapter("codex_mcp", model="custom-model")
+        # The model should be set (adapters store it as _model)
+        assert adapter._model == "custom-model"
+
+    def test_get_unknown_adapter(self):
+        """Unknown adapter raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            get_adapter("nonexistent_adapter")
+        assert "Unknown adapter" in str(exc_info.value)
+        assert "nonexistent_adapter" in str(exc_info.value)
+
+    def test_adapter_exists(self):
+        """adapter_exists returns correct boolean."""
+        assert adapter_exists("codex_mcp") is True
+        assert adapter_exists("claude_code") is True
+        assert adapter_exists("nonexistent") is False
+
+
+class TestAdapterInstances:
+    """Test that retrieved adapters are independent instances."""
+
+    def test_separate_instances(self):
+        """Each get_adapter call returns a new instance."""
+        adapter1 = get_adapter("codex_mcp")
+        adapter2 = get_adapter("codex_mcp")
+        assert adapter1 is not adapter2
+
+    def test_different_models(self):
+        """Can create adapters with different models."""
+        adapter1 = get_adapter("codex_mcp", model="model-a")
+        adapter2 = get_adapter("codex_mcp", model="model-b")
+        assert adapter1._model == "model-a"
+        assert adapter2._model == "model-b"