zwarm 2.3.5__py3-none-any.whl → 3.6.0__py3-none-any.whl

zwarm/tools/delegation.py

@@ -2,13 +2,17 @@
 Delegation tools for the orchestrator.
 
 These are the core tools that orchestrators use to delegate work to executors.
-They use the SAME CodexSessionManager that `zwarm interactive` uses - no special
+They use the same session managers that `zwarm interactive` uses - no special
 MCP integration, no separate code path.
 
 The orchestrator LLM has access to the exact same tools a human would use.
 
+Supports multiple adapters:
+- codex: OpenAI's Codex CLI (default)
+- claude: Anthropic's Claude Code CLI
+
 Tools:
-- delegate: Start a new codex session
+- delegate: Start a new session (with adapter selection)
 - converse: Continue a conversation (inject follow-up message)
 - check_session: Check status of a session
 - end_session: End/kill a session
@@ -19,60 +23,58 @@ from __future__ import annotations
 
 import time
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any
 
 from wbal.helper import weaveTool
 
 if TYPE_CHECKING:
     from zwarm.orchestrator import Orchestrator
 
+# Available adapters
+ADAPTERS = ["codex", "claude"]
+
 
 def _get_session_manager(orchestrator: "Orchestrator"):
     """
-    Get the CodexSessionManager - the SINGLE source of truth for sessions.
-
-    Both `zwarm interactive` and `zwarm orchestrate` use the same session manager.
-    The orchestrator is just another user that happens to be an LLM.
+    Get the default session manager for list/get operations.
 
-    The session manager is created eagerly in Orchestrator.model_post_init()
-    and shared with the environment for observe() visibility.
+    Uses CodexSessionManager as the default since all adapters share
+    the same .zwarm/sessions/ directory structure.
     """
-    # Should already exist from model_post_init, but create if not
     if not hasattr(orchestrator, "_session_manager") or orchestrator._session_manager is None:
         from zwarm.sessions import CodexSessionManager
         orchestrator._session_manager = CodexSessionManager(orchestrator.working_dir / ".zwarm")
     return orchestrator._session_manager
 
 
-def _wait_for_completion(manager, session_id: str, timeout: float = 300.0, poll_interval: float = 1.0) -> bool:
+def _get_adapter_manager(orchestrator: "Orchestrator", adapter: str):
     """
-    Wait for a session to complete.
+    Get the session manager for a specific adapter.
+
+    Each adapter has its own manager for start_session/inject_message,
+    but they all share the same .zwarm/sessions/ directory.
 
     Args:
-        manager: CodexSessionManager
-        session_id: Session to wait for
-        timeout: Max seconds to wait
-        poll_interval: Seconds between polls
+        orchestrator: The orchestrator instance
+        adapter: Adapter name ("codex" or "claude")
 
     Returns:
-        True if completed, False if timed out
+        Session manager for the specified adapter
     """
-    from zwarm.sessions import SessionStatus
+    # Initialize adapter managers dict if needed
+    if not hasattr(orchestrator, "_adapter_managers"):
+        orchestrator._adapter_managers = {}
 
-    start = time.time()
-    while time.time() - start < timeout:
-        # get_session() auto-updates status based on output completion markers
-        session = manager.get_session(session_id)
-        if not session:
-            return False
+    # Return cached manager if exists
+    if adapter in orchestrator._adapter_managers:
+        return orchestrator._adapter_managers[adapter]
 
-        # Check status (not is_running - PID check is unreliable due to reuse)
-        if session.status in (SessionStatus.COMPLETED, SessionStatus.FAILED, SessionStatus.KILLED):
-            return True
+    # Create new manager for this adapter
+    from zwarm.sessions import get_session_manager
+    manager = get_session_manager(adapter, str(orchestrator.working_dir / ".zwarm"))
+    orchestrator._adapter_managers[adapter] = manager
 
-        time.sleep(poll_interval)
-
-    return False
+    return manager
 
 
 def _truncate(text: str, max_len: int = 200) -> str:
@@ -84,7 +86,8 @@ def _truncate(text: str, max_len: int = 200) -> str:
 
 def _format_session_header(session) -> str:
     """Format a nice session header."""
-    return f"[{session.short_id}] codex ({session.status.value})"
+    adapter = getattr(session, "adapter", "codex")
+    return f"[{session.short_id}] {adapter} ({session.status.value})"
 
 
 def _get_total_tokens(session) -> int:
@@ -158,36 +161,49 @@ def _validate_working_dir(
 def delegate(
     self: "Orchestrator",
     task: str,
-    mode: Literal["sync", "async"] = "sync",
     model: str | None = None,
     working_dir: str | None = None,
+    adapter: str = "codex",
 ) -> dict[str, Any]:
     """
-    Delegate work to a Codex agent.
+    Delegate work to an executor agent.
 
-    This spawns a codex session - the exact same way `zwarm interactive` does.
-    Two modes available:
+    Supports multiple adapters:
+    - codex: OpenAI's Codex CLI (default, fast, good for code tasks)
+    - claude: Claude Code CLI (powerful, good for complex reasoning)
 
-    **sync** (default): Wait for codex to complete, then return the response.
-    Best for: most tasks - you get the full response immediately.
+    All sessions run async - you get a session_id immediately and poll for results.
 
-    **async**: Fire-and-forget execution.
-    Check progress later with check_session().
-    Best for: long-running tasks, parallel work.
+    Workflow pattern:
+        1. delegate(task="Add logout button") -> session_id
+        2. sleep(30) -> give it time
+        3. peek_session(session_id) -> check if done
+        4. Repeat 2-3 if still running
+        5. check_session(session_id) -> get full results
 
     Args:
         task: Clear description of what to do. Be specific about requirements.
-        mode: "sync" to wait for completion, "async" for fire-and-forget.
-        model: Model override (default: gpt-5.1-codex-mini).
-        working_dir: Directory for codex to work in (default: orchestrator's dir).
+        model: Model override (codex: gpt-5.1-codex-mini, claude: sonnet).
+        working_dir: Directory for executor to work in (default: orchestrator's dir).
+        adapter: Which executor to use - "codex" (default) or "claude".
 
     Returns:
-        {session_id, status, response (if sync)}
+        {session_id, status: "running", task, adapter, hint}
 
-    Example:
-        delegate(task="Add a logout button to the navbar", mode="sync")
-        # Then use converse() to refine: "Also add a confirmation dialog"
+    Example with codex (default):
+        delegate(task="Add a logout button to the navbar")
+
+    Example with claude for complex tasks:
+        delegate(task="Refactor the auth system to use OAuth2", adapter="claude")
     """
+    # Validate adapter
+    if adapter not in ADAPTERS:
+        return {
+            "success": False,
+            "error": f"Unknown adapter: {adapter}. Available: {ADAPTERS}",
+            "hint": f"Use one of: {ADAPTERS}",
+        }
+
     # Validate working directory
     effective_dir, dir_error = _validate_working_dir(
         working_dir,
@@ -202,94 +218,41 @@ def delegate(
             "hint": "Use the default working directory or ask user to update allowed_dirs config",
         }
 
-    # Get the session manager (same one zwarm interactive uses)
-    manager = _get_session_manager(self)
+    # Get the session manager for this adapter
+    manager = _get_adapter_manager(self, adapter)
 
-    # Determine model
-    effective_model = model or self.config.executor.model or "gpt-5.1-codex-mini"
+    # Determine model (defaults vary by adapter)
+    if model:
+        effective_model = model
+    elif self.config.executor.model:
+        effective_model = self.config.executor.model
+    else:
+        # Use adapter-specific defaults
+        effective_model = manager.default_model
 
     # Determine sandbox mode
     sandbox = self.config.executor.sandbox or "workspace-write"
 
-    # Start the session using CodexSessionManager
-    # This is the SAME method that `zwarm interactive` uses
+    # Start the session
     session = manager.start_session(
         task=task,
         working_dir=effective_dir,
         model=effective_model,
         sandbox=sandbox,
         source=f"orchestrator:{self.instance_id or 'default'}",
-        adapter="codex",
     )
 
-    # For sync mode, wait for completion
-    if mode == "sync":
-        completed = _wait_for_completion(
-            manager,
-            session.id,
-            timeout=self.config.executor.timeout or 300.0,
-        )
-
-        # Refresh session to get updated status and messages
-        session = manager.get_session(session.id)
-
-        if not completed:
-            return {
-                "success": False,
-                "session_id": session.id,
-                "status": "timeout",
-                "error": "Session timed out waiting for codex to complete",
-                "hint": "Use check_session() to monitor progress, or use async mode for long tasks",
-            }
-
-        # Get the response from messages
-        response_text = ""
-        messages = manager.get_messages(session.id)
-        for msg in messages:
-            if msg.role == "assistant":
-                response_text = msg.content
-                break  # Take first assistant message
-
-        # Build log path for debugging
-        log_path = str(manager._output_path(session.id, session.turn))
-
-        # Check if session failed
-        from zwarm.sessions import SessionStatus
-        if session.status == SessionStatus.FAILED:
-            return {
-                "success": False,
-                "session": _format_session_header(session),
-                "session_id": session.id,
-                "status": "failed",
-                "task": _truncate(task, 100),
-                "error": session.error or "Unknown error",
-                "response": response_text or "(no response captured)",
-                "tokens": _get_total_tokens(session),
-                "log_file": log_path,
-                "hint": "Check log_file for raw codex output. Use bash('cat <log_file>') to inspect.",
-            }
-
-        return {
-            "success": True,
-            "session": _format_session_header(session),
-            "session_id": session.id,
-            "status": session.status.value,
-            "task": _truncate(task, 100),
-            "response": response_text or "(no response captured)",
-            "tokens": _get_total_tokens(session),
-            "log_file": log_path,
-            "hint": "Use converse(session_id, message) to send follow-up messages",
-        }
-    else:
-        # Async mode - return immediately
-        return {
-            "success": True,
-            "session": _format_session_header(session),
-            "session_id": session.id,
-            "status": "running",
-            "task": _truncate(task, 100),
-            "hint": "Use check_session(session_id) to monitor progress",
-        }
+    # Return immediately - session runs in background
+    return {
+        "success": True,
+        "session": _format_session_header(session),
+        "session_id": session.id,
+        "status": "running",
+        "task": _truncate(task, 100),
+        "adapter": adapter,
+        "model": effective_model,
+        "hint": "Use sleep() then check_session(session_id) to monitor progress",
+    }
 
 
 @weaveTool
@@ -297,41 +260,33 @@ def converse(
     self: "Orchestrator",
     session_id: str,
     message: str,
-    wait: bool = True,
 ) -> dict[str, Any]:
     """
-    Continue a conversation with a codex session.
+    Continue a conversation with a session.
 
     This injects a follow-up message into the session, providing the
     conversation history as context. Like chatting with a developer.
+    Returns immediately - use sleep() + check_session() to poll for the response.
 
-    Two modes:
-    - **wait=True** (default): Wait for codex to respond before returning.
-    - **wait=False**: Fire-and-forget. Message sent, codex runs in background.
-      Use check_session() later to see the response.
+    Works with any adapter (codex or claude) - automatically uses the
+    correct adapter based on the session's original adapter.
 
     Args:
         session_id: The session to continue (from delegate() result).
-        message: Your next message to codex.
-        wait: If True, wait for response. If False, return immediately.
+        message: Your next message.
 
     Returns:
-        {session_id, response (if wait=True), turn}
+        {session_id, turn, status: "running"}
 
-    Example (sync):
-        result = delegate(task="Add user authentication")
-        converse(session_id=result["session_id"], message="Use JWT")
-        # Returns with response
-
-    Example (async - managing multiple sessions):
-        converse(session_id="abc123", message="Add tests", wait=False)
-        converse(session_id="def456", message="Fix bug", wait=False)
-        # Both running in parallel, check later with check_session()
+    Example:
+        converse(session_id="abc123", message="Add tests")
+        sleep(30)
+        check_session(session_id)  # Get response
     """
-    manager = _get_session_manager(self)
+    # First get session to determine adapter
+    default_manager = _get_session_manager(self)
+    session = default_manager.get_session(session_id)
 
-    # Get current session
-    session = manager.get_session(session_id)
     if not session:
         return {
             "success": False,
@@ -355,8 +310,12 @@ def converse(
             "hint": "Start a new session with delegate()",
         }
 
+    # Get the correct adapter manager for this session
+    adapter = getattr(session, "adapter", "codex")
+    manager = _get_adapter_manager(self, adapter)
+
     # Inject the follow-up message
-    # This uses CodexSessionManager.inject_message() which:
+    # This uses the adapter's inject_message() which:
     # 1. Builds context from previous messages
     # 2. Starts a new turn with the context + new message (background process)
     updated_session = manager.inject_message(session_id, message)
@@ -368,53 +327,16 @@ def converse(
             "session_id": session_id,
         }
 
-    if not wait:
-        # Async mode - return immediately
-        return {
-            "success": True,
-            "session": _format_session_header(updated_session),
-            "session_id": session_id,
-            "turn": updated_session.turn,
-            "status": "running",
-            "you_said": _truncate(message, 100),
-            "hint": "Use check_session(session_id) to see the response when ready",
-        }
-
-    # Sync mode - wait for completion
-    completed = _wait_for_completion(
-        manager,
-        session_id,
-        timeout=self.config.executor.timeout or 300.0,
-    )
-
-    # Refresh session
-    session = manager.get_session(session_id)
-
-    if not completed:
-        return {
-            "success": False,
-            "session_id": session_id,
-            "status": "timeout",
-            "error": "Session timed out waiting for response",
-            "hint": "Use check_session() to monitor progress",
-        }
-
-    # Get the response (last assistant message)
-    response_text = ""
-    messages = manager.get_messages(session_id)
-    for msg in reversed(messages):
-        if msg.role == "assistant":
-            response_text = msg.content
-            break
-
+    # Return immediately - session runs in background
     return {
         "success": True,
-        "session": _format_session_header(session),
+        "session": _format_session_header(updated_session),
         "session_id": session_id,
-        "turn": session.turn,
+        "turn": updated_session.turn,
+        "status": "running",
+        "adapter": adapter,
         "you_said": _truncate(message, 100),
-        "response": response_text or "(no response captured)",
-        "tokens": _get_total_tokens(session),
+        "hint": "Use sleep() then check_session(session_id) to see the response",
     }
 
 
@@ -782,3 +704,44 @@ def list_sessions(
         "filter": status or "all",
         "hint": "Sessions with needs_attention=True have new responses to review" if needs_attention_count else None,
     }
+
+
+@weaveTool
+def sleep(self, seconds: float) -> dict[str, Any]:
+    """
+    Sleep for a specified number of seconds.
+
+    Use this when you've started async sessions (wait=False) and want to
+    give them time to complete before checking their status. This lets you
+    manage your own polling loop:
+
+    1. delegate(task, wait=False) -> start background work
+    2. sleep(10) -> wait a bit
+    3. peek_session(id) -> check if done
+    4. Repeat 2-3 if still running
+
+    Args:
+        seconds: Number of seconds to sleep (max 300 = 5 minutes)
+
+    Returns:
+        Dict with success status and actual sleep duration
+    """
+    # Cap at 5 minutes to prevent accidental long hangs
+    max_sleep = 300.0
+    actual_seconds = min(float(seconds), max_sleep)
+
+    if actual_seconds <= 0:
+        return {
+            "success": False,
+            "error": "Sleep duration must be positive",
+            "requested": seconds,
+        }
+
+    time.sleep(actual_seconds)
+
+    return {
+        "success": True,
+        "slept_seconds": actual_seconds,
+        "capped": actual_seconds < seconds,
+        "max_allowed": max_sleep if actual_seconds < seconds else None,
+    }