| Filename | Latest commit message | Latest commit date |
|---|---|---|
f9c6a56ab9
opencode answers `end_turn` even when its provider rejected the request with a non-retryable error (401, 400), and forwards nothing over ACP, so the turn looked like an empty success. A turn that ends with `end_turn`, no event, no `usage_update` and no `usage` in the prompt response now fails with `AcpError::EmptyEndTurn`. A turn that really produced nothing and reported no usage is reported the same way; that false positive is accepted. The test agent's plain `end_turn` replies now carry a response `usage`, so its ordinary turns stay successes; a response `usage` feeds only cost telemetry, not the compaction watermark. A new `blank` mode keeps the empty reply for the error case. |
||
| .. | ||
| src | ||
| Cargo.toml | ||
| README.md | ||
hive-runtime
The layer an agent's turns are driven through: one Runtime interface
(run, compact, archive, canceller) with a backend per runtime.
- claude —
claude --printthrough thehive-claudecrate'sInfiniteSession. A pass-through: same spawn, same session handling, same errors. - acp — any Agent Client Protocol
agent, spawned from a command, args and env handed to it (
RuntimeSpec, read fromHIVE_RUNTIME/HIVE_ACP_COMMAND/HIVE_ACP_ARGS/HIVE_ACP_ENV). It knows no agent by name; which agent runs, and how it is configured, is decided in nix (services.hyperhive.agent.runtime,services.hyperhive.agent.acp.*).
Both backends report a turn through hive_claude::Sink in claude's
stream-json shape. The ACP backend translates session/update
notifications into it (text and thought chunks as whole blocks, tool calls as
tool_use + tool_result, MCP tools named mcp__<server>__<tool>), so the
harness's stream consumers read either backend unchanged. Context usage comes
from ACP usage_update.
The crate depends on no hyperhive binary crate, so hive-agent and
hive-subagent-mcp can both drive turns through it.
ACP backend: what it needs from the agent
mcpCapabilities.httpin itsinitializeresponse. The hyperhive tools are only served over HTTP, so an agent without it is refused at startup.loadSession, to pick its session back up after a harness restart. Without it every restart starts a new session.
ACP backend: stopping a turn
A turn is stopped with session/cancel: by the Canceller handle, or by the
idle watchdog once no session/update has arrived for
Config::idle_timeout. An agent that has not answered the prompt 10s later
is killed, and the next turn respawns it. A watchdog stop fails the turn
with AcpError::IdleTimeout (IdleKilled if the agent was killed). This is
the only way a provider error the agent retries without reporting it, such as
an HTTP 429, ends the turn.
ACP backend: compaction
The same CompactionPolicy as the claude backend decides when: after a turn
past the watermark, or on compact (the operator's /compact, the agent's
compact tool).
- If the agent advertises a
compactcommand (available_commands_update), it is sent as the prompt/compacton the same session, as the ACP spec runs any advertised command. A proactive compaction runs the policy's checkpoint turn first, as on claude. - Otherwise the policy's checkpoint turn runs, then the session is archived, and the next turn starts a new one, carrying the system prompt again.
- A
compactcommand that fails, or sends nothing for 180s (the turn's idle window if that is shorter), is cancelled and handled as the case above; the checkpoint turn is not run a second time. So a compaction always leaves a smaller session behind, and a failed one is not retried on the next turn.