From 5300bd71565921f595168e3fda061af4a40d9267 Mon Sep 17 00:00:00 2001 From: VascoSch92 Date: Sun, 15 Nov 2026 20:30:32 +0100 Subject: [PATCH 1/2] perf(agent-server): leave skill bodies out of full-state snapshots Every event socket (and webhook) gets a full ConversationState snapshot on connect and on state changes. It carried the full text of every skill in agent.agent_context.skills: 611 KB with the public skill tier, and serializing it in send_json blocked the event loop 18-26 ms per send on a Mac. Canvas, the Enterprise app and frontend, telemetry and the SDK's remote clients only read status and stats from it. Replace the skills with [] in the snapshot, as conversation responses already do by default (trim_conversation_response_skills). The snapshot drops to 4 KB and the send stalls go away. The persisted state and the running agent keep their skills. The live-server attach test grew the snapshot with a large skill to test WebSocket size limits; it now uses a large system_message_suffix. --- .../openhands/agent_server/event_service.py | 9 ++++- tests/agent_server/test_event_service.py | 33 +++++++++++++++++++ .../test_remote_conversation_live_server.py | 11 +++---- 3 files changed, 46 insertions(+), 7 deletions(-) diff --git a/openhands-agent-server/openhands/agent_server/event_service.py b/openhands-agent-server/openhands/agent_server/event_service.py index 6388c65de43..3c0c3390e22 100644 --- a/openhands-agent-server/openhands/agent_server/event_service.py +++ b/openhands-agent-server/openhands/agent_server/event_service.py @@ -847,7 +847,14 @@ def _create_state_update_event_sync(self) -> ConversationStateUpdateEvent: raise ValueError("inactive_service") state = self._conversation._state with state: - return ConversationStateUpdateEvent.from_conversation_state(state) + event = ConversationStateUpdateEvent.from_conversation_state(state) + # Like conversation responses (trim_conversation_response_skills), the + # snapshot pushed to sockets and webhooks leaves out skill bodies: they + # made it ~600 KB, and every known reader only uses status and stats. + agent_context = event.value.get("agent", {}).get("agent_context") + if isinstance(agent_context, dict) and agent_context.get("skills"): + agent_context["skills"] = [] + return event def _create_initial_state_sync( self, diff --git a/tests/agent_server/test_event_service.py b/tests/agent_server/test_event_service.py index dccebd6ef9b..6ca25052a2d 100644 --- a/tests/agent_server/test_event_service.py +++ b/tests/agent_server/test_event_service.py @@ -2808,6 +2808,39 @@ def mock_conversation_with_real_lock(self): conversation._state = state return conversation + @pytest.mark.asyncio + async def test_initial_state_leaves_out_skill_bodies( + self, event_service, mock_conversation_with_real_lock + ): + state = mock_conversation_with_real_lock._state + state.model_dump.return_value = { + "execution_status": "idle", + "agent": { + "llm": {"model": "gpt-4o-mini"}, + "agent_context": { + "skills": [{"name": "big", "content": "x" * 100_000}], + "system_message_suffix": "kept", + }, + }, + } + event_service._conversation = mock_conversation_with_real_lock + received: list[Event] = [] + + class Recorder(Subscriber[Event]): + async def __call__(self, event: Event): + received.append(event) + + await event_service.subscribe_to_events(Recorder()) + + snapshot = cast(ConversationStateUpdateEvent, received[0]) + assert snapshot.key == "full_state" + assert snapshot.value["agent"]["agent_context"] == { + "skills": [], + "system_message_suffix": "kept", + } + assert snapshot.value["agent"]["llm"] == {"model": "gpt-4o-mini"} + assert snapshot.value["execution_status"] == "idle" + @pytest.mark.asyncio async def test_concurrent_subscriptions_no_deadlock( self, event_service, mock_conversation_with_real_lock diff --git a/tests/cross/test_remote_conversation_live_server.py b/tests/cross/test_remote_conversation_live_server.py index 972fc1d765d..cb5cc072413 100644 --- a/tests/cross/test_remote_conversation_live_server.py +++ b/tests/cross/test_remote_conversation_live_server.py @@ -86,16 +86,15 @@ def _assert_secret(value: "str | SecretStr", expected: str) -> None: assert value == expected -@pytest.mark.parametrize("skill_mib", [2, 17]) -def test_attach_receives_large_initial_state(tmp_path: Path, monkeypatch, skill_mib): +@pytest.mark.parametrize("context_mib", [2, 17]) +def test_attach_receives_large_initial_state(tmp_path: Path, monkeypatch, context_mib): monkeypatch.setenv("OPENHANDS_REMOTE_WS_READY_TIMEOUT", "5") + # Skill bodies are left out of the snapshot, so grow a field that is sent. agent = Agent( llm=LLM(model="gpt-4o-mini", api_key=SecretStr("test")), tools=[], agent_context=AgentContext( - skills=[ - Skill(name="large-context", content="x" * (skill_mib * 1024 * 1024)) - ] + system_message_suffix="x" * (context_mib * 1024 * 1024) ), ) received = [] @@ -122,7 +121,7 @@ def on_event(event): response.raise_for_status() conversation_id = UUID(response.json()["id"]) try: - if skill_mib == 17: + if context_mib == 17: with pytest.raises( WebSocketConnectionError, match="message too big.*1009" ): From c0f5c5d142952d1530c5539c013b71cedadcba5b Mon Sep 17 00:00:00 2001 From: VascoSch92 Date: Mon, 16 Nov 2026 11:25:44 +0100 Subject: [PATCH 2/2] fix: leave skill bodies out of agent updates sent to sockets too Besides the full-state snapshot, an agent field update (plugin load, switch_llm, switch_profile, load_plugin) sent the whole agent with every skill body to sockets and webhooks, and remote clients cached it. Trim both through one helper. The persisted event and the running agent keep their skills. --- .../openhands/agent_server/event_service.py | 37 ++++++++++++++----- tests/agent_server/test_event_service.py | 27 ++++++++++++++ 2 files changed, 55 insertions(+), 9 deletions(-) diff --git a/openhands-agent-server/openhands/agent_server/event_service.py b/openhands-agent-server/openhands/agent_server/event_service.py index 3c0c3390e22..93e3f22d49d 100644 --- a/openhands-agent-server/openhands/agent_server/event_service.py +++ b/openhands-agent-server/openhands/agent_server/event_service.py @@ -81,7 +81,10 @@ StreamingDeltaEvent, ) from openhands.sdk.event.conversation_error import ConversationErrorEvent -from openhands.sdk.event.conversation_state import ConversationStateUpdateEvent +from openhands.sdk.event.conversation_state import ( + FULL_STATE_KEY, + ConversationStateUpdateEvent, +) from openhands.sdk.event.error_classification import ErrorClassification, FailureKind from openhands.sdk.event.llm_completion_log import LLMCompletionLogEvent from openhands.sdk.git.exceptions import GitCommandError, GitRepositoryError @@ -111,6 +114,23 @@ _GIT_INIT_LOCK = threading.Lock() +def _without_skill_bodies( + event: ConversationStateUpdateEvent, +) -> ConversationStateUpdateEvent: + """Leave skill bodies, most of the agent's size, out of the agent that + sockets and webhooks receive, as conversation responses do by default.""" + if event.key == FULL_STATE_KEY: + agent = event.value.get("agent") or {} + elif event.key == "agent": + agent = event.value.model_dump(mode="json") + event = event.model_copy(update={"value": agent}) + else: + return event + if agent.get("agent_context"): + agent["agent_context"]["skills"] = [] + return event + + class ConversationRunLimitExceeded(RateLimited, RuntimeError): """The server has no capacity to start another conversation run.""" @@ -848,13 +868,7 @@ def _create_state_update_event_sync(self) -> ConversationStateUpdateEvent: state = self._conversation._state with state: event = ConversationStateUpdateEvent.from_conversation_state(state) - # Like conversation responses (trim_conversation_response_skills), the - # snapshot pushed to sockets and webhooks leaves out skill bodies: they - # made it ~600 KB, and every known reader only uses status and stats. - agent_context = event.value.get("agent", {}).get("agent_context") - if isinstance(agent_context, dict) and agent_context.get("skills"): - agent_context["skills"] = [] - return event + return _without_skill_bodies(event) def _create_initial_state_sync( self, @@ -1332,7 +1346,7 @@ async def start(self): # Create and store callback wrapper to allow flushing pending events self._callback_wrapper = AsyncCallbackWrapper( - self._pub_sub, loop=asyncio.get_running_loop() + self._publish_to_subscribers, loop=asyncio.get_running_loop() ) # Token streaming is wired only for agents that can actually emit token @@ -2499,6 +2513,11 @@ async def get_state(self) -> ConversationState: raise ValueError("inactive_service") return self._conversation._state + async def _publish_to_subscribers(self, event: Event) -> None: + if isinstance(event, ConversationStateUpdateEvent): + event = _without_skill_bodies(event) + await self._pub_sub(event) + async def _publish_state_update(self): """Publish a ConversationStateUpdateEvent with the current state.""" if not self._conversation: diff --git a/tests/agent_server/test_event_service.py b/tests/agent_server/test_event_service.py index 6ca25052a2d..92100cb3ea4 100644 --- a/tests/agent_server/test_event_service.py +++ b/tests/agent_server/test_event_service.py @@ -39,6 +39,7 @@ from openhands.agent_server.pub_sub import Subscriber from openhands.sdk import LLM, Agent, AgentBase, Conversation, Message from openhands.sdk.agent import ACPAgent +from openhands.sdk.context import AgentContext from openhands.sdk.context.condenser import NoOpCondenser from openhands.sdk.conversation.event_store import EventLog from openhands.sdk.conversation.exceptions import ConversationRunError @@ -70,6 +71,7 @@ from openhands.sdk.mcp.config import coerce_mcp_config from openhands.sdk.secret import StaticSecret from openhands.sdk.security.confirmation_policy import NeverConfirm +from openhands.sdk.skills import Skill from openhands.sdk.subagent.schema import AgentDefinition from openhands.sdk.utils.cipher import FERNET_TOKEN_PREFIX, Cipher from openhands.sdk.utils.pydantic_secrets import REDACTED_SECRET_VALUE @@ -2841,6 +2843,31 @@ async def __call__(self, event: Event): assert snapshot.value["agent"]["llm"] == {"model": "gpt-4o-mini"} assert snapshot.value["execution_status"] == "idle" + @pytest.mark.asyncio + async def test_agent_update_leaves_out_skill_bodies(self, event_service): + agent = _sample_agent().model_copy( + update={ + "agent_context": AgentContext( + skills=[Skill(name="big", content="x" * 100_000)], + system_message_suffix="kept", + ) + } + ) + received: list[Event] = [] + + class Recorder(Subscriber[Event]): + async def __call__(self, event: Event): + received.append(event) + + event_service._pub_sub.subscribe(Recorder()) + update = ConversationStateUpdateEvent(key="agent", value=agent) + await event_service._publish_to_subscribers(update) + + sent = cast(ConversationStateUpdateEvent, received[0]) + assert sent.value["agent_context"]["skills"] == [] + assert sent.value["agent_context"]["system_message_suffix"] == "kept" + assert len(update.value.agent_context.skills) == 1 + @pytest.mark.asyncio async def test_concurrent_subscriptions_no_deadlock( self, event_service, mock_conversation_with_real_lock