Merge branch 'main' into rel-1.7.0

malhotra5 · malhotra5 · commit 1af52f1065ed · 2025-12-29T16:45:11.000-05:00
diff --git a/openhands_cli/acp_impl/agent.py b/openhands_cli/acp_impl/agent.py
@@ -91,12 +91,19 @@ def get_session_mode_state(current_mode: ConfirmationMode) -> SessionModeState:
 class OpenHandsACPAgent(ACPAgent):
     """OpenHands Agent Client Protocol implementation."""
 
-    def __init__(self, conn: Client, initial_confirmation_mode: ConfirmationMode):
+    def __init__(
+        self,
+        conn: Client,
+        initial_confirmation_mode: ConfirmationMode,
+        resume_conversation_id: str | None = None,
+    ):
         """Initialize the OpenHands ACP agent.
 
         Args:
             conn: ACP connection for sending notifications
             initial_confirmation_mode: Default confirmation mode for new sessions
+            resume_conversation_id: Optional conversation ID to resume when a new
+                session is created (used with --resume flag)
         """
         self._conn = conn
         # Cache of active conversations to preserve state (pause, confirmation, etc.)
@@ -106,10 +113,14 @@ def __init__(self, conn: Client, initial_confirmation_mode: ConfirmationMode):
         self._running_tasks: dict[str, asyncio.Task] = {}
         # Default confirmation mode for new sessions
         self._initial_confirmation_mode: ConfirmationMode = initial_confirmation_mode
+        # Conversation ID to resume (from --resume flag)
+        self._resume_conversation_id: str | None = resume_conversation_id
         logger.info(
             f"OpenHands ACP Agent initialized with "
             f"confirmation mode: {initial_confirmation_mode}"
         )
+        if resume_conversation_id:
+            logger.info(f"Will resume conversation: {resume_conversation_id}")
 
     async def _cmd_confirm(self, session_id: str, argument: str) -> str:
         """Handle /confirm command.
@@ -362,8 +373,22 @@ async def new_session(
         mcp_servers: list[Any],
         **_kwargs: Any,
     ) -> NewSessionResponse:
-        """Create a new conversation session."""
-        session_id = str(uuid.uuid4())
+        """Create a new conversation session.
+
+        If --resume was used when starting the ACP server, the first new_session
+        call will use the specified conversation ID instead of generating a new one.
+        When resuming, historic events are replayed to the client.
+        """
+        # Use resume_conversation_id if provided (from --resume flag)
+        # Only use it once, then clear it
+        is_resuming = False
+        if self._resume_conversation_id:
+            session_id = self._resume_conversation_id
+            self._resume_conversation_id = None
+            is_resuming = True
+            logger.info(f"Resuming conversation: {session_id}")
+        else:
+            session_id = str(uuid.uuid4())
 
         try:
             # Convert ACP MCP servers to Agent format
@@ -377,7 +402,7 @@ async def new_session(
 
             # Create conversation and cache it for future operations
             # This reuses the same pattern as openhands --resume
-            _ = self._get_or_create_conversation(
+            conversation = self._get_or_create_conversation(
                 session_id=session_id,
                 working_dir=working_dir,
                 mcp_servers=mcp_servers_dict,
@@ -389,15 +414,27 @@ async def new_session(
             await self._send_available_commands(session_id)
 
             # Get current confirmation mode for this session
-            conversation = self._active_sessions[session_id]
             current_mode = get_confirmation_mode_from_conversation(conversation)
 
-            # Return response with modes
-            return NewSessionResponse(
+            # Build response first (before streaming events)
+            response = NewSessionResponse(
                 session_id=session_id,
                 modes=get_session_mode_state(current_mode),
             )
 
+            # If resuming, replay historic events to the client
+            # This ensures the ACP client sees the full conversation history
+            if is_resuming and conversation.state.events:
+                logger.info(
+                    f"Replaying {len(conversation.state.events)} historic events "
+                    f"for resumed session {session_id}"
+                )
+                subscriber = EventSubscriber(session_id, self._conn)
+                for event in conversation.state.events:
+                    await subscriber(event)
+
+            return response
+
         except MissingAgentSpec as e:
             logger.error(f"Agent not configured: {e}")
             raise RequestError.internal_error(
@@ -695,21 +732,28 @@ async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
 
 async def run_acp_server(
     initial_confirmation_mode: ConfirmationMode = "always-ask",
+    resume_conversation_id: str | None = None,
 ) -> None:
     """Run the OpenHands ACP server.
 
     Args:
         initial_confirmation_mode: Default confirmation mode for new sessions
+        resume_conversation_id: Optional conversation ID to resume when a new
+            session is created
     """
     logger.info(
         f"Starting OpenHands ACP server with confirmation mode: "
         f"{initial_confirmation_mode}..."
     )
+    if resume_conversation_id:
+        logger.info(f"Will resume conversation: {resume_conversation_id}")
 
     reader, writer = await stdio_streams()
 
     def create_agent(conn: Client) -> OpenHandsACPAgent:
-        return OpenHandsACPAgent(conn, initial_confirmation_mode)
+        return OpenHandsACPAgent(
+            conn, initial_confirmation_mode, resume_conversation_id
+        )
 
     AgentSideConnection(create_agent, writer, reader)
 
diff --git a/openhands_cli/argparsers/acp_parser.py b/openhands_cli/argparsers/acp_parser.py
@@ -1,6 +1,6 @@
 import argparse
 
-from openhands_cli.argparsers.util import add_confirmation_mode_args
+from openhands_cli.argparsers.util import add_confirmation_mode_args, add_resume_args
 
 
 def add_acp_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
@@ -13,6 +13,9 @@ def add_acp_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentP
         ),
     )
 
+    # Resume arguments (same as main parser)
+    add_resume_args(acp_parser)
+
     # ACP confirmation mode options (mutually exclusive)
     acp_confirmation_group = acp_parser.add_mutually_exclusive_group()
     add_confirmation_mode_args(acp_confirmation_group)
diff --git a/openhands_cli/argparsers/main_parser.py b/openhands_cli/argparsers/main_parser.py
@@ -8,7 +8,7 @@
 from openhands_cli.argparsers.cloud_parser import add_cloud_parser
 from openhands_cli.argparsers.mcp_parser import add_mcp_parser
 from openhands_cli.argparsers.serve_parser import add_serve_parser
-from openhands_cli.argparsers.utils import add_confirmation_mode_args
+from openhands_cli.argparsers.util import add_confirmation_mode_args, add_resume_args
 from openhands_cli.argparsers.web_parser import add_web_parser
 
 
@@ -72,19 +72,7 @@ def create_main_parser() -> argparse.ArgumentParser:
     )
 
     # CLI arguments at top level (default mode)
-    parser.add_argument(
-        "--resume",
-        type=str,
-        nargs="?",
-        const="",
-        help="Conversation ID to resume. If no ID provided, shows list of recent "
-        "conversations",
-    )
-    parser.add_argument(
-        "--last",
-        action="store_true",
-        help="Resume the most recent conversation (use with --resume)",
-    )
+    add_resume_args(parser)
     parser.add_argument(
         "--exp",
         action="store_true",
diff --git a/openhands_cli/argparsers/util.py b/openhands_cli/argparsers/util.py
@@ -22,3 +22,24 @@ def add_confirmation_mode_args(
             "(only confirm LLM-predicted high-risk actions)"
         ),
     )
+
+
+def add_resume_args(parser: argparse.ArgumentParser) -> None:
+    """Add resume-related arguments to a parser.
+
+    Args:
+        parser: The argument parser to add resume arguments to
+    """
+    parser.add_argument(
+        "--resume",
+        type=str,
+        nargs="?",
+        const="",
+        help="Conversation ID to resume. If no ID provided, shows list of recent "
+        "conversations",
+    )
+    parser.add_argument(
+        "--last",
+        action="store_true",
+        help="Resume the most recent conversation (use with --resume)",
+    )
diff --git a/openhands_cli/simple_main.py b/openhands_cli/simple_main.py
@@ -124,7 +124,18 @@ def main() -> None:
             elif args.llm_approve:
                 confirmation_mode = "llm-approve"
 
-            asyncio.run(run_acp_server(initial_confirmation_mode=confirmation_mode))
+            # Handle resume logic for ACP (same as main command)
+            resume_id = handle_resume_logic(args)
+            if resume_id is None and (args.last or args.resume == ""):
+                # Either showed conversation list or had an error
+                return
+
+            asyncio.run(
+                run_acp_server(
+                    initial_confirmation_mode=confirmation_mode,
+                    resume_conversation_id=resume_id,
+                )
+            )
 
         elif args.command == "login":
             from openhands_cli.auth.login_command import run_login_command
diff --git a/openhands_cli/stores/agent_store.py b/openhands_cli/stores/agent_store.py
@@ -20,7 +20,11 @@
     WORK_DIR,
 )
 from openhands_cli.mcp.mcp_utils import list_enabled_servers
-from openhands_cli.utils import get_llm_metadata, should_set_litellm_extra_body
+from openhands_cli.utils import (
+    get_llm_metadata,
+    get_os_description,
+    should_set_litellm_extra_body,
+)
 
 
 class AgentStore:
@@ -40,9 +44,16 @@ def load(self, session_id: str | None = None) -> Agent | None:
             # Load skills from user directories and project-specific directories
             skills = load_project_skills(WORK_DIR)
 
+            system_suffix = "\n".join(
+                [
+                    f"Your current working directory is: {WORK_DIR}",
+                    f"User operating system: {get_os_description()}",
+                ]
+            )
+
             agent_context = AgentContext(
                 skills=skills,
-                system_message_suffix=f"You current working directory is: {WORK_DIR}",
+                system_message_suffix=system_suffix,
                 load_user_skills=True,
                 load_public_skills=True,
             )
@@ -62,9 +73,12 @@ def load(self, session_id: str | None = None) -> Agent | None:
                 }
             updated_llm = agent.llm.model_copy(update=llm_update)
 
-            condenser_updates = {}
+            # Always create a fresh condenser with current defaults if condensation
+            # is enabled. This ensures users get the latest condenser settings
+            # (e.g., max_size, keep_first) without needing to reconfigure.
+            condenser = None
             if agent.condenser and isinstance(agent.condenser, LLMSummarizingCondenser):
-                condenser_llm_update = {}
+                condenser_llm_update: dict[str, Any] = {}
                 if should_set_litellm_extra_body(agent.condenser.llm.model):
                     condenser_llm_update["litellm_extra_body"] = {
                         "metadata": get_llm_metadata(
@@ -73,9 +87,10 @@ def load(self, session_id: str | None = None) -> Agent | None:
                             session_id=session_id,
                         )
                     }
-                condenser_updates["llm"] = agent.condenser.llm.model_copy(
+                condenser_llm = agent.condenser.llm.model_copy(
                     update=condenser_llm_update
                 )
+                condenser = LLMSummarizingCondenser(llm=condenser_llm)
 
             # Update tools and context
             agent = agent.model_copy(
@@ -86,9 +101,7 @@ def load(self, session_id: str | None = None) -> Agent | None:
                     if enabled_servers
                     else {},
                     "agent_context": agent_context,
-                    "condenser": agent.condenser.model_copy(update=condenser_updates)
-                    if agent.condenser
-                    else None,
+                    "condenser": condenser,
                 }
             )
 
diff --git a/openhands_cli/utils.py b/openhands_cli/utils.py
@@ -2,6 +2,7 @@
 
 import json
 import os
+import platform
 from argparse import Namespace
 from pathlib import Path
 from typing import Any
@@ -15,6 +16,26 @@
 from openhands.tools.preset import get_default_agent
 
 
+def get_os_description() -> str:
+    system = platform.system() or "Unknown"
+
+    if system == "Darwin":
+        ver = platform.mac_ver()[0] or platform.release()
+        return f"macOS {ver}".strip()
+
+    if system == "Windows":
+        release, version, *_ = platform.win32_ver()
+        if release and version:
+            return f"Windows {release} ({version})"
+        return "Windows"
+
+    if system == "Linux":
+        kernel = platform.release()
+        return f"Linux (kernel {kernel})" if kernel else "Linux"
+
+    return platform.platform() or system
+
+
 def should_set_litellm_extra_body(model_name: str) -> bool:
     """
     Determine if litellm_extra_body should be set based on the model name.
diff --git a/pyproject.toml b/pyproject.toml
@@ -16,8 +16,8 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-  "openhands-sdk==1.7.1",
-  "openhands-tools==1.7.1",
+  "openhands-sdk==1.7.2",
+  "openhands-tools==1.7.2",
   "prompt-toolkit>=3",
   "textual>=0.79.0",
   "typer>=0.17.4",
diff --git a/tests/acp/test_agent.py b/tests/acp/test_agent.py
diff --git a/tests/test_agent_context_os_info.py b/tests/test_agent_context_os_info.py
diff --git a/tests/test_cli_help.py b/tests/test_cli_help.py
diff --git a/uv.lock b/uv.lock
