Module session 

Server-side session state — shared across all connections.

Structs

ApprovalGate

Builder for constructing a ServerState with embedder-supplied dependencies. Embedders (e.g. tokhn-daemon) use this to inject their own memgine handle and other shared infrastructure; the Approval-gate policy for high-risk WS methods.

ChatCollector

An in-process agent.chat collector entry: the sink that try_forward_agent_chat_event feeds, plus the host client whose disconnect should abandon it. Holding the sole sender here means dropping the entry closes the stream, so the collecting task wakes immediately instead of waiting out its timeout.

ChatGoalState

Host-visible standing goal for a chat session. goal.set stores this keyed by session_id; agents.chat reuses it for that session when the turn does not pass an inline goal.

ChatSession

In-flight agents.chat session bookkeeping. Created when a host client calls agents.chat, removed when the agent emits a terminal agent.chat.event (kind: "done" or "error"), when either side disconnects, or when the host cancels via agents.chat.cancel.

ChatStreamChunk

One normalized chunk of an agent.chat stream, delivered to an in-process chat_collectors sink (the A2A bridge). A token chunk carries a delta; a terminal chunk has kind "done" (success), "error" (with error text), or "auth_required" (with message text — the turn was refused because of the Parslee account, and nothing follows it on the wire).

ClientSession

Per-client session.

LastChatTurn

The last assistant turn a chat session produced, remembered so the next user turn can be classified against it (the conversation-outcome signal). The trace_id/model_id are carried straight from the InferenceResult that produced the turn — never reconstructed from message order — so credit always lands on the exact model/trace that generated the judged turn.

OrgSyncHolder

The opted-in shared org-scope delivery subsystem + which org it serves. See ServerState::org_sync. Held behind the same std::sync::Mutex as the personal subsystem holder (init is serialized by the oplog’s advisory lock); the subsystem itself lives behind a tokio::sync::Mutex.

RunMeta

Daemon-side record of a single agent run (agent run tracing, U1).

ServerState

Global server state shared across all connections.

ServerStateConfig

standalone car-server binary uses ServerState::standalone which calls with_config under the hood.

SubstrateShadowExecutor

Executor wrapper used only by substrate-bound sessions (session.bindSubstrate). It is the low-blast-radius “option (a)” from docs/execution-substrate.md §3: keep the existing share_with_fallback(ws_executor) composition intact for connector routes and host tool callbacks, but for the bare substrate-owned built-in names ([SUBSTRATE_OWNED_TOOLS]) return an "unknown tool: <name>" error so the engine’s dispatch (executor.rs) takes the fall_through branch and routes those names to the runtime’s bound substrate (the connector/VM car_engine::McpSubstrate) instead of the WS client.

WsChannel

Shared write half of the WebSocket, plus pending callback channels. write is type-erased via WsSink so the dispatcher can run against any transport-specific WebSocketStream (TCP or UDS today; axum-bridged in future) without templatizing every consumer.

WsMemgineIngestSink

Per-meeting fanout sink that ingests transcript text into a session-scoped memgine using the Arc<tokio::sync::Mutex<...>> wrapper, then forwards every event upstream untouched.

WsToolExecutor

Tool executor that sends callbacks to the client over WebSocket.

WsVoiceEventSink

Voice event sink that forwards events to a specific WebSocket client as voice.event JSON-RPC notifications.

Enums

A2aRouteAuth

Server-side credentials for continuing an A2A-owned A2UI surface.

RecordRunTurnsOutcome

Outcome of ServerState::record_run_turns — distinguishes the three reasons a batch can fail to land so the caller maps each to the right runs.record_turns drop reason (ADV-1). Before this enum the function returned a bare usize (the new total, or 0 for “nothing appended”), which collapsed an under-lock CEILING refusal and an unknown/terminal run into the same 0 — the handler then mislabeled a ceiling refusal as run_terminal.

RunReservation

Constants

DEFAULT_TOOL_TIMEOUT_MS

Default ceiling for the daemon→host tools.execute callback wait when an action carries no explicit timeout_ms. Overridable via CAR_TOOL_TIMEOUT (seconds). Raised from the old hardcoded 60s — real tools (build steps, CLI drivers, slow APIs) routinely run longer, and a 60s ceiling reaped them regardless of the agent’s budget (Parslee-ai/car#259).

RECORD_TURNS_RUN_CEILING

Per-run turn ceiling — a runaway-loop backstop sized well above any healthy main-agent-only cycle (tens of turns), never a trimmer. This is a TRUE hard cap, and it is enforced HERE — inside ServerState::record_run_turns, under the runs lock — not only in the WS handler’s pre-check. The handler keeps a fast-path pre-check off a lock-free snapshot, but the dispatcher spawns a task per frame, so pipelined runs.record_turns batches can all read a sub-ceiling snapshot and pass that pre-check before any of them appends. Only the under-lock check below is atomic with the append, so it is the one that actually bounds the run (ADV-1). A batch that would take the run PAST this many recorded turns is refused WHOLE.

RUN_COMPLETE_GRACE

Grace window applied on disconnect before a still-open run is marked Incomplete (agent run tracing, U1 — R5). Short on purpose: it only has to cover the gap between a healthy runs.complete being dispatched on a spawned task and its terminal record landing, not any real work. Long enough to absorb that scheduling jitter, short enough that a genuinely abandoned run is reported Incomplete promptly.

RUN_DISCONNECT_CLEANUP_TIMEOUT

Per-run observation bound for disconnect cleanup: the ten-second resume lease, two bounded five-second journal acknowledgement attempts (the second is an exact retry after durability-unknown), and scheduler headroom. Cleanup never clears the run or binding unless an acknowledgement arrives.

RUN_RESUME_LEASE

Bounded in-process lease for a disconnected run whose producer negotiated runs.resume.v1. Ten seconds leaves practical headroom for a loaded Mac’s Python controller to establish a fresh local socket, authenticate, and negotiate capabilities without turning this into restart recovery. Runs without the capability keep the original 250 ms behavior; an unclaimed resumable run still becomes Incomplete.

SESSION_HALTED_REASON

Stable admission reason returned after a callback terminally halts its WebSocket session. The halt is intentionally connection-local and dies on reconnect; durable run outcomes remain the responsibility of runs.complete.

Type Aliases

WsSink

Type-erased WebSocket sink. The dispatch loop accepts either a WebSocketStream<TcpStream> (the legacy car-server TCP listener) or a WebSocketStream<UnixStream> (the daemon-as-default UDS listener) — both implement Sink<Message, Error = WsError> after the tungstenite handshake. Erasing the type here avoids cascading a generic parameter through every WsChannel / Session / ServerState touchpoint in the dispatcher.