openhands-agent-server 1.29.0__tar.gz → 1.29.3__tar.gz

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.29.0
+Version: 1.29.3
 Summary: OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/openhands/agent_server/agent_profiles_router.py

@@ -30,9 +30,10 @@ from openhands.agent_server._secrets_exposure import (
 )
 from openhands.agent_server.persistence import (
     PersistedSettings,
+    get_agent_profile_store,
+    get_llm_profile_store,
     get_settings_store,
 )
-from openhands.sdk.llm.llm_profile_store import LLMProfileStore
 from openhands.sdk.logger import get_logger
 from openhands.sdk.profiles import (
     ACPAgentProfile,
@@ -318,7 +319,7 @@ async def list_agent_profiles(request: Request) -> AgentProfileListResponse:
     settings_store = get_settings_store(config)
     settings = settings_store.load() or PersistedSettings()
 
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     with _store_errors():
         existing = store.list()
 
@@ -347,7 +348,7 @@ async def get_agent_profile(
     expose_mode = parse_expose_secrets_header(request)
     cipher = get_cipher(request)
 
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     try:
         with _store_errors():
             profile = store.load(name, cipher=cipher)
@@ -408,7 +409,7 @@ async def save_agent_profile(
     # secret once rather than double-encrypting the token.
     profile = _decrypt_profile_mcp_tools(profile, cipher)
 
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     # The id is server-managed (the active pointer is keyed on it): overwrite
     # keeps the namesake's id and bumps revision; create mints a fresh id,
     # ignoring any client-supplied one. The lock spans read + mint + save so two
@@ -448,7 +449,7 @@ async def delete_agent_profile(
     If the deleted profile was the active one, ``active_agent_profile_id`` is
     cleared.
     """
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     deleted_id = _summary_id_for_name(store, name)
 
     with _store_errors():
@@ -485,7 +486,7 @@ async def rename_agent_profile(
     survives the rename untouched. Returns 404 if the source is missing, 409 if
     ``new_name`` is taken.
     """
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     try:
         with _store_errors():
             store.rename(name, body.new_name)
@@ -520,7 +521,7 @@ async def activate_agent_profile(
     ``/activate``, this does **not** write ``agent_settings`` (the
     creation-time-only contract). Returns 404 if no stored profile has that id.
     """
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     with _store_errors():
         known_ids = {
             str(s["id"]) for s in store.list_summaries() if s.get("id") is not None
@@ -574,7 +575,7 @@ async def materialize_agent_profile(
     """
     cipher = get_cipher(request)
 
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     try:
         with _store_errors():
             profile = store.load(name, cipher=cipher)
@@ -592,7 +593,7 @@ async def materialize_agent_profile(
     settings = get_settings_store(config).load() or PersistedSettings()
     mcp_config = settings.agent_settings.mcp_config
 
-    llm_store = LLMProfileStore()
+    llm_store = get_llm_profile_store()
     return resolve_agent_profile_dry_run(
         profile,
         llm_store=llm_store,

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/openhands/agent_server/api.py

@@ -29,8 +29,8 @@ from openhands.agent_server.conversation_service import (
     get_default_conversation_service,
 )
 from openhands.agent_server.dependencies import (
-    create_session_api_key_dependency,
-    create_workspace_session_dependency,
+    check_session_api_key,
+    check_workspace_session,
 )
 from openhands.agent_server.desktop_router import desktop_router
 from openhands.agent_server.desktop_service import get_desktop_service
@@ -47,9 +47,10 @@ from openhands.agent_server.llm_router import llm_router
 from openhands.agent_server.mcp_router import mcp_router
 from openhands.agent_server.middleware import CORSDispatcher
 from openhands.agent_server.openai.router import (
-    create_openai_api_key_dependency,
+    check_openai_api_key,
     openai_router,
 )
+from openhands.agent_server.plugins_router import plugins_router
 from openhands.agent_server.profiles_router import profiles_router
 from openhands.agent_server.server_details_router import (
     get_server_info,
@@ -234,6 +235,9 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
         mark_initialization_complete()
         logger.info("Server initialization complete - ready to serve requests")
 
+        bash_svc = get_default_bash_event_service()
+        api.state.bash_event_service = bash_svc
+
         async with service:
             api.state.conversation_service = service
 
@@ -241,7 +245,7 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
             retention_task: asyncio.Task | None = None
             if config.bash_events_retention_seconds is not None:
                 retention_task = asyncio.create_task(
-                    get_default_bash_event_service().run_retention_cleanup_loop(
+                    bash_svc.run_retention_cleanup_loop(
                         config.bash_events_retention_seconds
                     )
                 )
@@ -310,12 +314,8 @@ def _find_http_exception(exc: BaseExceptionGroup) -> HTTPException | None:
     return None
 
 
-def _add_api_routes(app: FastAPI, config: Config) -> None:
-    """Add all API routes to the FastAPI application.
-
-    Args:
-        app: FastAPI application instance to add routes to.
-    """
+def _add_api_routes(app: FastAPI) -> None:
+    """Add all API routes to the FastAPI application."""
     app.include_router(server_details_router)
 
     # The /api/init endpoint bypasses both the session-key auth and the
@@ -330,12 +330,14 @@ def _add_api_routes(app: FastAPI, config: Config) -> None:
     # Header-only auth: applied to every /api/* route EXCEPT the workspace
     # static-file routes (handled separately below). Cookies are NOT honored
     # here so that we don't expand the CSRF surface across the whole API.
-    dependencies = []
-    if config.session_api_keys:
-        dependencies.append(Depends(create_session_api_key_dependency(config)))
-    # Dormant gate: when ``deferred_init`` is True this 503s every /api/*
-    # route until POST /api/init completes. No-op for non-deferred deployments.
-    dependencies.append(Depends(require_initialized))
+    # check_session_api_key reads config from request.app.state at request time,
+    # so keys delivered via POST /api/init are honoured without re-registering routes.
+    dependencies = [
+        Depends(check_session_api_key),
+        # Dormant gate: 503s every /api/* route until POST /api/init completes.
+        # No-op for non-deferred deployments.
+        Depends(require_initialized),
+    ]
 
     api_router = APIRouter(prefix="/api", dependencies=dependencies)
     api_router.include_router(event_router)
@@ -347,6 +349,7 @@ def _add_api_routes(app: FastAPI, config: Config) -> None:
     api_router.include_router(vscode_router)
     api_router.include_router(desktop_router)
     api_router.include_router(skills_router)
+    api_router.include_router(plugins_router)
     api_router.include_router(hooks_router)
     api_router.include_router(llm_router)
     api_router.include_router(mcp_router)
@@ -359,22 +362,16 @@ def _add_api_routes(app: FastAPI, config: Config) -> None:
     api_router.include_router(auth_router)
     app.include_router(api_router)
 
-    openai_dependencies = []
-    if config.session_api_keys:
-        openai_dependencies.append(Depends(create_openai_api_key_dependency(config)))
-    app.include_router(openai_router, dependencies=openai_dependencies)
+    app.include_router(openai_router, dependencies=[Depends(check_openai_api_key)])
 
     # Workspace static-file routes get their own auth group that accepts
     # EITHER the X-Session-API-Key header OR the workspace session cookie.
     # The cookie is required so that <iframe src> / <img src> embeds of
     # workspace artifacts work — browsers cannot attach custom headers to
     # those requests.
-    workspace_dependencies = []
-    if config.session_api_keys:
-        workspace_dependencies.append(
-            Depends(create_workspace_session_dependency(config))
-        )
-    workspace_api_router = APIRouter(prefix="/api", dependencies=workspace_dependencies)
+    workspace_api_router = APIRouter(
+        prefix="/api", dependencies=[Depends(check_workspace_session)]
+    )
     workspace_api_router.include_router(workspace_router)
     app.include_router(workspace_api_router)
 
@@ -592,7 +589,7 @@ def create_app(config: Config | None = None) -> FastAPI:
     app = _create_fastapi_instance(config)
     app.state.config = config
 
-    _add_api_routes(app, config)
+    _add_api_routes(app)
     _setup_static_files(app, config)
     app.add_middleware(
         CORSDispatcher,

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/openhands/agent_server/bash_router.py

@@ -7,12 +7,14 @@ from uuid import UUID
 
 from fastapi import (
     APIRouter,
+    Depends,
     HTTPException,
     Query,
     status,
 )
 
-from openhands.agent_server.bash_service import get_default_bash_event_service
+from openhands.agent_server.bash_service import BashEventService
+from openhands.agent_server.dependencies import get_bash_event_service
 from openhands.agent_server.models import (
     BashCommand,
     BashEventBase,
@@ -25,7 +27,6 @@ from openhands.agent_server.server_details_router import update_last_execution_t
 
 
 bash_router = APIRouter(prefix="/bash", tags=["Bash"])
-bash_event_service = get_default_bash_event_service()
 logger = logging.getLogger(__name__)
 
 
@@ -53,6 +54,7 @@ async def search_bash_events(
         int,
         Query(title="The max number of results in the page", gt=0, lte=100),
     ] = 100,
+    bash_event_service: BashEventService = Depends(get_bash_event_service),
 ) -> BashEventPage:
     """Search / List bash event events"""
     assert limit > 0
@@ -73,7 +75,10 @@ async def search_bash_events(
 @bash_router.get(
     "/bash_events/{event_id}", responses={404: {"description": "Item not found"}}
 )
-async def get_bash_event(event_id: str) -> BashEventBase:
+async def get_bash_event(
+    event_id: str,
+    bash_event_service: BashEventService = Depends(get_bash_event_service),
+) -> BashEventBase:
     """Get a bash event event given an id"""
     event = await bash_event_service.get_bash_event(event_id)
     if event is None:
@@ -84,6 +89,7 @@ async def get_bash_event(event_id: str) -> BashEventBase:
 @bash_router.get("/bash_events/")
 async def batch_get_bash_events(
     event_ids: list[str],
+    bash_event_service: BashEventService = Depends(get_bash_event_service),
 ) -> list[BashEventBase | None]:
     """Get a batch of bash event events given their ids, returning null for any
     missing item."""
@@ -92,7 +98,10 @@ async def batch_get_bash_events(
 
 
 @bash_router.post("/start_bash_command")
-async def start_bash_command(request: ExecuteBashRequest) -> BashCommand:
+async def start_bash_command(
+    request: ExecuteBashRequest,
+    bash_event_service: BashEventService = Depends(get_bash_event_service),
+) -> BashCommand:
     """Execute a bash command in the background"""
     update_last_execution_time()
     command, _ = await bash_event_service.start_bash_command(request)
@@ -100,7 +109,10 @@ async def start_bash_command(request: ExecuteBashRequest) -> BashCommand:
 
 
 @bash_router.post("/execute_bash_command")
-async def execute_bash_command(request: ExecuteBashRequest) -> BashOutput:
+async def execute_bash_command(
+    request: ExecuteBashRequest,
+    bash_event_service: BashEventService = Depends(get_bash_event_service),
+) -> BashOutput:
     """Execute a bash command and wait for a result"""
     update_last_execution_time()
     command, task = await bash_event_service.start_bash_command(request)
@@ -111,7 +123,9 @@ async def execute_bash_command(request: ExecuteBashRequest) -> BashOutput:
 
 
 @bash_router.delete("/bash_events")
-async def clear_all_bash_events() -> dict[str, int]:
+async def clear_all_bash_events(
+    bash_event_service: BashEventService = Depends(get_bash_event_service),
+) -> dict[str, int]:
     """Clear all bash events from storage"""
     count = await bash_event_service.clear_all_events()
     return {"cleared_count": count}

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/openhands/agent_server/conversation_service.py

@@ -1,6 +1,7 @@
 import asyncio
 import importlib
 import logging
+from collections.abc import Awaitable, Callable
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import suppress
 from dataclasses import dataclass, field
@@ -261,11 +262,13 @@ def _resolve_agent_from_profile(
         DanglingMcpServerRef: A referenced MCP server is absent from the global config.
         ValueError: Profile load or settings validation failure.
     """
-    from openhands.sdk.llm.llm_profile_store import LLMProfileStore
-    from openhands.sdk.profiles.agent_profile_store import AgentProfileStore
+    from openhands.agent_server.persistence.store import (
+        get_agent_profile_store,
+        get_llm_profile_store,
+    )
     from openhands.sdk.profiles.resolver import ProfileNotFound, resolve_agent_profile
 
-    store = AgentProfileStore()
+    store = get_agent_profile_store()
     profile_name = store.name_for_id(profile_id)
     if profile_name is None:
         raise ProfileNotFound(f"Agent profile with id '{profile_id}' not found")
@@ -281,7 +284,7 @@ def _resolve_agent_from_profile(
             f"Failed to load agent profile '{profile_name}': {exc}"
         ) from exc
 
-    llm_store = LLMProfileStore()
+    llm_store = get_llm_profile_store()
     try:
         settings_config = resolve_agent_profile(
             profile, llm_store=llm_store, mcp_config=mcp_config, cipher=cipher
@@ -1343,9 +1346,11 @@ class AutoTitleSubscriber(Subscriber):
             return None
 
         try:
-            from openhands.sdk.llm.llm_profile_store import LLMProfileStore
+            from openhands.agent_server.persistence.store import (
+                get_llm_profile_store,
+            )
 
-            profile_store = LLMProfileStore()
+            profile_store = get_llm_profile_store()
             return profile_store.load(profile_name, cipher=self.service.cipher)
         except (FileNotFoundError, ValueError) as e:
             logger.warning(
@@ -1363,6 +1368,12 @@ class WebhookSubscriber(Subscriber):
     session_api_key: str | None = None
     queue: list[Event] = field(default_factory=list)
     _flush_timer: asyncio.Task | None = field(default=None, init=False)
+    # Per-instance sleep seam so tests override delays without patching the
+    # global asyncio.sleep. default_factory (not default) keeps it an instance
+    # attribute, else the function would be descriptor-bound as a method.
+    _sleep: Callable[[float], Awaitable[None]] = field(
+        default_factory=lambda: asyncio.sleep, init=False
+    )
 
     async def __call__(self, event: Event):
         """Add event to queue and post to webhook when buffer size is reached."""
@@ -1433,7 +1444,7 @@ class WebhookSubscriber(Subscriber):
             except Exception as e:
                 logger.warning(f"Webhook post attempt {attempt + 1} failed: {e}")
                 if attempt < self.spec.num_retries:
-                    await asyncio.sleep(self.spec.retry_delay)
+                    await self._sleep(self.spec.retry_delay)
                 else:
                     logger.error(
                         f"Failed to post events to webhook {events_url} "
@@ -1458,7 +1469,7 @@ class WebhookSubscriber(Subscriber):
     async def _flush_after_delay(self):
         """Wait for flush_delay seconds then flush events if any exist."""
         try:
-            await asyncio.sleep(self.spec.flush_delay)
+            await self._sleep(self.spec.flush_delay)
             # Only flush if there are events in the queue
             if self.queue:
                 await self._post_events()
@@ -1475,6 +1486,10 @@ class ConversationWebhookSubscriber:
 
     spec: WebhookSpec
     session_api_key: str | None = None
+    # Per-instance sleep seam; see WebhookSubscriber._sleep.
+    _sleep: Callable[[float], Awaitable[None]] = field(
+        default_factory=lambda: asyncio.sleep, init=False
+    )
 
     async def post_conversation_info(self, conversation_info: BaseModel):
         """Post conversation info to the webhook immediately (no batching)."""
@@ -1512,7 +1527,7 @@ class ConversationWebhookSubscriber:
                     f"Conversation webhook post attempt {attempt + 1} failed: {e}"
                 )
                 if attempt < self.spec.num_retries:
-                    await asyncio.sleep(self.spec.retry_delay)
+                    await self._sleep(self.spec.retry_delay)
                 else:
                     # Log response content for debugging failures
                     response_content = (

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/openhands/agent_server/dependencies.py

@@ -3,6 +3,7 @@ from uuid import UUID
 from fastapi import Depends, HTTPException, Request, status
 from fastapi.security import APIKeyCookie, APIKeyHeader
 
+from openhands.agent_server.bash_service import BashEventService
 from openhands.agent_server.config import Config
 from openhands.agent_server.conversation_service import ConversationService
 from openhands.agent_server.event_service import EventService
@@ -20,22 +21,26 @@ _WORKSPACE_SESSION_COOKIE = APIKeyCookie(
 )
 
 
-def create_session_api_key_dependency(config: Config):
-    """Create a session API key dependency with the given config."""
+def check_session_api_key(
+    request: Request,
+    session_api_key: str | None = Depends(_SESSION_API_KEY_HEADER),
+) -> None:
+    """Reject the request if the supplied key is not in the current session keys.
 
-    def check_session_api_key(
-        session_api_key: str | None = Depends(_SESSION_API_KEY_HEADER),
-    ):
-        """Check the session API key and throw an exception if incorrect. Having this as
-        a dependency means it appears in OpenAPI Docs
-        """
-        if config.session_api_keys and session_api_key not in config.session_api_keys:
-            raise HTTPException(status.HTTP_401_UNAUTHORIZED)
-
-    return check_session_api_key
+    Reads ``session_api_keys`` from ``request.app.state.config`` at request time
+    so that keys delivered via ``POST /api/init`` take effect immediately without
+    restarting the server or re-registering routes.
+    """
+    config: Config = request.app.state.config
+    if config.session_api_keys and session_api_key not in config.session_api_keys:
+        raise HTTPException(status.HTTP_401_UNAUTHORIZED)
 
 
-def create_workspace_session_dependency(config: Config):
+def check_workspace_session(
+    request: Request,
+    header_key: str | None = Depends(_SESSION_API_KEY_HEADER),
+    cookie_key: str | None = Depends(_WORKSPACE_SESSION_COOKIE),
+) -> None:
     """Auth dependency for the workspace static-file routes.
 
     Accepts EITHER the standard ``X-Session-API-Key`` header OR the
@@ -46,28 +51,16 @@ def create_workspace_session_dependency(config: Config):
     frontend embeds workspace artifacts. The cookie is deliberately scoped
     to this router only; no other endpoint honors it.
     """
-
-    def check_workspace_session(
-        header_key: str | None = Depends(_SESSION_API_KEY_HEADER),
-        cookie_key: str | None = Depends(_WORKSPACE_SESSION_COOKIE),
-    ):
-        if not config.session_api_keys:
+    config: Config = request.app.state.config
+    if not config.session_api_keys:
+        return
+    for candidate in (header_key, cookie_key):
+        if candidate and candidate in config.session_api_keys:
             return
-        for candidate in (header_key, cookie_key):
-            if candidate and candidate in config.session_api_keys:
-                return
-        raise HTTPException(status.HTTP_401_UNAUTHORIZED)
-
-    return check_workspace_session
-
-
-def get_conversation_service(request: Request):
-    """Get the conversation service from app state.
+    raise HTTPException(status.HTTP_401_UNAUTHORIZED)
 
-    This dependency ensures that the conversation service is properly initialized
-    through the application lifespan context manager.
-    """
 
+def get_conversation_service(request: Request) -> ConversationService:
     service = getattr(request.app.state, "conversation_service", None)
     if service is None:
         raise HTTPException(
@@ -77,6 +70,16 @@ def get_conversation_service(request: Request):
     return service
 
 
+def get_bash_event_service(request: Request) -> BashEventService:
+    service = getattr(request.app.state, "bash_event_service", None)
+    if service is None:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Bash event service is not available",
+        )
+    return service
+
+
 async def get_event_service(
     conversation_id: UUID,
     conversation_service: ConversationService = Depends(get_conversation_service),

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/openhands/agent_server/docker/Dockerfile

@@ -8,6 +8,11 @@ ARG USERNAME=openhands
 ARG UID=10001
 ARG GID=10001
 ARG PORT=8000
+# Opt-in build flag for the Vertex AI extra (`openhands-sdk[vertex]`). Off by
+# default to keep the published image lean. Pass `--build-arg ENABLE_VERTEX=1`
+# to bundle google-cloud-aiplatform so the resulting binary supports
+# `vertex_ai/*` partner models (MiniMax, Qwen, Kimi MaaS endpoints).
+ARG ENABLE_VERTEX=0
 
 ####################################################################################
 # Builder (source mode)
@@ -26,7 +31,7 @@ ARG PORT=8000
 # See OpenHands/software-agent-sdk#2761.
 ####################################################################################
 FROM python:3.13-bookworm AS builder
-ARG USERNAME UID GID
+ARG USERNAME UID GID ENABLE_VERTEX
 ENV UV_PROJECT_ENVIRONMENT=/agent-server/.venv
 ENV UV_PYTHON_INSTALL_DIR=/agent-server/uv-managed-python
 
@@ -48,9 +53,11 @@ COPY --chown=${USERNAME}:${USERNAME} openhands-tools ./openhands-tools
 COPY --chown=${USERNAME}:${USERNAME} openhands-workspace ./openhands-workspace
 COPY --chown=${USERNAME}:${USERNAME} openhands-agent-server ./openhands-agent-server
 RUN --mount=type=cache,target=/home/${USERNAME}/.cache,uid=${UID},gid=${GID} \
+    EXTRA_FLAGS=""; \
+    if [ "$ENABLE_VERTEX" = "1" ]; then EXTRA_FLAGS="--extra vertex"; fi; \
     uv python install 3.13 && \
     uv venv --python-preference only-managed --python 3.13 .venv && \
-    uv sync --frozen --no-editable --managed-python --extra boto3 && \
+    uv sync --frozen --no-editable --managed-python --extra boto3 $EXTRA_FLAGS && \
     readlink -f .venv/bin/python | grep -q '^/agent-server/uv-managed-python/'
 
 ####################################################################################
@@ -58,11 +65,13 @@ RUN --mount=type=cache,target=/home/${USERNAME}/.cache,uid=${UID},gid=${GID} \
 # We run pyinstaller here to produce openhands-agent-server
 ####################################################################################
 FROM builder AS binary-builder
-ARG USERNAME UID GID
+ARG USERNAME UID GID ENABLE_VERTEX
 
 # We need --dev for pyinstaller
 RUN --mount=type=cache,target=/home/${USERNAME}/.cache,uid=${UID},gid=${GID} \
-    uv sync --frozen --dev --no-editable --extra boto3
+    EXTRA_FLAGS=""; \
+    if [ "$ENABLE_VERTEX" = "1" ]; then EXTRA_FLAGS="--extra vertex"; fi; \
+    uv sync --frozen --dev --no-editable --extra boto3 $EXTRA_FLAGS
 
 RUN --mount=type=cache,target=/home/${USERNAME}/.cache,uid=${UID},gid=${GID} \
     uv run pyinstaller openhands-agent-server/openhands/agent_server/agent-server.spec

{openhands_agent_server-1.29.0 → openhands_agent_server-1.29.3}/openhands/agent_server/event_service.py

@@ -6,6 +6,8 @@ from datetime import datetime
 from pathlib import Path
 from uuid import UUID, uuid4
 
+from pydantic import ValidationError
+
 from openhands.agent_server.conversation_lease import (
     ConversationLease,
     ConversationOwnershipLostError,
@@ -20,6 +22,7 @@ from openhands.agent_server.pub_sub import PubSub, Subscriber
 from openhands.sdk import LLM, AgentBase, Event, Message, TextContent, get_logger
 from openhands.sdk.agent import ACPAgent
 from openhands.sdk.conversation.base import BaseConversation
+from openhands.sdk.conversation.events_list_base import EventsListBase
 from openhands.sdk.conversation.goal import (
     GoalController,
     GoalDone,
@@ -217,6 +220,18 @@ class EventService:
             return False
         return True
 
+    def _get_searchable_event(self, events: EventsListBase, index: int) -> Event | None:
+        try:
+            return events[index]
+        except (FileNotFoundError, UnicodeDecodeError, ValidationError) as exc:
+            logger.warning(
+                "Skipping unreadable event at index %d for conversation %s (%s)",
+                index,
+                self.stored.id,
+                type(exc).__name__,
+            )
+            return None
+
     def _search_events_sync(
         self,
         page_id: str | None = None,
@@ -272,7 +287,8 @@ class EventService:
                     start_index = None
             else:
                 for i in range(total):
-                    if events[i].id == page_id:
+                    event = self._get_searchable_event(events, i)
+                    if event is not None and event.id == page_id:
                         start_index = i
                         break
         if start_index is None:
@@ -286,7 +302,9 @@ class EventService:
         items: list[Event] = []
         next_page_id: str | None = None
         for i in indices:
-            event = events[i]
+            event = self._get_searchable_event(events, i)
+            if event is None:
+                continue
             if not self._event_matches_filters(
                 event, kind, source, body, timestamp_gte_str, timestamp_lt_str
             ):
@@ -360,7 +378,10 @@ class EventService:
         timestamp_lt_str = timestamp__lt.isoformat() if timestamp__lt else None
 
         count = 0
-        for event in events:
+        for i in range(len(events)):
+            event = self._get_searchable_event(events, i)
+            if event is None:
+                continue
             if self._event_matches_filters(
                 event, kind, source, body, timestamp_gte_str, timestamp_lt_str
             ):
@@ -584,10 +605,9 @@ class EventService:
         from callbacks that may run in different threads. Events are emitted through
         the conversation's normal event flow to ensure they are persisted.
         """
-        if self._main_loop and self._main_loop.is_running() and self._conversation:
-            # Capture conversation reference for closure
-            conversation = self._conversation
-
+        main_loop = self._main_loop
+        conversation = self._conversation
+        if main_loop and main_loop.is_running() and conversation:
             # Wrap _on_event with lock acquisition to ensure thread-safe access
             # to conversation state and event log during concurrent operations
             def locked_on_event():
@@ -596,7 +616,7 @@ class EventService:
 
             # Run the locked callback in an executor to ensure the event is
             # both persisted and sent to WebSocket subscribers
-            self._main_loop.run_in_executor(None, locked_on_event)
+            main_loop.run_in_executor(None, locked_on_event)
 
     def _setup_llm_log_streaming(self, agent: AgentBase) -> None:
         """Configure LLM log callbacks to stream logs via events."""
@@ -612,13 +632,16 @@ class EventService:
                 filename: str, log_data: str, uid=usage_id, model=model_name
             ) -> None:
                 """Callback to emit LLM completion logs as events."""
-                event = LLMCompletionLogEvent(
-                    filename=filename,
-                    log_data=log_data,
-                    model_name=model,
-                    usage_id=uid,
-                )
-                self._emit_event_from_thread(event)
+                try:
+                    event = LLMCompletionLogEvent(
+                        filename=filename,
+                        log_data=log_data,
+                        model_name=model,
+                        usage_id=uid,
+                    )
+                    self._emit_event_from_thread(event)
+                except Exception:
+                    logger.exception("Failed to emit LLM completion log event")
 
             llm.telemetry.set_log_completions_callback(log_callback)