Struct Execute 

pub struct Execute { /* private fields */ }

Unified agent execution service — the single place handling:

• conversation history loading (TenantDb)
• memory injection (ContextProvider)
• ToolCoordinator loop
• fallback LLM chain (Coordinator)
• observability sink (run_history + agent_runs)
• usage/cost aggregation
• token budget check
• loop detection

Reachable via ctx.get::<Execute>() (see Service impl).

Implementations

impl Execute

pub fn new() -> Self

Create a new service with no backing stores (useful for tests and cargo check --no-default-features).

pub fn with_strict_fallbacks(self, strict: bool) -> Self

Enable strict fallback mode: every echo/fallback entry in execute returns Err(AppError::Unavailable) whose message starts with strict_fallbacks: instead of echoing the request.

pub fn strict_fallbacks(&self) -> bool

Whether strict fallback mode is enabled.

pub async fn emit_agent_started( &self, ctx: &Arc<Context>, payload: AgentStartedPayload, ) -> Value

Emit the agent.started event through the Cordis event bus with Dispatch::Parallel, which fans out to every registered observer concurrently and awaits all of them before returning (join-all).

If no EventsService is present in the context, or the dispatch errors, the original payload is returned unchanged so callers never lose data.

pub async fn emit_observability( &self, ctx: &Arc<Context>, event: impl Into<String>, payload: Value, )

Fire-and-forget observability event via Cordis Dispatch::Emit.

Returns immediately without waiting for handlers. Missing EventsService is a no-op. Usage snapshot recording stays in server middleware (UsageContext is not in this crate).

pub async fn emit_observability_typed<E: TypedEvent>( &self, ctx: &Arc<Context>, payload: &E::Payload, )

Typed fire-and-forget variant of [emit_observability]: dispatches the payload struct for its catalog-bound event via Dispatch::Emit.

pub fn with_context_provider(self, provider: Arc<dyn ContextProvider>) -> Self

Attach a context provider for memory injection.

pub fn with_agent_registry(self, registry: Arc<AgentRegistry>) -> Self

Attach an agent registry for creating agents from resolved configs.

pub fn with_run_tracker(self, tracker: Arc<dyn RunTracker>) -> Self

Attach a run tracker for observability.

pub fn run_tracker(&self) -> Option<&Arc<dyn RunTracker>>

Host-injected run tracker, if any.

pub async fn run( &self, req: &AgentRequest, ctx: &Arc<Context>, ) -> Result<ExecutionResult, AppError>

Execute an agent by name using the full pipeline: resolve → create → execute.

This is the PRIMARY entry point that handlers should call. It:

1. Resolves the agent via crate-private Resolver (3-tier: tenant → community → system)
2. Creates the agent via AgentRegistry::create_agent_from_config_with_fallbacks
3. Calls agent.execute(message, context) with the request ctx bound
4. Returns ExecutionResult with response + resolution metadata

Run tracking (start/finish) is handled internally via RunTracker.

Trait Implementations

impl Clone for Execute

fn clone(&self) -> Execute

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Execute

fn default() -> Self

Returns the “default value” for a type.

impl Service for Execute

fn name(&self) -> &'static str

fn init( &self, _ctx: &Arc<Context>, ) -> Pin<Box<dyn Future<Output = Result<Option<Box<dyn Disposable>>, CordisError>> + Send + '_>>

fn check(&self) -> bool

Availability predicate for this service instance.