AgentServerAdapter

Shuts down the transport and releases any underlying resources.

Streams incoming protocol messages from the remote peer. Used by WebSocket transports where all events share one connection.

Fetch a slice of checkpoint history for the bound thread. Used by branching and time-travel UIs. Optional — omitting it turns those UIs into no-ops rather than surfacing an error.

Fetch the latest checkpointed state for the bound thread via GET /threads/:threadId/state (or an adapter-specific override). When omitted, StreamController.hydrate falls back to client.threads.getState().

Opens the underlying connection (e.g. WebSocket handshake). For HTTP/SSE transports this is a no-op.

Opens an independent filtered SSE event stream. Each call creates a new server connection with the given filter. Returns undefined when the transport does not support per-subscription streams (e.g. WebSocket), in which case the caller should fall back to command-based subscriptions over events.

Replay contract. Implementations MUST buffer events emitted for the thread/run and replay them through every newly-opened stream whose filter matches. The SDK's shared-stream rotation relies on this: when a subscription's filter widens the union, the SDK opens a fresh stream and expects to receive the run's full history from seq=0 (deduplication is handled client-side via event_id). The SDK also defers the open until after run.start has committed the thread server-side to avoid a 404: Thread not found, which means events emitted during that window MUST be delivered to the late opener. The protocol v2 server implements this via a bounded per-run replay buffer; custom adapters should mirror that.

Sends a command and optionally returns an immediate response.

Rebind this transport to a different thread.

client.threads.stream(threadId, { transport }) calls this (when implemented) whenever the framework binds or re-binds the active thread — including the lazily-minted id from the first submit() on a threadId: null controller. Implementing it lets an adapter be constructed once (optionally with no threadId) and reused as the active thread becomes known, so the framework doesn't have to tear down and rebuild a custom transport when the thread id appears.

Optional: adapters that bake threadId at construction can omit it, in which case the per-call threadId is ignored (prior behaviour).