Repository navigation
feat(agent-server): Conversation reactions, the first experimental feature - #6609
Conversation
A ReactionEvent (target_event_id, emoji, removed, source) records an emoji
on a message; it never reaches the LLM. Agents react with the new react and
unreact tools (openhands.tools.reaction), which default to the person's
latest message. The executor only reads the log: the observation carries
the reaction and the agent records the event right after it on its own
thread, through a new Observation.follow_up_events() hook, so it is safe
with parallel tool calls. People react through
POST /api/conversations/{id}/reactions (LocalConversation.react), which
defaults to the agent's latest message or finish and never runs the agent.
Emoji come from a fixed set of shortcodes. New feature-map family F37.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013ArwwJH94xGSYwfoyccT4E
… on every tool path Reaction part of de324a9 from #6602. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJH94xGSYwfoyccT4E
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJH94xGSYwfoyccT4E
…s the first
A feature flag is a yes/no switch the user sets for themselves, stored in
PersistedSettings.features and read when a conversation starts.
GET /api/settings/features lists the known features with their state, and
PATCH /api/settings/features/{key} {enabled} turns one on or off; unknown
keys are 404. The registry is openhands.agent_server.features.
The first flag, conversation_reactions (off by default), gives every new
OpenHands-agent conversation the react and unreact tools through a new
finalize(feature_tools=...) parameter (ACP agents are left alone), and
lets POST /api/conversations/{id}/reactions through; while it is off that
route answers 409. Feature map F37 covers both.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
REST API breakage checks (OpenAPI) — ✅ PASSEDResult: ✅ PASSED |
ReactionEvent / ReactionEmoji types with isReactionEvent, ConversationClient.react(), and SettingsClient.listFeatures() / updateFeature() with the FeatureFlag type. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
This comment has been minimized.
This comment has been minimized.
Coverage Report •
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
The react tool told the agent to unreact once it had answered, so a "react with eyes first, then answer" request left no reaction: the agent reacted and took it off just before its answer. A reaction now stays until it no longer fits or the person asks. F37.tool asks in plain words and checks that the one agent reaction is still on. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
- execute_tool records a tool's follow-up events without re-taking the state lock when the run loop holds it for the step (as switch_llm does, #3485), so a react from a tool worker cannot deadlock. - The reactions route answers 409 with a clear reason when the settings file cannot be read, and the feature list reads settings off the event loop. - Docs say what the flag governs: the agent's tools at conversation start, the person's reactions at once; child conversations reuse their parent's tools. The persisted-settings history notes the new field. - react/unreact take an EventID and are not idempotent (each call records an event). - TypeScript client: tests for listFeatures, updateFeature, react and isReactionEvent; the endpoint audit lists the new client-ahead calls. - F37: rest-default accepts the agent's finish or its plain-text answer as the default target, and the lock gotcha matches the run loop. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
Since #5796 an MCP entry with neither command nor url is refused when the config is built, so the invalid-entry case can no longer reach the runtime. Same one-line change as #6606, so this PR's CI is not red on a main failure. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
all-hands-bot
left a comment
There was a problem hiding this comment.
This review was posted by an AI agent (OpenHands).
Reviewed fresh at head 3a4d2b441df7c20f80ed868ae939f7dd17d0c34b against base 9f9bd444 (origin/main). CI on this head: all test suites green (sdk-tests, agent-server, agent-server-api, tools-tests, workspace, TS client, integration/smoke/ACP); the only red check is "Validate PR description", noted at the end.
Design. A user-scoped feature-flag registry (openhands.agent_server.features) with conversation_reactions as the first flag fits this repo cleanly: the flag state is additive (PersistedSettings.features within schema v7), the REST surface (GET /api/settings/features, PATCH .../features/{key}) refuses unknown keys with 404, and FileSettingsStore.update performs the swap under the existing file lock, so concurrent PATCHes cannot clobber each other.
Tools-at-start vs. live routing. The split behavior is implemented deliberately and correctly: feature_tools(settings.features) is resolved once in _start_conversation (conversation_service.py:1639) and merged into the agent via _with_client_tools (name-deduped), while the reactions REST route re-reads settings and checks is_enabled on every call. ACP agents are correctly excluded in finalize. Child conversations reuse the parent agent, so they inherit the tools chosen at parent start — consistent with the PR's stated semantics.
Reaction data model. ReactionEvent is non-LLM and whitelist-validated (check_reaction_emoji). find_reaction_target only considers the conversation's active branch and only reactable events (MessageEvent, or the agent's finish ActionEvent), and the default-target lookup selects from the opposite side, so a stale or cross-branch target_event_id cannot silently hit the wrong message.
Concurrency. The execute_tool follow-up-emission path (local_conversation.py:3405) reuses the switch_llm (#3485) skip-lock pattern: skip_lock = _step_holds_state_lock and not state.owned(). Verified that _step_holds_state_lock is set around agent.step() in both the sync and async run loops, that the ReactionExecutor itself only reads state (the agent emits the ReactionEvent from the observation on its own thread via follow_up_events()), and that the REST route executes conversation.react through run_in_executor exactly like send_message. The router catches tool ValueErrors → 400 and re-raises inactive_service, matching the existing precedent in event_router.py. The worker-thread test covers the deadlock case this avoids.
Client and docs. The TypeScript client additions (ReactionEvent/isReactionEvent, ConversationClient.react, SettingsClient.listFeatures/updateFeature) match the OpenAPI contract summary in the PR body, and the endpoint-audit config lists the three new endpoints as client-ahead with a tracking PR. Feature-map F37 was added with its F37.tool/F37-fail recipes.
Tests run in the workspace (head, no modifications): tests/tools/reaction, tests/agent_server/test_features_router.py, tests/agent_server/test_reactions_router.py — 24 passed; reaction/feature-selected tests/sdk subset — 262 passed.
One note outside the diff (not attachable inline): the Validate PR description check for this head is failing because the ## Issue Number section says None. while .github/scripts/check_pr_description.py requires a linked issue (Link an issue in the ## Issue Numbersection (e.g.Fixes #123). Newly opened issues must carry the ready-for-dev label.). This is description metadata, not code — adding an issue reference will clear the check before merge.
No material correctness, security, or design issues found on the current head.
✅ APPROVED
The user-facing feature flags are experimental features: list them with
GET /api/settings/experimental and switch one with PATCH
/api/settings/experimental/{key}. The TypeScript client methods become
listExperimentalFeatures and updateExperimentalFeature. This also keeps
clear of the operator-set Canvas feature policy (OpenHands/OpenHands#18843).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
Modules experimental_features and experimental_features_router, models ExperimentalFeature / ExperimentalFeatureDefinition / ExperimentalFeatureUpdate, the persisted field PersistedSettings.experimental_features, finalize(experimental_feature_tools=...), and the TypeScript ExperimentalFeature type, so every name says which flag system it belongs to. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
A Docker runtime's server had its own empty settings, so its conversations never got the reaction tools and the person's reactions always answered 409. The host now passes its switches to each container in OH_RUNTIME_EXPERIMENTAL_FEATURES, which pick the tools of conversations started there, and checks the live switch itself before forwarding a reaction. Also wraps three docstring lines over the line limit, and makes the F37 rest-default recipe fall back cleanly when the agent answered with finish. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
execute_tool skipped the state lock while a step held it, so two direct calls on worker threads could write events at once and leave one off the active branch. Their events now wait for the step to return and are written by the run loop, the way the step's own parallel tool calls hand theirs back. Outside a step it takes the state lock like send_message and react. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
execute_tool decided to defer before taking the queue lock, so a step could end and drain the queue in between, losing a reaction whose call had returned success. The decision and the append now happen under the queue lock, and the run loop clears the step flag and drains under the same lock. Also types the test worker's emoji as ReactionEmoji for pyright. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
Engel wants the Projects PR to carry every split-out PR's code until it merges, so everything can be tested together. #6609's reactions replace the earlier copy here: the conversation_reactions experimental feature, /api/settings/experimental, react/unreact given to conversations (workers included) when the feature is on, and the run-loop fix for direct tool calls' events. Also regenerates the TypeScript client contract. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJH94xGSYwfoyccT4E
A person's ReactionEvent now reaches the agent as one line: who reacted, the emoji, and the message, given as its last 500 characters behind "<clipped message start, if you need it find the message with the ending below>" when it is longer. The ending is saved on the event when the person reacts. Reacting still starts no run. The agent's own reactions stay out of what it sees, since its react call is already there. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJKhrR2viNUM9gjr89
Brings #6602's copy of reactions and feature flags in line with claude/project-thread-hb0du7 (#6609 on top of #6759): reactions placed before open tool calls, a source validator, no deferred events, tools not user-selectable, ExperimentalFeature without default, and main. Projects joins the new registry; tests turn it on by default through is_enabled. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJH94xGSYwfoyccT4E
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJKhrR2viNUM9gjr89
The merge of main committed conflict markers in four files: the TypeScript client's endpoint audit config and API client test, and the verify-agent-server F18 map and README. Each keeps the reactions side, which already contained the merged flags change. The tree now equals the branch as it was before the merge. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJKhrR2viNUM9gjr89
all-hands-bot
left a comment
There was a problem hiding this comment.
This review was posted by an AI agent (OpenHands).
Reviewed the reactions portion of this PR (the feature-flag plumbing it builds on was merged separately in #6759 and is in the base main here) against the repository review guide, AGENTS.md, and the package-level guidance.
Scope. In-scope for this repository: SDK event/tool/agent-loop behavior, the Agent Server REST surface, Docker runtime behavior, and the TypeScript client mirror. The linked issue #6621 is open, labeled ready-for-dev and priority:medium, and this PR delivers the agreed first feature (conversation_reactions, off by default) on top of the flag system.
Cross-layer completeness. Traced the change through every public entry point: ReactionEvent (with the agent/user source validator), react/unreact tools in openhands.tools.reaction (user_selectable = False), the Observation.follow_up_events() hook consumed in _execute_action_event and in the rerun path of LocalConversation, the View repositioning of reactions that arrive while tool calls await results, LocalConversation.react for the user path, POST /api/conversations/{id}/reactions with the 409 gate, the Docker runtime host checks plus OH_RUNTIME_EXPERIMENTAL_FEATURES forwarding, and the TypeScript client (ReactionEvent, isReactionEvent, ConversationClient.react) with its endpoint-audit exemption. The ACP path is intentionally left untouched, which finalize() documents and tests confirm.
Concurrency and lifecycle. EventService.react follows the existing send_message pattern (executor thread + conversation FIFO state lock). The View logic keeps the persisted event order intact while presenting the reaction to the LLM before open tool calls, covered by test_a_reaction_during_a_pending_tool_call_stays_out_of_the_call including the rebuild path through View.from_events. My one design note - after the person rejects a pending action, a reaction without target_event_id targets the agent's finish rather than the withdrawn message - is the documented latest-answer semantics, keeps the LLM view valid, and is not a demonstrated defect.
Compatibility. The OpenAPI contract change is additive (new route, new event/tool/observation schemas in unions). New event kind and tool downgrade risks are stated in the PR and gated behind an opt-in feature flag. Persisted settings shape is unchanged from main.
Tests and CI. In the workspace at head 80a69320: tests/tools/reaction, tests/agent_server/test_experimental_features_router.py, tests/agent_server/test_reactions_router.py, docker runtime registry/route tests, test_event_router.py, test_event_service.py, and tests/sdk/{context,event,conversation} all pass. CI on this exact head is green except the Build & Push Java image jobs, which are infrastructure builds unrelated to this diff. The only local failure I could reproduce (test_canvas_extension_backend) fails identically on a clean checkout of the PR head and touches no code this PR changes.
Eval note for the human maintainer: the react tool description guides when the agent reacts (notably +1 on mid-task corrections), which can alter agent behavior. The integration-test workflow passes on this head and the PR includes live model and upgrade evidence, so this does not withhold approval; flagging it for the maintainer's awareness.
No material correctness, security, compatibility, or acceptance-criterion defect found on the current head.
✅ APPROVED
all-hands-bot
left a comment
There was a problem hiding this comment.
This review was posted by an AI agent (OpenHands).
Fresh review at head 80a69320439c3fd991412011863533dfce6e451d against origin/main (56d559f6). Scope gate passed: conversation reactions live where they belong — SDK events/tools, agent-server routing, and the TypeScript client mirror — per AGENTS.md cross-repository boundaries. Linked issue #6621 is open with ready-for-dev / priority:medium.
CI on this head: all functional checks green (sdk-tests, agent-server-tests, cross-tests, integration-test, REST API/OpenAPI, endpoint-audit, security, TS 416 tests, pre-commit). The two failing jobs are Build & Push (java-amd64/arm64): the logs show Docker apt DNS failures (Could not resolve 'ports.ubuntu.com') inside the image build — an environment failure that also fails on unrelated branches, not attributable to this diff.
Workspace verification (no tracked files modified):
tests/tools/reaction+test_experimental_features_router.py+test_reactions_router.py: 38 passed, includingtest_a_reaction_during_a_pending_tool_call_stays_out_of_the_call.tests/agent_server/docker_runtime: 202 passed.tests/sdk/context,tests/sdk/event: 601 passed.clients/typescript: 416 passed.- Broader
tests/agent_serverrun had sandbox-environment failures; re-running the identical failing subsets onorigin/mainreproduced byte-identical failure sets (launch parity, agent launch additions, credential binding — the sandbox injectsGITHUB_TOKEN_REVIEWinto secret refs — and canvas-extension backend tests). Pre-existing on main, unrelated to this PR.
Material findings: none. Cross-layer trace is complete: ReactionEvent with agent/user-only source validation, tool-gated via experimental_feature_tools at finalize (ACP excluded), user_selectable = False so settings don't offer the tools, View correctly moves a person's reaction that arrives during pending tool calls before the open calls (LLM history constraint), follow_up_events() keeps the executor read-only for parallel-tool safety with the rerun path covered, and the Docker dual-path gating is sound: the container trusts OH_RUNTIME_EXPERIMENTAL_FEATURES only for a request the host already gated (tail == "reactions" + POST check in proxy_conversation), verified by test_reactions_follow_the_host_switch_before_reaching_the_runtime. Compatibility is additive (new event kind, new tools, settings field documented as within-v7 with downgrade behavior), and the OpenAPI contract summary in the PR matches the diff. The eval risk of new react tool descriptions is noted for the human maintainer; the integration-test check passed on this head.
✅ APPROVED
A person's reaction that arrives while tool calls are open (a pending confirmation, a pause) is no longer written between a call and its result and then moved in the View. The conversation keeps it in memory and emits it once every open call is answered, so the event log itself is always in an order a model API accepts. View no longer reorders anything. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJKhrR2viNUM9gjr89
…f5ef) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJH94xGSYwfoyccT4E
all-hands-bot
left a comment
There was a problem hiding this comment.
This review was posted by an AI agent (OpenHands).
Fresh review at head d5bf5ef91103ff8506e3a192329663d478990631 against origin/main (56d559f6). Scope gate passed: the reactions feature sits where it belongs (SDK events/tools, agent-server routing, TypeScript client mirror) per AGENTS.md ownership boundaries. Linked issue #6621 is open with ready-for-dev / priority:medium.
CI on this head: all 51 checks green — including the Build & Push docker jobs that failed on DNS in the previous run; they pass now. The macOS suite line is a skip, not a failure.
Workspace verification (no tracked files modified):
tests/tools/reaction+test_experimental_features_router.py+test_reactions_router.py: 38 passed, including the renamedtest_a_reaction_during_a_pending_tool_call_waits_for_its_result.tests/agent_server/docker_runtime+tests/sdk/context+tests/sdk/event: 744 passed, 1 skipped.clients/typescript: 416 passed.
The new hold-back design is sound. The head replaces the previous View reordering with holding a person's reaction in memory while tool calls wait, then emitting it once every open call is answered — so the event log itself is always in a valid order and View no longer special-cases reactions. Verified on the current code:
- Locking: the run loop holds the conversation state lock across
agent.step()(RLock; the#3485comment marks the step as lock-holding), so_flush_pending_reactions— which fires inside the callback chain when the observation is emitted — is serialized againstreact(), which appends underwith self._state. The reentrant lock makes the flush's recursive_on_eventsafe. - No deadlock while waiting: during
WAITING_FOR_CONFIRMATIONthe run loop breaks out of thewith self._stateblock and returns, releasing the lock, so RESTreact()cannot block on the run thread. - Flush correctness: the flush triggers on any
ObservationBaseEvent(coversObservationEventandUserRejectObservation) only whenget_unmatched_actionsis empty; the list swap before iteration prevents re-entrant double-flush; the recursive emission runs the full composed chain, so held reactions are persisted and published. - Ordering/id: the restamp at flush time (
model_copy(update={"timestamp": ...})) keeps log order = timestamp order while preserving the event id; the test assertsActionEvent, ObservationEvent, ReactionEvent, ReactionEvent, id stability, and a validassistant/tool/usermessage history for the next model call. - Edge behavior: reactions held through an error or pause flush on the next observation — consistent with "the agent sees the person's reaction on its next turn". The restart-drops-a-held-reaction trade-off is documented and matches the in-memory design.
The previous View-based special casing was removed cleanly, execute_tool is back to the main shape, and the rest of the feature (feature gating, Docker dual-path, TS client, additive OpenAPI surface) is unchanged from the earlier reviews of this PR and still holds up.
Material findings: none.
✅ APPROVED
The codebase calls them the user everywhere (source="user"). This renames the wording in docstrings, comments, test names, the tool descriptions and the line the agent reads: "[The user reacted ...]". Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJKhrR2viNUM9gjr89
Takes Engel's react tool description edit from main; the rest of the reactions code here already matched #6609 as merged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwJH94xGSYwfoyccT4E
- S16.reactions: the react/unreact tools and ReactionEvent (#6609), scripted and live; S16 now owns openhands-tools/reaction. - S11.task-secrets (known failure #6724) and S17.schema-constraints (known failure #6766): open bugs filed since the baseline, reproduced. - S21: the ask_agent fork-cost and timeout-resend known failures link #6646 and #6645; the live handshake lists today's adapter versions. - S14: the tmux pane-pool gotcha states today's behavior (#6752). - History notes removed from S14, S15 and S17. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013ArwwNZe7p1P7oMgnFNYcy
Fifty files conflicted, most of them with #6780 (domain errors), which rewrote the raises in every router this branch rewrote the lookups of. Each conflict keeps main's errors, responses and new behaviour and this branch's injected dependencies. Code main added since the branch point that used lookups this branch removed now takes its dependencies like the rest: - experimental features (#6759): the routes take the settings store through Depends(get_settings_store). - conversation reactions (#6609): require_reactions_enabled takes a settings store; the route injects it and the Docker proxy passes the registry's. - pull request status (#6704): get_provider_pull_request takes the secrets store. - trajectory download (#5766): uses the injected config. - DockerConversationRegistry and the OpenAI gateway read experimental features from their own ServerStores. Code that exists only on this branch raises domain errors too (dependencies.py, init_router.py, vscode_router.py); a WebSocket that finds no service still closes with 1013. Tests main added for these features build their stores per test instead of reading a process-wide one.
HUMAN:
AGENT:
Why
Conversation reactions is the first experimental feature a user can turn on: the agent can put an emoji on a message (for example 👀 when the work comes before the answer), and the person can react to the agent's messages. The switches themselves were merged in #6759; this PR is reactions on top of them, and nothing else.
Summary
conversation_reactions, off by default), registered inopenhands.agent_server.experimental_features. While it is on, every new OpenHands-agent conversation getsreact/unreactthroughfinalize(experimental_feature_tools=...). ACP agents are left as they are. While it is off,POST /api/conversations/{id}/reactionsanswers 409. Turning it off does not take the tools from conversations started while it was on.ReactionEvent(target_event_id,emoji,removed,source), thereact/unreacttools inopenhands.tools.reaction, theObservation.follow_up_events()hook,LocalConversation.react, and the REST route. The agent sees the person's reactions on its next turn, as one line naming the emoji and the end of the message; its own reactions are not repeated to it.OH_RUNTIME_EXPERIMENTAL_FEATURESand checks the reactions route itself before forwarding.ReactionEvent,isReactionEvent,ConversationClient.react.Changes after a fresh review (2026-11-11)
Viewreorders nothing. The route still answers 200 with the event at once; a server restart during the wait drops a held reaction.reactandunreactare no longer offered as selectable tools in agent settings (user_selectable = False); the feature gives them.execute_toolis back to what it is onmain: it returns the observation and records nothing. The deferral queue this PR had added to the run loop had no caller.ReactionEvent'ssourcemust be the agent or the user.defaultfield.REST API contract changes
Compared with base OpenAPI
56d559f66ac0for public/api/**paths.Issue Number
Closes #6621
How to Test
uv run pytest tests/tools/reaction tests/agent_server/test_experimental_features_router.py tests/agent_server/test_reactions_router.py: passes, includingtest_a_reaction_during_a_pending_tool_call_waits_for_its_result: the reaction stays out of the log while the call is open and follows its result.uv run pytest -n 8 tests/tools/reaction tests/agent_server tests/sdk/context tests/sdk/event tests/sdk/conversation: 4711 passed, 2 failed.test_exited_leader_descendant_does_not_block_recovery[status]also fails onmainin this sandbox (process reaping);test_file_legacy_routes_are_removed_from_openapifailed only under-n 8and passes alone.clients/typescript: 416 tests pass;npm run audit:endpointspasses.control-agent-server map run --fresh --file F37: 7/7 pass, twice, includingF37.rest-while-confirming(react while a call waits: noReactionEventin the log yet; accept; the reaction is saved after the result and the run finishes with exactly the two commands asked for and no condensation).AlwaysConfirm): the held reaction lands asActionEvent, ObservationEvent, ReactionEvent, the next model call succeeds, and the agent names the 👍 and the message it was on.main+ this PR: a 1.62.0 user's settings, profiles, secret and conversation load unchanged; the old conversation continues without the tools; with the feature on a new conversation gets them and the agent reacts; the person's ❤️ on the 1.62.0-era conversation is seen by the agent on its next turn; restart, feature off, restart: every conversation restores and keeps working. A new user with no settings does the same.Video/Screenshots
API only. Screenshots are in OpenHands/OpenHands#19503.
Type
Notes
ReactionEventis a new event kind andreact/unreactare new tools. On a server older than this PR a reaction in a conversation reads as an unreadable event, and a conversation started with the feature on opens but cannot continue (its tools are not registered there). An older remote client cannot parse a conversation once it holds a reaction. All of this needs the feature turned on first.reacttool description says when each emoji fits, most of all +1 first when the person corrects or changes the plan mid-task. Changing a tool description normally warrants theintegration-testlabel.🤖 Generated with Claude Code
https://claude.ai/code/session_013ArwwJ5sQMXhwgSTG2Ztkt
🐳 Agent Server images for this PR — GHCR package, pull/run commands, and all pushed tags (click to expand)
• GHCR package: https://github.com/OpenHands/agent-sdk/pkgs/container/agent-server
Variants & Base Images
eclipse-temurin:17-jdkpython-node-runtimepython-node-runtimepython-node-runtimegolang:1.21-bookwormPull (multi-arch manifest)
# Each variant is a multi-arch manifest supporting both amd64 and arm64 docker pull ghcr.io/openhands/agent-server:82d61a2-pythonRun
All tags pushed for this build
About Multi-Architecture Support
82d61a2-python) is a multi-arch manifest supporting both amd64 and arm6482d61a2-python-amd64) are also available if needed