Struct AppState 

pub struct AppState {
    pub config: Arc<HarnessConfig>,
    pub store: Arc<dyn StateStore>,
    pub sandbox: Arc<Sandbox>,
    pub bridge: Arc<dyn EventBus>,
    pub sessions: Arc<SessionRegistry>,
    pub worker: WorkerHandle,
    pub identity: Option<Arc<IdentityValidator>>,
    pub metrics: Arc<Registry>,
    pub client: Client,
    pub finalizer: Finalizer,
    /* private fields */
}

Shared application state passed through HTTP handlers and background tasks.

Fields

config: Arc<HarnessConfig>

Versioned harness configuration.

store: Arc<dyn StateStore>

Atomic quota and action-budget state.

sandbox: Arc<Sandbox>

MCP schema, policy, and action-budget sandbox.

bridge: Arc<dyn EventBus>

Event Bridge backend used by asynchronous workers and by lifecycle finalization (close/promote publish through it inline).

sessions: Arc<SessionRegistry>

Live session registry.

worker: WorkerHandle

Bounded non-blocking worker queue.

identity: Option<Arc<IdentityValidator>>

Optional NHI validator. Required in production identity mode.

metrics: Arc<Registry>

Prometheus-compatible metrics registry.

client: Client

Reused upstream HTTP client.

finalizer: Finalizer

Asynchronous session close and promotion service.

Implementations

impl AppState

pub fn new( config: HarnessConfig, store: Arc<dyn StateStore>, sandbox: Arc<Sandbox>, bridge: Arc<dyn EventBus>, identity: Option<Arc<IdentityValidator>>, signer: Arc<dyn Signer>, ) -> Result<Self, PipelineError>

Build fully wired application state with a bounded worker and shared lifecycle services.

pub fn new_with_embedder( config: HarnessConfig, store: Arc<dyn StateStore>, sandbox: Arc<Sandbox>, bridge: Arc<dyn EventBus>, identity: Option<Arc<IdentityValidator>>, signer: Arc<dyn Signer>, embedder: Arc<dyn Embedder>, ) -> Result<Self, PipelineError>

Build application state with an explicit embedding backend.

pub fn new_with_backends( config: HarnessConfig, store: Arc<dyn StateStore>, sandbox: Arc<Sandbox>, bridge: Arc<dyn EventBus>, identity: Option<Arc<IdentityValidator>>, signer: Arc<dyn Signer>, embedder: Arc<dyn Embedder>, vector_sink: Arc<dyn VectorSink>, ) -> Result<Self, PipelineError>

Build application state with explicit embedding and vector backends.

pub fn new_with_backends_and_metrics( config: HarnessConfig, store: Arc<dyn StateStore>, sandbox: Arc<Sandbox>, bridge: Arc<dyn EventBus>, identity: Option<Arc<IdentityValidator>>, signer: Arc<dyn Signer>, embedder: Arc<dyn Embedder>, vector_sink: Arc<dyn VectorSink>, metrics: Arc<Registry>, ) -> Result<Self, PipelineError>

Build application state reusing a pre-existing metrics registry.

main.rs uses this so counters registered outside AppState (JWKS refresh errors, HTTP shutdown drain timeouts) live on the same registry that gets scraped at /metrics — otherwise their samples would be invisible to Prometheus.

pub fn prepare_chat( &self, headers: &HeaderMap, payload: Value, ) -> Result<PreparedRequest, PipelineError>

Run identity, breaker, quota, sanitize, compression, and asynchronous dispatch in the mandated order without awaiting worker or upstream I/O.

pub async fn prepare_chat_nonblocking( &self, headers: &HeaderMap, payload: Value, ) -> Result<PreparedRequest, PipelineError>

Run synchronous local gates without waiting for off-path journal, embedding, or broker work. When a completion-token budget is configured (budget.max_tokens) the gates run on the blocking pool; otherwise they are cheap enough to run inline.

pub async fn prepare_chat_durable( &self, headers: &HeaderMap, payload: Value, ) -> Result<PreparedRequest, PipelineError>

Prepare a request and wait until its audit record is durably captured before the provider can observe it.

pub async fn forward_chat( &self, request: PreparedRequest, ) -> Result<ForwardedResponse, PipelineError>

Forward a prepared OpenAI-compatible request to the configured provider.

pub fn intercept_tool( &self, headers: &HeaderMap, raw: &[u8], ) -> Result<ToolVerdict, PipelineError>

Intercept one MCP JSON-RPC tool call, emit its OCSF verdict asynchronously, and return the immediate authorization decision.

pub async fn intercept_tool_durable( &self, headers: &HeaderMap, raw: &[u8], ) -> Result<ToolVerdict, PipelineError>

Authorize a tool call and wait for its verdict event to become durable.

pub async fn intercept_tool_nonblocking( &self, headers: &HeaderMap, raw: &[u8], ) -> Result<ToolVerdict, PipelineError>

Authorize a tool call on the blocking pool without waiting for the off-path event journal or broker publication.

Trait Implementations

impl Clone for AppState

fn clone(&self) -> AppState

Returns a duplicate of the value.

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

Performs copy-assignment from source.