openhands-agent-server 1.3.0__tar.gz → 1.8.1__tar.gz

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.3.0
+Version: 1.8.1
 Summary: OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent
 Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.19
 Requires-Dist: alembic>=1.13
 Requires-Dist: docker<8,>=7.1
 Requires-Dist: fastapi>=0.104
+Requires-Dist: openhands-sdk
 Requires-Dist: pydantic>=2
 Requires-Dist: sqlalchemy>=2
 Requires-Dist: uvicorn>=0.31.1

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/api.py

@@ -1,3 +1,4 @@
+import asyncio
 import traceback
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
@@ -28,6 +29,7 @@ from openhands.agent_server.server_details_router import (
     server_details_router,
 )
 from openhands.agent_server.sockets import sockets_router
+from openhands.agent_server.tool_preload_service import get_tool_preload_service
 from openhands.agent_server.tool_router import tool_router
 from openhands.agent_server.vscode_router import vscode_router
 from openhands.agent_server.vscode_service import get_vscode_service
@@ -42,28 +44,50 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
     service = get_default_conversation_service()
     vscode_service = get_vscode_service()
     desktop_service = get_desktop_service()
-
-    # Start VSCode service if enabled
-    if vscode_service is not None:
-        vscode_started = await vscode_service.start()
-        if vscode_started:
-            logger.info("VSCode service started successfully")
+    tool_preload_service = get_tool_preload_service()
+
+    # Define async functions for starting each service
+    async def start_vscode_service():
+        if vscode_service is not None:
+            vscode_started = await vscode_service.start()
+            if vscode_started:
+                logger.info("VSCode service started successfully")
+            else:
+                logger.warning(
+                    "VSCode service failed to start, continuing without VSCode"
+                )
         else:
-            logger.warning("VSCode service failed to start, continuing without VSCode")
-    else:
-        logger.info("VSCode service is disabled")
-
-    # Start Desktop service if enabled
-    if desktop_service is not None:
-        desktop_started = await desktop_service.start()
-        if desktop_started:
-            logger.info("Desktop service started successfully")
+            logger.info("VSCode service is disabled")
+
+    async def start_desktop_service():
+        if desktop_service is not None:
+            desktop_started = await desktop_service.start()
+            if desktop_started:
+                logger.info("Desktop service started successfully")
+            else:
+                logger.warning(
+                    "Desktop service failed to start, continuing without desktop"
+                )
         else:
-            logger.warning(
-                "Desktop service failed to start, continuing without desktop"
-            )
-    else:
-        logger.info("Desktop service is disabled")
+            logger.info("Desktop service is disabled")
+
+    async def start_tool_preload_service():
+        if tool_preload_service is not None:
+            tool_preload_started = await tool_preload_service.start()
+            if tool_preload_started:
+                logger.info("Tool preload service started successfully")
+            else:
+                logger.warning("Tool preload service failed to start - skipping")
+        else:
+            logger.info("Tool preload service is disabled")
+
+    # Start all services concurrently
+    await asyncio.gather(
+        start_vscode_service(),
+        start_desktop_service(),
+        start_tool_preload_service(),
+        return_exceptions=True,
+    )
 
     async with service:
         # Store the initialized service in app state for dependency injection
@@ -71,11 +95,26 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
         try:
             yield
         finally:
-            # Stop services on shutdown
-            if vscode_service is not None:
-                await vscode_service.stop()
-            if desktop_service is not None:
-                await desktop_service.stop()
+            # Define async functions for stopping each service
+            async def stop_vscode_service():
+                if vscode_service is not None:
+                    await vscode_service.stop()
+
+            async def stop_desktop_service():
+                if desktop_service is not None:
+                    await desktop_service.stop()
+
+            async def stop_tool_preload_service():
+                if tool_preload_service is not None:
+                    await tool_preload_service.stop()
+
+            # Stop all services concurrently
+            await asyncio.gather(
+                stop_vscode_service(),
+                stop_desktop_service(),
+                stop_tool_preload_service(),
+                return_exceptions=True,
+            )
 
 
 def _create_fastapi_instance() -> FastAPI:

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/config.py

@@ -126,6 +126,10 @@ class Config(BaseModel):
         default=False,
         description="Whether to enable VNC desktop functionality",
     )
+    preload_tools: bool = Field(
+        default=True,
+        description="Whether to preload tools",
+    )
     secret_key: SecretStr | None = Field(
         default_factory=_default_secret_key,
         description=(

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/conversation_router.py

@@ -24,9 +24,10 @@ from openhands.agent_server.models import (
     UpdateConversationRequest,
     UpdateSecretsRequest,
 )
-from openhands.sdk import LLM, Agent, TextContent, Tool
+from openhands.sdk import LLM, Agent, TextContent
 from openhands.sdk.conversation.state import ConversationExecutionStatus
 from openhands.sdk.workspace import LocalWorkspace
+from openhands.tools.preset.default import get_default_tools
 
 
 conversation_router = APIRouter(prefix="/conversations", tags=["Conversations"])
@@ -41,17 +42,13 @@ START_CONVERSATION_EXAMPLES = [
                 model="your-model-provider/your-model-name",
                 api_key=SecretStr("your-api-key-here"),
             ),
-            tools=[
-                Tool(name="TerminalTool"),
-                Tool(name="FileEditorTool"),
-                Tool(name="TaskTrackerTool"),
-            ],
+            tools=get_default_tools(enable_browser=True),
         ),
         workspace=LocalWorkspace(working_dir="workspace/project"),
         initial_message=SendMessageRequest(
             role="user", content=[TextContent(text="Flip a coin!")]
         ),
-    ).model_dump(exclude_defaults=True)
+    ).model_dump(exclude_defaults=True, mode="json")
 ]
 
 
@@ -307,3 +304,18 @@ async def ask_agent(
     if response is None:
         raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR)
     return AskAgentResponse(response=response)
+
+
+@conversation_router.post(
+    "/{conversation_id}/condense",
+    responses={404: {"description": "Item not found"}},
+)
+async def condense_conversation(
+    conversation_id: UUID,
+    conversation_service: ConversationService = Depends(get_conversation_service),
+) -> Success:
+    """Force condensation of the conversation history."""
+    success = await conversation_service.condense(conversation_id)
+    if not success:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Conversation not found")
+    return Success()

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/conversation_service.py

@@ -1,4 +1,5 @@
 import asyncio
+import importlib
 import logging
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -165,14 +166,30 @@ class ConversationService:
         if not self._conversation_webhook_subscribers:
             return
 
-        # Send notifications to all conversation webhook subscribers
-        await asyncio.gather(
-            *[
-                subscriber.post_conversation_info(conversation_info)
-                for subscriber in self._conversation_webhook_subscribers
-            ],
-            return_exceptions=True,  # Don't fail if one webhook fails
-        )
+        # Send notifications to all conversation webhook subscribers in the background
+        async def _notify_and_log_errors():
+            results = await asyncio.gather(
+                *[
+                    subscriber.post_conversation_info(conversation_info)
+                    for subscriber in self._conversation_webhook_subscribers
+                ],
+                return_exceptions=True,  # Don't fail if one webhook fails
+            )
+
+            # Log any exceptions that occurred
+            for i, result in enumerate(results):
+                if isinstance(result, Exception):
+                    subscriber = self._conversation_webhook_subscribers[i]
+                    logger.error(
+                        (
+                            f"Failed to notify conversation webhook "
+                            f"{subscriber.spec.base_url}: {result}"
+                        ),
+                        exc_info=result,
+                    )
+
+        # Create task to run in background without awaiting
+        asyncio.create_task(_notify_and_log_errors())
 
     # Write Methods
 
@@ -192,6 +209,32 @@ class ConversationService:
             )
             return conversation_info, False
 
+        # Dynamically register tools from client's registry
+        if request.tool_module_qualnames:
+            import importlib
+
+            for tool_name, module_qualname in request.tool_module_qualnames.items():
+                try:
+                    # Import the module to trigger tool auto-registration
+                    importlib.import_module(module_qualname)
+                    logger.debug(
+                        f"Tool '{tool_name}' registered via module '{module_qualname}'"
+                    )
+                except ImportError as e:
+                    logger.warning(
+                        f"Failed to import module '{module_qualname}' for tool "
+                        f"'{tool_name}': {e}. Tool will not be available."
+                    )
+                    # Continue even if some tools fail to register
+                    # The agent will fail gracefully if it tries to use unregistered
+                    # tools
+            if request.tool_module_qualnames:
+                logger.info(
+                    f"Dynamically registered {len(request.tool_module_qualnames)} "
+                    f"tools for conversation {conversation_id}: "
+                    f"{list(request.tool_module_qualnames.keys())}"
+                )
+
         stored = StoredConversation(id=conversation_id, **request.model_dump())
         event_service = await self._start_event_service(stored)
         initial_message = request.initial_message
@@ -240,6 +283,9 @@ class ConversationService:
                 conversation_info = _compose_conversation_info(
                     event_service.stored, state
                 )
+                conversation_info.execution_status = (
+                    ConversationExecutionStatus.DELETING
+                )
                 await self._notify_conversation_webhooks(conversation_info)
             except Exception as e:
                 logger.warning(
@@ -332,6 +378,18 @@ class ConversationService:
         response = await event_service.ask_agent(question)
         return response
 
+    async def condense(self, conversation_id: UUID) -> bool:
+        """Force condensation of the conversation history."""
+        if self._event_services is None:
+            raise ValueError("inactive_service")
+        event_service = self._event_services.get(conversation_id)
+        if event_service is None:
+            return False
+
+        # Delegate to EventService to avoid accessing private conversation internals
+        await event_service.condense()
+        return True
+
     async def __aenter__(self):
         self.conversations_dir.mkdir(parents=True, exist_ok=True)
         self._event_services = {}
@@ -347,6 +405,34 @@ class ConversationService:
                         "cipher": self.cipher,
                     },
                 )
+                # Dynamically register tools when resuming persisted conversations
+                if stored.tool_module_qualnames:
+                    for (
+                        tool_name,
+                        module_qualname,
+                    ) in stored.tool_module_qualnames.items():
+                        try:
+                            # Import the module to trigger tool auto-registration
+                            importlib.import_module(module_qualname)
+                            logger.debug(
+                                f"Tool '{tool_name}' registered via module "
+                                f"'{module_qualname}' when resuming conversation "
+                                f"{stored.id}"
+                            )
+                        except ImportError as e:
+                            logger.warning(
+                                f"Failed to import module '{module_qualname}' for "
+                                f"tool '{tool_name}' when resuming conversation "
+                                f"{stored.id}: {e}. Tool will not be available."
+                            )
+                            # Continue even if some tools fail to register
+                    if stored.tool_module_qualnames:
+                        logger.info(
+                            f"Dynamically registered "
+                            f"{len(stored.tool_module_qualnames)} tools when "
+                            f"resuming conversation {stored.id}: "
+                            f"{list(stored.tool_module_qualnames.keys())}"
+                        )
                 await self._start_event_service(stored)
             except Exception:
                 logger.exception(
@@ -416,6 +502,9 @@ class ConversationService:
 
         try:
             await event_service.start()
+            # Save metadata immediately after successful start to ensure persistence
+            # even if the system is not shut down gracefully
+            await event_service.save_meta()
         except Exception:
             # Clean up the event service if startup fails
             await event_service.close()

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/docker/Dockerfile

@@ -156,6 +156,18 @@ RUN set -eux; \
 RUN mkdir -p /etc/docker && \
     echo '{"mtu": 1450}' > /etc/docker/daemon.json
 
+# --- GitHub CLI ---
+RUN set -eux; \
+    mkdir -p -m 755 /etc/apt/keyrings; \
+    wget -nv -O /etc/apt/keyrings/githubcli-archive-keyring.gpg \
+        https://cli.github.com/packages/githubcli-archive-keyring.gpg; \
+    chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg; \
+    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \
+        > /etc/apt/sources.list.d/github-cli.list; \
+    apt-get update; \
+    apt-get install -y gh; \
+    apt-get clean; \
+    rm -rf /var/lib/apt/lists/*
 
 # --- VNC + Desktop + noVNC ---
 RUN set -eux; \
@@ -218,10 +230,14 @@ ARG USERNAME
 
 COPY --chown=${USERNAME}:${USERNAME} --from=binary-builder /agent-server/dist/openhands-agent-server /usr/local/bin/openhands-agent-server
 RUN chmod +x /usr/local/bin/openhands-agent-server
+# Fix library path to use system GCC libraries instead of bundled ones
+ENV LD_LIBRARY_PATH=/usr/lib/aarch64-linux-gnu:/usr/lib:/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
 ENTRYPOINT ["/usr/local/bin/openhands-agent-server"]
 
 FROM base-image-minimal AS binary-minimal
 ARG USERNAME
 COPY --chown=${USERNAME}:${USERNAME} --from=binary-builder /agent-server/dist/openhands-agent-server /usr/local/bin/openhands-agent-server
 RUN chmod +x /usr/local/bin/openhands-agent-server
+# Fix library path to use system GCC libraries instead of bundled ones
+ENV LD_LIBRARY_PATH=/usr/lib/aarch64-linux-gnu:/usr/lib:/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
 ENTRYPOINT ["/usr/local/bin/openhands-agent-server"]

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/docker/build.py

@@ -4,7 +4,7 @@ Single-entry build helper for agent-server images.
 
 - Targets: binary | binary-minimal | source | source-minimal
 - Multi-tagging via CUSTOM_TAGS (comma-separated)
-- Versioned tag includes primary custom tag: v{SDK}_{BASE_SLUG}
+- Versioned tags for custom tags: {SDK_VERSION}-{CUSTOM_TAG}
 - Branch-scoped cache keys
 - CI (push) vs local (load) behavior
 - sdist-based builds: Uses `uv build` to create clean build contexts
@@ -26,18 +26,16 @@ import threading
 import tomllib
 from contextlib import chdir
 from pathlib import Path
-from typing import Literal
 
 from pydantic import BaseModel, Field, field_validator
 
 from openhands.sdk.logger import IN_CI, get_logger, rolling_log_view
+from openhands.sdk.workspace import PlatformType, TargetType
 
 
 logger = get_logger(__name__)
 
 VALID_TARGETS = {"binary", "binary-minimal", "source", "source-minimal"}
-TargetType = Literal["binary", "binary-minimal", "source", "source-minimal"]
-PlatformType = Literal["linux/amd64", "linux/arm64"]
 
 
 # --- helpers ---
@@ -379,8 +377,12 @@ class BuildOptions(BaseModel):
         return _base_slug(self.base_image)
 
     @property
-    def versioned_tag(self) -> str:
-        return f"v{self.sdk_version}_{self.base_image_slug}"
+    def versioned_tags(self) -> list[str]:
+        """
+        Generate simple version tags for each custom tag variant.
+        Returns tags like: 1.2.0-python, 1.2.0-java, 1.2.0-golang
+        """
+        return [f"{self.sdk_version}-{t}" for t in self.custom_tag_list]
 
     @property
     def base_tag(self) -> str:
@@ -412,7 +414,8 @@ class BuildOptions(BaseModel):
         if self.include_base_tag:
             tags.append(f"{self.image}:{self.base_tag}{arch_suffix}")
         if self.include_versioned_tag:
-            tags.append(f"{self.image}:{self.versioned_tag}{arch_suffix}")
+            for versioned_tag in self.versioned_tags:
+                tags.append(f"{self.image}:{versioned_tag}{arch_suffix}")
 
         # Append target suffix for clarity (binary is default, no suffix needed)
         if self.target != "binary":
@@ -734,7 +737,11 @@ def main(argv: list[str]) -> int:
                 fh.write(f"build_context={ctx}\n")
                 fh.write(f"dockerfile={ctx / 'Dockerfile'}\n")
                 fh.write(f"tags_csv={','.join(opts.all_tags)}\n")
-                fh.write(f"versioned_tag={opts.versioned_tag}\n")
+                # Only output versioned tags if they're being used
+                if opts.include_versioned_tag:
+                    fh.write(f"versioned_tags_csv={','.join(opts.versioned_tags)}\n")
+                else:
+                    fh.write("versioned_tags_csv=\n")
                 fh.write(f"base_image_slug={opts.base_image_slug}\n")
             logger.info("[build] Wrote outputs to $GITHUB_OUTPUT")
 
@@ -773,13 +780,18 @@ def main(argv: list[str]) -> int:
 
     # --- expose outputs for GitHub Actions ---
     def _write_gha_outputs(
-        image: str, short_sha: str, versioned_tag: str, tags_list: list[str]
+        image: str,
+        short_sha: str,
+        versioned_tags: list[str],
+        tags_list: list[str],
+        include_versioned_tag: bool,
     ) -> None:
         """
         If running in GitHub Actions, append step outputs to $GITHUB_OUTPUT.
         - image: repo/name (no tag)
         - short_sha: 7-char SHA
-        - versioned_tag: e.g. v{SDK}_{BASE_SLUG}_{target}[ -dev ]
+        - versioned_tags_csv: comma-separated list of versioned tags
+          (empty if not enabled)
         - tags: multiline output (one per line)
         - tags_csv: single-line, comma-separated
         """
@@ -789,13 +801,23 @@ def main(argv: list[str]) -> int:
         with open(out_path, "a", encoding="utf-8") as fh:
             fh.write(f"image={image}\n")
             fh.write(f"short_sha={short_sha}\n")
-            fh.write(f"versioned_tag={versioned_tag}\n")
+            # Only output versioned tags if they're being used
+            if include_versioned_tag:
+                fh.write(f"versioned_tags_csv={','.join(versioned_tags)}\n")
+            else:
+                fh.write("versioned_tags_csv=\n")
             fh.write(f"tags_csv={','.join(tags_list)}\n")
             fh.write("tags<<EOF\n")
             fh.write("\n".join(tags_list) + "\n")
             fh.write("EOF\n")
 
-    _write_gha_outputs(opts.image, opts.short_sha, opts.versioned_tag, tags)
+    _write_gha_outputs(
+        opts.image,
+        opts.short_sha,
+        opts.versioned_tags,
+        tags,
+        opts.include_versioned_tag,
+    )
     return 0
 
 

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/env_parser.py

@@ -17,7 +17,10 @@ from uuid import UUID
 
 from pydantic import BaseModel, SecretStr, TypeAdapter
 
-from openhands.sdk.utils.models import DiscriminatedUnionMixin
+from openhands.sdk.utils.models import (
+    DiscriminatedUnionMixin,
+    get_known_concrete_subclasses,
+)
 
 
 # Define Missing type
@@ -268,6 +271,26 @@ class UnionEnvParser(EnvParser):
                 output.write("\n")
 
 
+@dataclass
+class DiscriminatedUnionEnvParser(EnvParser):
+    parsers: dict[str, EnvParser]
+
+    def from_env(self, key: str) -> JsonType:
+        kind = os.environ.get(f"{key}_KIND", MISSING)
+        if kind is MISSING:
+            return MISSING
+        assert isinstance(kind, str)
+        parser = self.parsers[kind]
+        parser_result = parser.from_env(key)
+        assert isinstance(parser_result, dict)
+        parser_result["kind"] = kind
+        return parser_result
+
+    def to_env(self, key: str, value: Any, output: IO):
+        parser = self.parsers[value.kind]
+        parser.to_env(key, value, output)
+
+
 @dataclass
 class DelayedParser(EnvParser):
     """Delayed parser for circular dependencies"""
@@ -341,9 +364,16 @@ def get_env_parser(target_type: type, parsers: dict[type, EnvParser]) -> EnvPars
     if issubclass(target_type, DiscriminatedUnionMixin) and (
         inspect.isabstract(target_type) or ABC in target_type.__bases__
     ):
-        serializable_type = target_type.get_serializable_type()
-        if serializable_type != target_type:
-            return get_env_parser(target_type.get_serializable_type(), parsers)
+        delayed = DelayedParser()
+        parsers[target_type] = delayed  # Prevent circular dependency
+        sub_parsers = {
+            c.__name__: get_env_parser(c, parsers)
+            for c in get_known_concrete_subclasses(target_type)
+        }
+        parser = DiscriminatedUnionEnvParser(sub_parsers)
+        delayed.parser = parser
+        parsers[target_type] = parser
+        return parser
     if issubclass(target_type, BaseModel):  # type: ignore
         delayed = DelayedParser()
         parsers[target_type] = delayed  # Prevent circular dependency

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/event_service.py

@@ -19,6 +19,7 @@ from openhands.sdk.conversation.state import (
     ConversationExecutionStatus,
     ConversationState,
 )
+from openhands.sdk.event import AgentErrorEvent
 from openhands.sdk.event.conversation_state import ConversationStateUpdateEvent
 from openhands.sdk.event.llm_completion_log import LLMCompletionLogEvent
 from openhands.sdk.security.analyzer import SecurityAnalyzerBase
@@ -44,6 +45,7 @@ class EventService:
     _conversation: LocalConversation | None = field(default=None, init=False)
     _pub_sub: PubSub[Event] = field(default_factory=lambda: PubSub[Event](), init=False)
     _run_task: asyncio.Task | None = field(default=None, init=False)
+    _run_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False)
 
     @property
     def conversation_dir(self):
@@ -74,7 +76,8 @@ class EventService:
             raise ValueError("inactive_service")
         return self._conversation
 
-    async def get_event(self, event_id: str) -> Event | None:
+    def _get_event_sync(self, event_id: str) -> Event | None:
+        """Private sync function to get event with state lock."""
         if not self._conversation:
             raise ValueError("inactive_service")
         with self._conversation._state as state:
@@ -82,7 +85,13 @@ class EventService:
             event = state.events[index]
             return event
 
-    async def search_events(
+    async def get_event(self, event_id: str) -> Event | None:
+        if not self._conversation:
+            raise ValueError("inactive_service")
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, self._get_event_sync, event_id)
+
+    def _search_events_sync(
         self,
         page_id: str | None = None,
         limit: int = 100,
@@ -93,6 +102,7 @@ class EventService:
         timestamp__gte: datetime | None = None,
         timestamp__lt: datetime | None = None,
     ) -> EventPage:
+        """Private sync function to search events with state lock."""
         if not self._conversation:
             raise ValueError("inactive_service")
 
@@ -161,7 +171,34 @@ class EventService:
 
         return EventPage(items=items, next_page_id=next_page_id)
 
-    async def count_events(
+    async def search_events(
+        self,
+        page_id: str | None = None,
+        limit: int = 100,
+        kind: str | None = None,
+        source: str | None = None,
+        body: str | None = None,
+        sort_order: EventSortOrder = EventSortOrder.TIMESTAMP,
+        timestamp__gte: datetime | None = None,
+        timestamp__lt: datetime | None = None,
+    ) -> EventPage:
+        if not self._conversation:
+            raise ValueError("inactive_service")
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            self._search_events_sync,
+            page_id,
+            limit,
+            kind,
+            source,
+            body,
+            sort_order,
+            timestamp__gte,
+            timestamp__lt,
+        )
+
+    def _count_events_sync(
         self,
         kind: str | None = None,
         source: str | None = None,
@@ -169,7 +206,7 @@ class EventService:
         timestamp__gte: datetime | None = None,
         timestamp__lt: datetime | None = None,
     ) -> int:
-        """Count events matching the given filters."""
+        """Private sync function to count events with state lock."""
         if not self._conversation:
             raise ValueError("inactive_service")
 
@@ -210,6 +247,28 @@ class EventService:
 
         return count
 
+    async def count_events(
+        self,
+        kind: str | None = None,
+        source: str | None = None,
+        body: str | None = None,
+        timestamp__gte: datetime | None = None,
+        timestamp__lt: datetime | None = None,
+    ) -> int:
+        """Count events matching the given filters."""
+        if not self._conversation:
+            raise ValueError("inactive_service")
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            self._count_events_sync,
+            kind,
+            source,
+            body,
+            timestamp__gte,
+            timestamp__lt,
+        )
+
     def _event_matches_body(self, event: Event, body: str) -> bool:
         """Check if event's message content matches body filter (case-insensitive)."""
         # Import here to avoid circular imports
@@ -350,7 +409,9 @@ class EventService:
         workspace = self.stored.workspace
         assert isinstance(workspace, LocalWorkspace)
         Path(workspace.working_dir).mkdir(parents=True, exist_ok=True)
-        agent = Agent.model_validate(self.stored.agent.model_dump())
+        agent = Agent.model_validate(
+            self.stored.agent.model_dump(context={"expose_secrets": True}),
+        )
 
         conversation = LocalConversation(
             agent=agent,
@@ -379,23 +440,95 @@ class EventService:
         # Setup stats streaming for remote execution
         self._setup_stats_streaming(self._conversation.agent)
 
+        # If the execution_status was "running" while serialized, then the
+        # conversation can't possibly be running - something is wrong
+        state = self._conversation.state
+        if state.execution_status == ConversationExecutionStatus.RUNNING:
+            state.execution_status = ConversationExecutionStatus.ERROR
+            # Add error event for the first unmatched action to inform the agent
+            unmatched_actions = ConversationState.get_unmatched_actions(state.events)
+            if unmatched_actions:
+                first_action = unmatched_actions[0]
+                error_event = AgentErrorEvent(
+                    tool_name=first_action.tool_name,
+                    tool_call_id=first_action.tool_call_id,
+                    error=(
+                        "A restart occurred while this tool was in progress. "
+                        "This may indicate a fatal memory error or system crash. "
+                        "The tool execution was interrupted and did not complete."
+                    ),
+                )
+                self._conversation._on_event(error_event)
+
         # Publish initial state update
         await self._publish_state_update()
 
     async def run(self):
-        """Run the conversation asynchronously."""
+        """Run the conversation asynchronously in the background.
+
+        This method starts the conversation run in a background task and returns
+        immediately. The conversation status can be monitored via the
+        GET /api/conversations/{id} endpoint or WebSocket events.
+
+        Raises:
+            ValueError: If the service is inactive or conversation is already running.
+        """
         if not self._conversation:
             raise ValueError("inactive_service")
-        loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, self._conversation.run)
-        # Publish state update after run completes to ensure stats are updated
-        await self._publish_state_update()
+
+        # Use lock to make check-and-set atomic, preventing race conditions
+        async with self._run_lock:
+            # Check if already running
+            with self._conversation._state as state:
+                if state.execution_status == ConversationExecutionStatus.RUNNING:
+                    raise ValueError("conversation_already_running")
+
+            # Check if there's already a running task
+            if self._run_task is not None and not self._run_task.done():
+                raise ValueError("conversation_already_running")
+
+            # Capture conversation reference for the closure
+            conversation = self._conversation
+
+            # Start run in background
+            loop = asyncio.get_running_loop()
+
+            async def _run_and_publish():
+                try:
+                    await loop.run_in_executor(None, conversation.run)
+                except Exception as e:
+                    logger.error(f"Error during conversation run: {e}")
+                finally:
+                    # Clear task reference and publish state update
+                    self._run_task = None
+                    await self._publish_state_update()
+
+            # Create task but don't await it - runs in background
+            self._run_task = asyncio.create_task(_run_and_publish())
 
     async def respond_to_confirmation(self, request: ConfirmationResponseRequest):
         if request.accept:
-            await self.run()
+            try:
+                await self.run()
+            except ValueError as e:
+                # Treat "already running" as a no-op success
+                if str(e) == "conversation_already_running":
+                    logger.debug(
+                        "Confirmation accepted but conversation already running"
+                    )
+                else:
+                    raise
         else:
-            await self.pause()
+            await self.reject_pending_actions(request.reason)
+
+    async def reject_pending_actions(self, reason: str):
+        """Reject all pending actions and publish updated state."""
+        if not self._conversation:
+            raise ValueError("inactive_service")
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(
+            None, self._conversation.reject_pending_actions, reason
+        )
 
     async def pause(self):
         if self._conversation:
@@ -474,6 +607,17 @@ class EventService:
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, self._conversation.ask_agent, question)
 
+    async def condense(self) -> None:
+        """Force condensation of the conversation history.
+
+        Delegates to LocalConversation in an executor to avoid blocking the event loop.
+        """
+        if not self._conversation:
+            raise ValueError("inactive_service")
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, self._conversation.condense)
+
     async def get_state(self) -> ConversationState:
         if not self._conversation:
             raise ValueError("inactive_service")

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/logging_config.py

@@ -3,26 +3,7 @@
 import logging
 from typing import Any
 
-from openhands.sdk.logger import (
-    ENV_JSON,
-    ENV_LOG_LEVEL,
-    IN_CI,
-)
-
-
-class UvicornAccessFormatter(logging.Formatter):
-    """Custom formatter for uvicorn access logs."""
-
-    def format(self, record):
-        # Set default values for uvicorn-specific fields if they don't exist
-        if not hasattr(record, "client_addr"):
-            record.client_addr = "-"
-        if not hasattr(record, "request_line"):
-            record.request_line = record.getMessage()
-        if not hasattr(record, "status_code"):
-            record.status_code = "-"
-
-        return super().format(record)
+from openhands.sdk.logger import ENV_LOG_LEVEL
 
 
 def get_uvicorn_logging_config() -> dict[str, Any]:
@@ -47,29 +28,6 @@ def get_uvicorn_logging_config() -> dict[str, Any]:
         "loggers": {},
     }
 
-    # Add formatters based on SDK settings
-    if ENV_JSON or IN_CI:
-        # JSON formatter for access logs
-        config["formatters"]["access"] = {
-            "()": "pythonjsonlogger.json.JsonFormatter",
-            "fmt": "%(asctime)s %(levelname)s %(name)s "
-            "%(client_addr)s %(request_line)s %(status_code)s",
-        }
-    else:
-        # Custom formatter for access logs that handles missing fields
-        config["formatters"]["access"] = {
-            "()": UvicornAccessFormatter,
-            "format": '%(asctime)s - %(name)s - %(levelname)s - "'
-            '"%(client_addr)s - "%(request_line)s" %(status_code)s',
-        }
-
-    # Access handler - always separate for proper formatting
-    config["handlers"]["access"] = {
-        "formatter": "access",
-        "class": "logging.StreamHandler",
-        "stream": "ext://sys.stdout",
-    }
-
     # Configure uvicorn loggers
     config["loggers"] = {
         # Main uvicorn logger - propagate to root
@@ -84,11 +42,11 @@ def get_uvicorn_logging_config() -> dict[str, Any]:
             "level": logging.getLevelName(ENV_LOG_LEVEL),
             "propagate": True,
         },
-        # Access logger - use dedicated handler
+        # Access logger - propagate to root
         "uvicorn.access": {
-            "handlers": ["access"],
+            "handlers": [],
             "level": logging.getLevelName(ENV_LOG_LEVEL),
-            "propagate": False,  # Don't duplicate to root
+            "propagate": True,
         },
     }
 

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/models.py

@@ -1,19 +1,19 @@
 from abc import ABC
 from datetime import datetime
 from enum import Enum
-from typing import Literal
+from typing import Any, Literal
 from uuid import uuid4
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from openhands.agent_server.utils import OpenHandsUUID, utc_now
 from openhands.sdk import LLM, AgentBase, Event, ImageContent, Message, TextContent
-from openhands.sdk.conversation.secret_source import SecretSource
 from openhands.sdk.conversation.state import (
     ConversationExecutionStatus,
     ConversationState,
 )
 from openhands.sdk.llm.utils.metrics import MetricsSnapshot
+from openhands.sdk.secret import SecretSource
 from openhands.sdk.security.analyzer import SecurityAnalyzerBase
 from openhands.sdk.security.confirmation_policy import (
     ConfirmationPolicyBase,
@@ -98,6 +98,14 @@ class StartConversationRequest(BaseModel):
         default_factory=dict,
         description="Secrets available in the conversation",
     )
+    tool_module_qualnames: dict[str, str] = Field(
+        default_factory=dict,
+        description=(
+            "Mapping of tool names to their module qualnames from the client's "
+            "registry. These modules will be dynamically imported on the server "
+            "to register the tools for this conversation."
+        ),
+    )
 
 
 class StoredConversation(StartConversationRequest):
@@ -159,6 +167,43 @@ class UpdateSecretsRequest(BaseModel):
         description="Dictionary mapping secret keys to values"
     )
 
+    @field_validator("secrets", mode="before")
+    @classmethod
+    def convert_string_secrets(cls, v: dict[str, Any]) -> dict[str, Any]:
+        """Convert plain string secrets to StaticSecret objects.
+
+        This validator enables backward compatibility by automatically converting:
+        - Plain strings: "secret-value" → StaticSecret(value=SecretStr("secret-value"))
+        - Dict with value field: {"value": "secret-value"} → StaticSecret dict format
+        - Proper SecretSource objects: passed through unchanged
+        """
+        if not isinstance(v, dict):
+            return v
+
+        converted = {}
+        for key, value in v.items():
+            if isinstance(value, str):
+                # Convert plain string to StaticSecret dict format
+                converted[key] = {
+                    "kind": "StaticSecret",
+                    "value": value,
+                }
+            elif isinstance(value, dict):
+                if "value" in value and "kind" not in value:
+                    # Convert dict with value field to StaticSecret dict format
+                    converted[key] = {
+                        "kind": "StaticSecret",
+                        "value": value["value"],
+                    }
+                else:
+                    # Keep existing SecretSource objects or properly formatted dicts
+                    converted[key] = value
+            else:
+                # Keep other types as-is (will likely fail validation later)
+                converted[key] = value
+
+        return converted
+
 
 class SetConfirmationPolicyRequest(BaseModel):
     """Payload to set confirmation policy for a conversation."""

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/sockets.py

@@ -26,6 +26,7 @@ from openhands.agent_server.conversation_service import (
 from openhands.agent_server.models import BashEventBase, ExecuteBashRequest
 from openhands.agent_server.pub_sub import Subscriber
 from openhands.sdk import Event, Message
+from openhands.sdk.utils.paging import page_iterator
 
 
 sockets_router = APIRouter(prefix="/sockets", tags=["WebSockets"])
@@ -65,14 +66,8 @@ async def events_socket(
         # Resend all existing events if requested
         if resend_all:
             logger.info(f"Resending events: {conversation_id}")
-            page_id = None
-            while True:
-                page = await event_service.search_events(page_id=page_id)
-                for event in page.items:
-                    await _send_event(event, websocket)
-                page_id = page.next_page_id
-                if not page_id:
-                    break
+            async for event in page_iterator(event_service.search_events):
+                await _send_event(event, websocket)
 
         # Listen for messages over the socket
         while True:
@@ -118,14 +113,8 @@ async def bash_events_socket(
         # Resend all existing events if requested
         if resend_all:
             logger.info("Resending bash events")
-            page_id = None
-            while True:
-                page = await bash_event_service.search_bash_events(page_id=page_id)
-                for event in page.items:
-                    await _send_bash_event(event, websocket)
-                page_id = page.next_page_id
-                if not page_id:
-                    break
+            async for event in page_iterator(bash_event_service.search_bash_events):
+                await _send_bash_event(event, websocket)
 
         while True:
             try:
@@ -150,7 +139,7 @@ async def bash_events_socket(
 
 async def _send_event(event: Event, websocket: WebSocket):
     try:
-        dumped = event.model_dump()
+        dumped = event.model_dump(mode="json")
         await websocket.send_json(dumped)
     except Exception:
         logger.exception("error_sending_event:{event}", stack_info=True)
@@ -168,7 +157,7 @@ class _WebSocketSubscriber(Subscriber):
 
 async def _send_bash_event(event: BashEventBase, websocket: WebSocket):
     try:
-        dumped = event.model_dump()
+        dumped = event.model_dump(mode="json")
         await websocket.send_json(dumped)
     except Exception:
         logger.exception("error_sending_event:{event}", stack_info=True)

openhands_agent_server-1.8.1/openhands/agent_server/tool_preload_service.py

@@ -0,0 +1,76 @@
+"""Service which preloads chromium."""
+
+from __future__ import annotations
+
+import sys
+
+from openhands.agent_server.config import get_default_config
+from openhands.sdk.logger import get_logger
+from openhands.sdk.tool.schema import Action
+from openhands.sdk.tool.tool import create_action_type_with_risk
+from openhands.sdk.utils.models import get_known_concrete_subclasses
+
+
+_logger = get_logger(__name__)
+
+
+class ToolPreloadService:
+    """Service which preloads tools / chromium reducing time to
+    start first conversation"""
+
+    running: bool = False
+
+    async def start(self) -> bool:
+        """Preload tools"""
+
+        # Skip if already running
+        if self.running:
+            return True
+
+        self.running = True
+        try:
+            if sys.platform == "win32":
+                from openhands.tools.browser_use.impl_windows import (
+                    WindowsBrowserToolExecutor as BrowserToolExecutor,
+                )
+            else:
+                from openhands.tools.browser_use.impl import BrowserToolExecutor
+
+            # Creating an instance here to preload chomium
+            BrowserToolExecutor()
+
+            # Pre-creating all these classes prevents processing which costs
+            # significant time per tool on the first conversation invocation.
+            for action_type in get_known_concrete_subclasses(Action):
+                create_action_type_with_risk(action_type)
+
+            _logger.debug(f"Loaded {BrowserToolExecutor}")
+            return True
+        except Exception:
+            _logger.exception("Error preloading chromium")
+            return False
+
+    async def stop(self) -> None:
+        """Stop the tool preload process."""
+        self.running = False
+
+    def is_running(self) -> bool:
+        """Check if tool preload is running."""
+        return self.running
+
+
+_tool_preload_service: ToolPreloadService | None = None
+
+
+def get_tool_preload_service() -> ToolPreloadService | None:
+    """Get the tool preload service instance if preload is enabled."""
+    global _tool_preload_service
+    config = get_default_config()
+
+    if not config.preload_tools:
+        _logger.info("Tool preload is disabled in configuration")
+        return None
+
+    if _tool_preload_service is None:
+        _tool_preload_service = ToolPreloadService()
+    return _tool_preload_service

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands/agent_server/tool_router.py

@@ -4,11 +4,13 @@ from fastapi import APIRouter
 
 from openhands.sdk.tool.registry import list_registered_tools
 from openhands.tools.preset.default import register_default_tools
+from openhands.tools.preset.gemini import register_gemini_tools
 from openhands.tools.preset.planning import register_planning_tools
 
 
 tool_router = APIRouter(prefix="/tools", tags=["Tools"])
 register_default_tools(enable_browser=True)
+register_gemini_tools(enable_browser=True)
 register_planning_tools()
 
 

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands_agent_server.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.3.0
+Version: 1.8.1
 Summary: OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent
 Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.19
 Requires-Dist: alembic>=1.13
 Requires-Dist: docker<8,>=7.1
 Requires-Dist: fastapi>=0.104
+Requires-Dist: openhands-sdk
 Requires-Dist: pydantic>=2
 Requires-Dist: sqlalchemy>=2
 Requires-Dist: uvicorn>=0.31.1

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands_agent_server.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ pyproject.toml
 ./openhands/agent_server/py.typed
 ./openhands/agent_server/server_details_router.py
 ./openhands/agent_server/sockets.py
+./openhands/agent_server/tool_preload_service.py
 ./openhands/agent_server/tool_router.py
 ./openhands/agent_server/utils.py
 ./openhands/agent_server/vscode_router.py
@@ -56,6 +57,7 @@ openhands/agent_server/pub_sub.py
 openhands/agent_server/py.typed
 openhands/agent_server/server_details_router.py
 openhands/agent_server/sockets.py
+openhands/agent_server/tool_preload_service.py
 openhands/agent_server/tool_router.py
 openhands/agent_server/utils.py
 openhands/agent_server/vscode_router.py

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/openhands_agent_server.egg-info/requires.txt

@@ -2,6 +2,7 @@ aiosqlite>=0.19
 alembic>=1.13
 docker<8,>=7.1
 fastapi>=0.104
+openhands-sdk
 pydantic>=2
 sqlalchemy>=2
 uvicorn>=0.31.1

{openhands_agent_server-1.3.0 → openhands_agent_server-1.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openhands-agent-server"
-version = "1.3.0"
+version = "1.8.1"
 description = "OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent"
 
 requires-python = ">=3.12"
@@ -9,6 +9,7 @@ dependencies = [
   "alembic>=1.13",
   "docker>=7.1,<8",
   "fastapi>=0.104",
+  "openhands-sdk",
   "pydantic>=2",
   "sqlalchemy>=2",
   "uvicorn>=0.31.1",