Crate cpex 

CPEX is a policy enforcement runtime for AI agents.

It is a deterministic reference monitor between an agent and every capability it invokes: tools, prompts, resources, inference providers, and A2A methods. Each operation runs through a policy-defined pipeline that can resolve identity, make an authorization decision (delegated to an engine like Cedar or CEL), exchange and reduce credentials before a downstream call, redact inputs and outputs, track information flow across calls, and audit. You write that policy declaratively in APL, the configuration that defines each operation’s pipeline; CPEX evaluates and enforces it at the boundary, against state the model cannot observe or forge.

• Guide and concepts: https://contextforge-org.github.io/cpex/
• Source and issues: https://github.com/contextforge-org/cpex

This crate

cpex is the host facade: one dependency that re-exports the CPEX runtime (cpex-core, apl-core, apl-cmf, apl-cpex), so a host depends on this crate instead of pinning each of them separately.

By default it is the engine only: no builtin plugins are compiled in. The bundled extension set lives in cpex-builtins and is pulled in only when a builtins feature is enabled.

Usage

Engine only (register your own factories):

use std::sync::Arc;
use cpex::PluginManager;

let mgr = Arc::new(PluginManager::default());
// ... register host factories, then `apl_cpex::register_apl(&mgr, opts)`.

With the bundled builtins (enable the builtins or full feature):

use std::sync::Arc;
use cpex::PluginManager;

let mgr = Arc::new(PluginManager::default());
// Register every enabled builtin factory and install the APL config
// visitor (in-process defaults) in one call:
cpex::install_builtins(&mgr);
// ... then load a config that references the enabled `kind`s.

Features

No plugins are on by default (cpex = "0.2" is the engine alone). builtins enables the common in-process set; full adds the Valkey session store; or pick a granular subset (jwt, oauth, pii, audit, cedar, cel, valkey). When any builtins feature is on, the registration helpers and the concrete factory types are re-exported here from cpex-builtins.

Re-exports

pub use apl_cmf;

pub use apl_core;

pub use apl_cpex;

pub use cpex_core;

pub use cpex_builtins;

Structs

AplOptions

Configuration for register_apl. All runtime collaborators APL needs to do its work are funneled through here so the call site reads as a single block instead of a multi-step builder.

AuditLoggerFactory

CedarDirectPdpFactory

Factory for CedarDirectResolver. Reports kind() = "cedar-direct"; builds resolvers from the unified-config block via CedarDirectResolver::from_config.

CelPdpFactory

Factory for CelResolver. Reports kind() = "cel"; builds resolvers from the unified-config block via CelResolver::from_config.

DispatchCache

Host-owned dispatch cache. Construct once, share via Arc<DispatchCache> across all CmfPluginInvoker::for_request calls so plans built for one request can be reused by the next.

JwtIdentityFactory

Factory for kind: identity/jwt plugins. Instantiates a JwtIdentityResolver from the config: block and registers it on the identity.resolve hook.

MemorySessionStore

In-process SessionStore backed by a HashMap of HashSets. Suitable for tests, single-process deployments, and as the default when no distributed store is configured. Cloning the store via Arc shares state across all consumers.

OAuthDelegatorFactory

Factory for kind: delegator/oauth plugins. Instantiates an OAuthDelegator from the config: block and registers it on the token.delegate hook.

PiiScannerFactory

Factory for kind: validator/pii-scan. Instantiates a PiiScanner from the config: block and registers a handler for every CMF hook name listed in cfg.hooks. Operators typically wire it on cmf.tool_pre_invoke / cmf.prompt_pre_invoke / cmf.resource_pre_fetch so it runs before any of those entity types reach the backend.

PluginManager

ValkeyConfig

Parsed global.apl.session_store config for kind: valkey.

ValkeySessionStoreFactory

Factory the host registers via AplOptions.session_store_factories.

Constants

AUDIT_KIND

kind: string operators write in CPEX YAML to declare an audit logger instance.

JWT_KIND

The plugin kind: string operators write in CPEX YAML to declare a JWT identity resolver.

OAUTH_KIND

The plugin kind: string operators write in CPEX YAML to declare an OAuth RFC 8693 token-exchange delegator.

PII_KIND

kind: string operators write in CPEX YAML to declare a PII scanner instance.

VALKEY_KIND

The kind: discriminator this factory builds. Part of the public surface — it is the string operators write in their config.

Traits

PdpFactory

Build a PdpResolver from a unified-config block. Implemented per PDP backend (cedar-direct, opa, …) and registered with the apl-cpex visitor so unified-config YAML can declare PDPs without the host pre-constructing them in code.

SessionStore

Pluggable session-state backend. Implementations must be Send + Sync — the same store is shared across all concurrent requests.

SessionStoreFactory

Factory the visitor consults when it encounters a global.apl.session_store block in the unified config. Mirrors apl_core::step::PdpFactory: each factory advertises a kind() string matching the YAML block’s kind: field, and build turns the block into a live store. Registered up front via crate::AplOptions::session_store_factories; the visitor selects the active store from config during its global-config walk, before any route handler captures the store.

Functions

builtin_pdp_factories

The enabled PDP factories, ready to drop into AplOptions::pdp_factories. A route’s cedar: or cel: step selects which one runs.

builtin_session_store_factories

The enabled session-store factories, ready to drop into AplOptions::session_store_factories. A global.apl.session_store: { kind: ... } config block selects one; absent that, the in-process MemorySessionStore default stays active.

install_builtins

Register every enabled plugin factory and install the APL config visitor on mgr with in-process defaults (a MemorySessionStore and the default baseline capabilities). The enabled PDP and session-store factories are wired in, so a later config load can reference any of them by kind.

register_apl

Build an AplConfigVisitor from the supplied options and register it on the manager. Returns the Arc<AplConfigVisitor> so the caller can stash it for later inspection (or call register_pdp on it after the fact for late-bound resolvers) — but in the typical case the return value is dropped and the visitor lives inside the manager’s visitor list.

register_builtin_plugins

Register every enabled by-kind plugin factory on mgr: identity (identity-jwt), delegators (delegator-oauth), validators (pii-scanner), and observers (audit-logger). Call before loading a config so the manager can instantiate plugins whose YAML kind: matches.