car-server-core 0.30.0

// Raise the recursion limit so the deeply-nested async block at the
// `accept_async` -> `run_dispatch` call site doesn't trip the rustc
// query-depth limit on Windows / Linux. The default 128 is fine on
// macOS but the larger query graph on the other platforms pushes
// through the threshold; 256 has comfortable headroom. (Same fix
// `car-server` carries; the library inherits the same call-site
// shape.)
#![recursion_limit = "512"]

//! Transport-neutral library extracted from `car-server`.
//!
//! Holds the JSON-RPC dispatcher, per-client session state, and the
//! WebSocket channel plumbing. The standalone `car-server` binary is
//! a thin wrapper that loads `~/.car/env`, initializes telemetry,
//! spawns the dream loop, binds a TCP listener, and on each
//! connection calls [`run_dispatch`].
//!
//! Embedders (e.g. the future `tokhn-daemon` at U7) construct a
//! [`ServerState`] via [`ServerState::embedded`] (or
//! [`ServerStateConfig`] for advanced wiring), accept WebSocket
//! connections in their own listener, and call [`run_dispatch`]
//! directly — without re-implementing the dispatcher.
//!
//! ## Library boundary contract
//!
//! Per the U1 plan, this library MUST NOT:
//! - spawn the dream loop (caller decides),
//! - initialize telemetry (caller decides),
//! - load `~/.car/env` (caller decides).
//!
//! Those bootstraps stay in the embedder's `main`. This contract
//! prevents the dual-memgine bug U7 mitigates: if the library
//! silently spawned its own dream loop, embedded users would end up
//! with two memgine engines (the embedder's plus the library's).
//!
//! ## Lock primitive
//!
//! `ClientSession.memgine` uses `Arc<tokio::sync::Mutex<MemgineEngine>>`
//! per the "one-wrapper rule" — dispatcher handlers can hold the lock
//! across `.await` points without risking poisoning, and tokio's
//! `Mutex` does not poison so a panicking handler does not poison the
//! engine for sibling connections.

pub mod a2a;
pub mod admission;
pub mod approval_core;
pub mod channel;
pub mod coder;
pub mod fanout;
pub mod handler;
pub mod host;
pub mod mcp;
pub mod meeting;
pub mod messaging_config;
pub mod messaging_orchestrator;
pub mod slack_adapter;
pub mod parslee_auth;
pub mod parslee_capabilities;
pub mod parslee_m365;
pub mod parslee_tools;
pub mod run_store;
pub mod run_trace;
pub mod session;
pub mod ui_agent_loop;
pub mod voice_turn;

pub use admission::{InferenceAdmission, ENV_MAX_CONCURRENT};
pub use handler::{
    handle_connection, reconcile_os_schedules_at_boot, recover_workflow_checkpoints,
    run_concierge_check, run_dispatch, run_idle_backend_eviction, run_upgrade_nudge_check,
    JsonRpcError, JsonRpcMessage, JsonRpcResponse,
};
// Unix-only — the underlying `tokio::net::UnixStream` doesn't exist
// on Windows. Mirror the cfg gate on the function definition itself
// so consumers that need both transports gate their call sites
// the same way (`car-server::main::uds_accept_loop` already does).
#[cfg(unix)]
pub use handler::handle_connection_unix;
pub use approval_core::{ApprovalCore, ResolveOutcome};
pub use channel::{ChannelConfig, ChannelId, InboundChannel, InboundSink, SlackTokenRef};
pub use fanout::FanoutCoordinator;
pub use messaging_orchestrator::{
    spawn_channel_pollers, MessageSender, MessagingOrchestrator, RealMessageSender,
};
pub use slack_adapter::{
    build_ack_frame, parse_events_api, parse_interactive, parse_socket_frame,
    parse_socket_url_response, SlackAdapter, SlackInboundEvent, SlackTransport,
};
pub use run_store::{
    RetentionConfig, RunStatus, RunStore, RunSummary, DEFAULT_MAX_AGE_DAYS,
    DEFAULT_MAX_RUNS_PER_AGENT,
};
pub use run_trace::record_turns;
pub use session::{
    ApprovalGate, ClientSession, RecordRunTurnsOutcome, RunMeta, ServerState, ServerStateConfig,
    WsChannel, WsMemgineIngestSink, WsSink, WsToolExecutor, WsVoiceEventSink,
    RECORD_TURNS_RUN_CEILING, RUN_COMPLETE_GRACE,
};