Struct AgentPipeline 

pub struct AgentPipeline { /* private fields */ }

The main agent pipeline for processing requests

Implementations

impl AgentPipeline

pub async fn generate_requirement_breakdown_specs( cfg: AppConfig, source: RequestSource, session_id: Option<&str>, requirements: &str, ) -> Result<Vec<RequirementBreakdownTaskSpec>, String>

Generate a typed requirement breakdown using the shared core pipeline.

pub fn default_auto_tracked_execution_specs( message: &str, ) -> Vec<RequirementBreakdownTaskSpec>

Build the default tracked execution specs used when LLM planning is unavailable.

pub fn new(config: AppConfig) -> Self

Create a new pipeline using the default runtime configuration merged with persisted user pipeline settings from AppConfig.

pub fn with_config(config: AppConfig, pipeline_config: PipelineConfig) -> Self

Create a pipeline with custom configuration

pub fn with_knowledge( self, store: &'static KnowledgeStore, settings: &'static KnowledgeSettingsManager, ) -> Self

Set the knowledge store and settings manager for this pipeline

pub fn with_provider_optimized_config(config: AppConfig) -> Self

Create a pipeline with configuration optimized for the current LLM provider

This automatically sets the context token limit based on the provider’s capabilities and applies user settings from AppConfig.pipeline.

Note: For model-specific limits, prefer [with_model_optimized_config].

pub fn with_shared_capabilities_cache( config: AppConfig, capabilities_cache: ModelCapabilitiesCache, ) -> Self

Create a pipeline with a shared capabilities cache for dynamic limit discovery.

This allows the pipeline to learn model limits from errors and API discovery, sharing that knowledge across pipeline instances.

pub fn capabilities_cache(&self) -> &ModelCapabilitiesCache

Get a reference to the capabilities cache for learning model limits.

pub async fn process_streaming( &self, request: AgentRequest, tx: Sender<StreamChunk>, cancel_token: CancellationToken, ) -> Result<AgentResponse, AppError>

Process a request with streaming response

This is the main entry point for streaming LLM interactions. It handles context reduction, tool filtering, and the agentic loop.

pub async fn process_blocking( &self, request: AgentRequest, ) -> Result<AgentResponse, AppError>

Process a request without streaming (blocking)