Struct LeanCtxServer 

pub struct LeanCtxServer {

    pub cache: SharedCache,
    pub session: SessionSlot,
    pub tool_calls: Arc<RwLock<Vec<ToolCallRecord>>>,
    pub call_count: Arc<AtomicUsize>,
    pub background_tick: Arc<AtomicUsize>,
    pub cache_ttl_secs: u64,
    pub last_call: Arc<RwLock<Instant>>,
    pub agent_id: Arc<RwLock<Option<String>>>,
    pub task_envelope: Arc<RwLock<Option<TaskEnvelopeV1>>>,
    pub native_receipt_authority: Option<Arc<HostReceiptAuthority>>,
    pub presence_agent_id: Arc<RwLock<Option<String>>>,
    pub client_name: Arc<RwLock<String>>,
    pub autonomy: Arc<AutonomyState>,
    pub loop_detector: Arc<RwLock<LoopDetector>>,
    pub workflow: Arc<RwLock<Option<WorkflowRun>>>,
    pub ledger: Arc<RwLock<ContextLedger>>,
    pub pipeline_stats: Arc<RwLock<PipelineStats>>,
    pub session_mode: SessionMode,
    pub workspace_id: String,
    pub channel_id: String,
    pub context_os: Option<Arc<ContextOsRuntime>>,
    pub context_ir: Option<Arc<RwLock<ContextIrV1>>>,
    pub registry: Option<Arc<ToolRegistry>>,
    /* private fields */
}

Central MCP server state: cache, session, metrics, and autonomy runtime.

Fields

cache: SharedCache

session: SessionSlot

tool_calls: Arc<RwLock<Vec<ToolCallRecord>>>

call_count: Arc<AtomicUsize>

background_tick: Arc<AtomicUsize>

Every tool call, counted unconditionally at the top of call_tool_guarded.

call_count only advances inside record_checkpoint, which returns early whenever checkpointing is skipped — and minimal_overhead (default true) skips it for every tool. Anything scheduled off call_count therefore never runs in a default install. The daily telemetry flush was scheduled that way and consequently never sent.

cache_ttl_secs: u64

last_call: Arc<RwLock<Instant>>

agent_id: Arc<RwLock<Option<String>>>

task_envelope: Arc<RwLock<Option<TaskEnvelopeV1>>>

native_receipt_authority: Option<Arc<HostReceiptAuthority>>

Installed by the trusted host before serving; never sourced from tool arguments.

presence_agent_id: Arc<RwLock<Option<String>>>

client_name: Arc<RwLock<String>>

autonomy: Arc<AutonomyState>

loop_detector: Arc<RwLock<LoopDetector>>

workflow: Arc<RwLock<Option<WorkflowRun>>>

ledger: Arc<RwLock<ContextLedger>>

pipeline_stats: Arc<RwLock<PipelineStats>>

session_mode: SessionMode

workspace_id: String

channel_id: String

context_os: Option<Arc<ContextOsRuntime>>

context_ir: Option<Arc<RwLock<ContextIrV1>>>

registry: Option<Arc<ToolRegistry>>

Implementations

impl LeanCtxServer

pub async fn call_tool_guarded( &self, request: CallToolRequestParams, ) -> Result<CallToolResult, ErrorData>

A call keeps the session instance it was bound to once its roots were resolved, so a root change while it runs cannot redirect its late writes into the next project’s session (AP04-G1).

impl LeanCtxServer

pub fn guard_egress( guard_name: &str, guard_args: Option<&Map<String, Value>>, agent_id: &str, ) -> Option<CallToolResult>

Egress DLP on agent writes and actions. A block is a tool error, audited for agent_id.

impl LeanCtxServer

pub fn new() -> Self

Creates a new server with default settings, auto-detecting the project root.

pub fn new_with_project_root(project_root: Option<&str>) -> Self

Creates a new server rooted at the given project directory.

pub fn new_shared_with_context( project_root: &str, workspace_id: &str, channel_id: &str, ) -> Self

Creates a new server in Context OS shared mode for a specific workspace/channel.

pub async fn check_idle_expiry(&self)

Clears the cache and saves the session if the TTL idle threshold has been exceeded.

pub fn idle_ttl(&self) -> Duration

Idle TTL of the read cache (memory_cleanup / LEAN_CTX_CACHE_TTL); 0 = off.

pub async fn release_idle_memory(&self)

Release what an idle server holds without waiting for the next call: the read cache (as check_idle_expiry would), the resident indexes and the allocator’s free pages. Everything reloads on demand. Restarts the TTL so the next call does not clear (and count) the cache a second time.

pub async fn shutdown(&self)

Aggressive cleanup on connection drop: save session, consolidate knowledge, clear caches.

Order and bounds: the host that closed the connection waits a bounded time and then kills the process. What must not be lost comes first — the session’s last state — and what only enriches later sessions (the knowledge consolidation) runs afterwards within SHUTDOWN_ENRICHMENT. With a semantic detector bound it re-admits the session’s text through the model; run first and unbounded, it kept the server alive beyond the host’s wait while the last state was still to be saved. The consolidation reads the SAVED session, so it also belongs after the save.

impl LeanCtxServer

pub async fn record_call( &self, tool: &str, original: usize, saved: usize, mode: Option<String>, )

Records a tool call’s token savings without timing information.

pub async fn record_call_with_path( &self, tool: &str, original: usize, saved: usize, mode: Option<String>, path: Option<&str>, duration_ms: u64, )

Records a tool call like record_call, but includes an optional file path for observability and the measured handler duration (#1020 — the duration is what makes the row land in tool-calls.log).

pub async fn record_call_with_timing( &self, tool: &str, original: usize, saved: usize, mode: Option<String>, duration_ms: u64, )

Records a tool call’s token savings, duration, and emits events and stats.

pub async fn publish_value_snapshot(&self)

Folds security events recorded outside record_call (e.g. injection flags found after the handler) into the session and republishes the value snapshot, so the status line never lags a blocked or flagged call.

pub fn increment_and_check(&self) -> bool

Increments the call counter and returns true if a checkpoint is due.

pub async fn auto_checkpoint(&self) -> Option<String>

Generates a compressed context checkpoint with session state and multi-agent sync.

pub fn append_tool_call_log( tool: &str, duration_ms: u64, original: usize, saved: usize, mode: Option<&str>, timestamp: &str, )

Appends a tool call entry to the rotating tool-calls.log file.

pub async fn record_cep_snapshot(&self)

Persists a CEP (Cognitive Efficiency Protocol) score snapshot for analytics.

impl LeanCtxServer

pub fn checkpoint_interval_effective() -> usize

pub async fn resolve_path(&self, path: &str) -> Result<String, String>

Resolves a (possibly relative) tool path against the session’s project_root. Absolute paths and “.” are returned as-is. Relative paths like “src/main.rs” are joined with project_root so tools work regardless of the server’s cwd.

pub async fn resolve_path_or_passthrough(&self, path: &str) -> String

Like resolve_path, but returns the original path on failure instead of an error.

Trait Implementations

impl Clone for LeanCtxServer

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for LeanCtxServer

fn default() -> Self

Returns the “default value” for a type.

impl ServerHandler for LeanCtxServer

fn get_info(&self) -> ServerConfig

async fn initialize( &self, request: InitializeRequestParams, context: RequestContext<RoleServer>, ) -> Result<InitializeResult, ErrorData>

async fn list_tools( &self, _request: Option<PaginatedRequestParams>, _context: RequestContext<RoleServer>, ) -> Result<ListToolsResult, ErrorData>

fn list_prompts( &self, _request: Option<PaginatedRequestParams>, _context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<ListPromptsResult, ErrorData>>

async fn get_prompt( &self, request: GetPromptRequestParams, _context: RequestContext<RoleServer>, ) -> Result<GetPromptResponse, ErrorData>

fn list_resources( &self, _request: Option<PaginatedRequestParams>, _context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<ListResourcesResult, ErrorData>>

async fn read_resource( &self, request: ReadResourceRequestParams, _context: RequestContext<RoleServer>, ) -> Result<ReadResourceResponse, ErrorData>

async fn call_tool( &self, request: CallToolRequestParams, context: RequestContext<RoleServer>, ) -> Result<CallToolResponse, ErrorData>

Handle a tools/call request from a client.

async fn on_roots_list_changed(&self, _context: NotificationContext<RoleServer>)

fn ping( &self, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<(), ErrorData>> + MaybeSendFuture

fn negotiate_initialize( &self, request: &InitializeRequestParams, ) -> Result<InitializeResult, ErrorData>

Build the initialize response for request, negotiating the protocol version against Self::supported_protocol_versions.

fn supported_protocol_versions(&self) -> Cow<'static, [ProtocolVersion]>

Return the protocol versions supported by this server.

fn discover( &self, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<DiscoverResult, ErrorData>> + MaybeSendFuture

Return this server’s discovery information.

fn complete( &self, request: CompleteRequestParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<CompleteResult, ErrorData>> + MaybeSendFuture

fn set_level( &self, request: SetLevelRequestParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<(), ErrorData>> + MaybeSendFuture

fn list_resource_templates( &self, request: Option<PaginatedRequestParams>, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<ListResourceTemplatesResult, ErrorData>> + MaybeSendFuture

fn accepted_subscription_filter( &self, requested: &SubscriptionFilter, ) -> Option<SubscriptionFilter>

Return the subset of a requested notification filter this server accepts.

fn listen( &self, context: SubscriptionContext, ) -> impl Future<Output = Result<(), ErrorData>> + MaybeSendFuture

Run one established subscription until it is cancelled or closed gracefully.

fn subscribe( &self, request: SubscribeRequestParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<(), ErrorData>> + MaybeSendFuture

👎Deprecated:

resources/subscribe is legacy-only; implement accepted_subscription_filter and listen for protocol version 2026-07-28

fn unsubscribe( &self, request: UnsubscribeRequestParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<(), ErrorData>> + MaybeSendFuture

👎Deprecated:

resources/unsubscribe is legacy-only; subscriptions/listen is cancelled through its request lifecycle

fn get_tool(&self, _name: &str) -> Option<Tool>

Get a tool definition by name.

fn on_custom_request( &self, request: CustomRequest, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<CustomResult, ErrorData>> + MaybeSendFuture

fn on_cancelled( &self, notification: CancelledNotificationParam, context: NotificationContext<RoleServer>, ) -> impl Future<Output = ()> + MaybeSendFuture

fn on_progress( &self, notification: ProgressNotificationParam, context: NotificationContext<RoleServer>, ) -> impl Future<Output = ()> + MaybeSendFuture

fn on_initialized( &self, context: NotificationContext<RoleServer>, ) -> impl Future<Output = ()> + MaybeSendFuture

fn on_custom_notification( &self, notification: CustomNotification, context: NotificationContext<RoleServer>, ) -> impl Future<Output = ()> + MaybeSendFuture

fn get_task( &self, request: GetTaskParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<GetTaskResult, ErrorData>> + MaybeSendFuture

SEP-2663 tasks/get: return the current DetailedTask state.

fn update_task( &self, request: UpdateTaskParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<(), ErrorData>> + MaybeSendFuture

SEP-2663 tasks/update: accept responses to outstanding in-task input requests. Returns an empty acknowledgement on success.

fn cancel_task( &self, request: CancelTaskParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<(), ErrorData>> + MaybeSendFuture

SEP-2663 tasks/cancel: cooperative cancellation. Returns an empty acknowledgement; the task’s observable status may lag.

fn list_skills( &self, request: Option<PaginatedRequestParams>, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<ListSkillsResult, ErrorData>> + MaybeSendFuture

SEP-2640 skills/list: one page of the skills this server serves.

fn get_skill( &self, request: GetSkillRequestParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<GetSkillResult, ErrorData>> + MaybeSendFuture

SEP-2640 skills/get: the entry for one skill, or -32602 when the server does not serve a skill at that URI.

fn read_resource_directory( &self, request: ReadResourceDirectoryRequestParams, context: RequestContext<RoleServer>, ) -> impl Future<Output = Result<ListResourcesResult, ErrorData>> + MaybeSendFuture

SEP-2640 resources/directory/read: the direct children of a directory resource, or -32602 when the URI is not a directory.