Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.
Rust
refactor(libsy): share capability input and separate judge settings (#900)
nachiketb-nvidia16cbe5939937
diff --git a/crates/libsy-llm-client/tests/observability.rs b/crates/libsy-llm-client/tests/observability.rsindex 820c762c6..8f5071ccd 100644--- a/crates/libsy-llm-client/tests/observability.rs+++ b/crates/libsy-llm-client/tests/observability.rs@@ -34,9 +34,10 @@ use tracing_subscriber::layer::{Context as LayerContext, SubscriberExt};use tracing_subscriber::registry::LookupSpan;use switchyard_libsy::{- Algorithm, ClassifierContractConfig, ClassifyTrigger, DeescalationConfig, Driver,- EscalationJudgeConfig, LibsyError, LlmClassifierConfig, LlmTaskClassifier, PickerMode,- RoutingOutcome, RuntimeModels, StageRouter, StageRouterConfig, Step, TaskClassifierConfig,+ Algorithm, CapabilityJudgeConfig, ClassifierContractConfig, ClassifyTrigger,+ DeescalationConfig, Driver, EscalationJudgeConfig, LibsyError, LlmCapabilityConfig,+ LlmClassifierConfig, LlmTaskClassifier, PickerMode, RoutingOutcome, RuntimeModels, StageRouter,+ StageRouterConfig, Step, TaskClassifierConfig,};use switchyard_llm_client::{ClientRouter, RunObservation, RunObserver};use switchyard_protocol::{Category, ModelId};@@ -606,7 +607,10 @@ fn classifier_router() -> switchyard_libsy::Result<Arc<dyn Algorithm>> {Ok(Arc::new(LlmTaskClassifier::new(LlmClassifierConfig::Capability {config: TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),fail_open: false,..TaskClassifierConfig::default()},@@ -869,7 +873,10 @@ async fn affinity_keeps_the_algorithm_selection_after_client_fallback()});let router = Arc::new(LlmTaskClassifier::new(LlmClassifierConfig::Capability {config: TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),classify_trigger: ClassifyTrigger::NewSession,..TaskClassifierConfig::default()},diff --git a/crates/libsy/src/algorithms/composite.rs b/crates/libsy/src/algorithms/composite.rsindex 3afe61486..12ddfb39a 100644--- a/crates/libsy/src/algorithms/composite.rs+++ b/crates/libsy/src/algorithms/composite.rs@@ -172,6 +172,7 @@ impl Algorithm for CompositeRouter {#[cfg(test)]mod tests {+ use crate::{CapabilityJudgeConfig, LlmCapabilityConfig};use std::collections::HashMap;use std::sync::Arc;@@ -215,7 +216,10 @@ mod tests {fn hash_keyed_router() -> Result<Arc<CompositeRouter>> {Ok(Arc::new(CompositeRouter::new(CompositeRouterConfig {judge: TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),classify_trigger: ClassifyTrigger::UserTurn,message_hash_fallback: true,..Default::default()@@ -227,7 +231,10 @@ mod tests {fn router() -> Result<Arc<CompositeRouter>> {Ok(Arc::new(CompositeRouter::new(CompositeRouterConfig {judge: TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),classify_trigger: ClassifyTrigger::UserTurn,..Default::default()},diff --git a/crates/libsy/src/algorithms/llm_class.rs b/crates/libsy/src/algorithms/llm_class.rsindex 40d9ad3d9..74ab7e55c 100644--- a/crates/libsy/src/algorithms/llm_class.rs+++ b/crates/libsy/src/algorithms/llm_class.rs@@ -186,8 +186,9 @@ struct TaskInput {recent_turn_window: Option<usize>,}-impl ClassifierInput for TaskInput {- fn build_messages(&self, _state: &State, request: &Request) -> Vec<Message> {+impl TaskInput {+ /// Selects conversation content without adding judge instructions.+ fn messages(&self, request: &Request) -> Vec<Message> {// The default preserves the whole-task anchor and latest user update. A// configured window widens that to the surrounding conversation.let mut messages = match self.recent_turn_window {@@ -204,6 +205,13 @@ impl ClassifierInput for TaskInput {.retain(|block| !matches!(block, ContentBlock::Reasoning { .. }));}messages.retain(|message| !message.content.is_empty());+ messages+ }+}++impl ClassifierInput for TaskInput {+ fn build_messages(&self, _state: &State, request: &Request) -> Vec<Message> {+ let mut messages = self.messages(request);// Only the windowed path carries assistant turns and tool traffic for the judge// to be distracted by. The default path is user task messages only — the anchor// and the latest follow-up — so there is nothing there to outrank.@@ -223,7 +231,7 @@ struct TaskClassifierPolicy {}impl TaskClassifierPolicy {- fn new(config: &TaskClassifierConfig) -> Self {+ fn new(config: &LlmCapabilityConfig) -> Self {Self {base_threshold: config.base_threshold,threshold_step: config.threshold_step,@@ -297,35 +305,60 @@ fn capability_evidence(}))}+/// Settings shared by capability judges and their surrounding route.#[derive(Clone, Debug)]-/// Settings that control capability classifier prompting and routing.pub struct TaskClassifierConfig {+ /// The judge's prediction contract and routing policy.+ pub judge: CapabilityJudgeConfig,/// Routes to the capable tier on judge client failures and deadlines. Defaults to true.pub fail_open: bool,- /// Lowest solve probability that routes a supported task to the efficient target.- pub base_threshold: f64,- /// Amount added per capability-boundary step.- ///- /// Supported verdicts use `base_threshold`, uncertain and unmatched verdicts use one- /// step, and unsupported verdicts use two steps.- pub threshold_step: f64,/// How often the classifier re-decides this session's target.pub classify_trigger: ClassifyTrigger,/// Uses the first user message as the SessionKey for sticky routing when session metadata is unavailable.pub message_hash_fallback: bool,- /// Trailing conversation turns the judge sees on top of the client- /// instructions and the opening task.- ///- /// `None` (the default) judges the opening task and latest user follow-up.- /// `Some(n)` widens that to the client instructions, the opening task, and- /// the last `n` turns after it.+ /// `None` judges the opening task and latest user follow-up. `Some(n)` also+ /// includes the surrounding conversation using the last `n` turns.pub recent_turn_window: Option<usize>,+}++/// Selects how a capability judge obtains and interprets its prediction.+#[derive(Clone, Debug)]+pub enum CapabilityJudgeConfig {+ /// A structured LLM verdict with a solve probability and capability boundary.+ Llm(LlmCapabilityConfig),+}++impl Default for CapabilityJudgeConfig {+ fn default() -> Self {+ Self::Llm(LlmCapabilityConfig::default())+ }+}++/// Prompt, output, and solve-probability settings for an LLM capability judge.+#[derive(Clone, Debug)]+pub struct LlmCapabilityConfig {+ /// Lowest solve probability that routes a supported task to the efficient target.+ pub base_threshold: f64,+ /// Amount added per capability-boundary step: zero for supported, one for+ /// uncertain or unmatched, and two for unsupported.+ pub threshold_step: f64,/// Prompt and verdict contract settings for the classifier judge.pub contract: ClassifierContractConfig,/// Maximum completion tokens available to the classifier verdict.pub max_output_tokens: u64,}+impl Default for LlmCapabilityConfig {+ fn default() -> Self {+ Self {+ base_threshold: 0.0,+ threshold_step: 0.0,+ contract: ClassifierContractConfig::default(),+ max_output_tokens: DEFAULT_JUDGE_MAX_OUTPUT_TOKENS,+ }+ }+}+/// Flat serialized shape that maps prompt settings into the runtime contract.#[derive(Deserialize)]#[serde(deny_unknown_fields)]@@ -361,14 +394,16 @@ impl<'de> Deserialize<'de> for TaskClassifierConfig {}contract = contract.with_response_format_type(wire.response_format_type);Ok(Self {- base_threshold: wire.base_threshold,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: wire.base_threshold,+ threshold_step: wire.threshold_step,+ contract,+ max_output_tokens: wire.max_output_tokens,+ }),fail_open: wire.fail_open,- threshold_step: wire.threshold_step,classify_trigger: wire.classify_trigger,message_hash_fallback: wire.message_hash_fallback,recent_turn_window: wire.recent_turn_window,- contract,- max_output_tokens: wire.max_output_tokens,})}}@@ -384,20 +419,16 @@ const fn default_judge_max_output_tokens() -> u64 {impl Default for TaskClassifierConfig {fn default() -> Self {Self {- base_threshold: 0.0,+ judge: CapabilityJudgeConfig::default(),fail_open: default_fail_open(),- threshold_step: 0.0,classify_trigger: ClassifyTrigger::default(),message_hash_fallback: false,recent_turn_window: None,- contract: ClassifierContractConfig::default(),- max_output_tokens: DEFAULT_JUDGE_MAX_OUTPUT_TOKENS,}}}-impl TaskClassifierConfig {- /// Validates routing thresholds before the classifier is constructed.+impl LlmCapabilityConfig {fn validate(&self) -> Result<()> {if !(0.0..=1.0).contains(&self.base_threshold) {return Err(LibsyError::AlgorithmError {@@ -428,6 +459,15 @@ impl TaskClassifierConfig {message: "max_output_tokens must be at least 1".to_string(),});}+ Ok(())+ }+}++impl TaskClassifierConfig {+ fn validate(&self) -> Result<()> {+ match &self.judge {+ CapabilityJudgeConfig::Llm(config) => config.validate()?,+ }// Only `every_request` is rejected: it retains no target, so a fallback identity has nothing to key on. Both retaining triggers can key the retained target on a message hash when the caller sends no session id.if self.message_hash_fallback && self.classify_trigger == ClassifyTrigger::EveryRequest {return Err(LibsyError::AlgorithmError {@@ -639,7 +679,8 @@ impl LlmTaskClassifier {fn build_capability(config: TaskClassifierConfig) -> Result<Self> {config.validate()?;- let contract = Self::load_capability_contract(&config.contract)?;+ let CapabilityJudgeConfig::Llm(judge) = &config.judge;+ let contract = Self::load_capability_contract(&judge.contract)?;let classify_trigger = config.classify_trigger;let message_hash_fallback = config.message_hash_fallback;let classifier: Arc<dyn Classifier<State>> = Arc::new(@@ -650,9 +691,9 @@ impl LlmTaskClassifier {},contract,SerdeDecoder::new(),- JudgeRuntimeConfig::new(config.max_output_tokens)?,+ JudgeRuntimeConfig::new(judge.max_output_tokens)?,),- TaskClassifierPolicy::new(&config),+ TaskClassifierPolicy::new(judge),).with_error_recovery(config.fail_open).with_evidence(capability_evidence),@@ -806,15 +847,22 @@ mod tests {type CapabilityJudge = StructuredJudge<TaskInput, SerdeDecoder<TaskClassifierVerdict>>;+ fn llm_config(base_threshold: f64) -> LlmCapabilityConfig {+ LlmCapabilityConfig {+ base_threshold,+ ..LlmCapabilityConfig::default()+ }+ }+fn test_config(base_threshold: f64) -> TaskClassifierConfig {TaskClassifierConfig {- base_threshold,+ judge: CapabilityJudgeConfig::Llm(llm_config(base_threshold)),..TaskClassifierConfig::default()}}fn policy() -> TaskClassifierPolicy {- TaskClassifierPolicy::new(&test_config(TEST_THRESHOLD))+ TaskClassifierPolicy::new(&llm_config(TEST_THRESHOLD))}fn runtime_models() -> HashMap<Category, Vec<ModelId>> {@@ -1045,7 +1093,10 @@ mod tests {let recorder = Arc::new(Recorder::default());let router = Arc::new(LlmTaskClassifier::new(LlmClassifierConfig::Capability {config: TaskClassifierConfig {- max_output_tokens: 512,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ max_output_tokens: 512,+ ..llm_config(TEST_THRESHOLD)+ }),..test_config(TEST_THRESHOLD)},})?);@@ -1067,8 +1118,11 @@ mod tests {let recorder = Arc::new(Recorder::default());let router = Arc::new(LlmTaskClassifier::new(LlmClassifierConfig::Capability {config: TaskClassifierConfig {- contract: ClassifierContractConfig::default()- .with_prompt("Custom capability rubric."),+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ contract: ClassifierContractConfig::default()+ .with_prompt("Custom capability rubric."),+ ..llm_config(TEST_THRESHOLD)+ }),..test_config(TEST_THRESHOLD)},})?);@@ -1229,8 +1283,8 @@ mod tests {#[test]fn the_threshold_moves_the_routing_boundary() -> Result<()> {let borderline = verdict(0.5, "supported", "SUP-1");- let strict = TaskClassifierPolicy::new(&test_config(0.9));- let lenient = TaskClassifierPolicy::new(&test_config(0.1));+ let strict = TaskClassifierPolicy::new(&llm_config(0.9));+ let lenient = TaskClassifierPolicy::new(&llm_config(0.1));assert_eq!(selected(&strict, Some(&borderline))?, "capable");assert_eq!(selected(&lenient, Some(&borderline))?, "efficient");Ok(())@@ -1265,23 +1319,35 @@ mod tests {}for config in [TaskClassifierConfig {- base_threshold: 0.5,- threshold_step: -0.1,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ threshold_step: -0.1,+ ..LlmCapabilityConfig::default()+ }),..TaskClassifierConfig::default()},TaskClassifierConfig {- base_threshold: 0.8,- threshold_step: 0.11,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.8,+ threshold_step: 0.11,+ ..LlmCapabilityConfig::default()+ }),..TaskClassifierConfig::default()},TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),message_hash_fallback: true,..TaskClassifierConfig::default()},TaskClassifierConfig {- base_threshold: 0.5,- max_output_tokens: 0,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ max_output_tokens: 0,+ ..LlmCapabilityConfig::default()+ }),..TaskClassifierConfig::default()},] {@@ -1302,7 +1368,10 @@ mod tests {// retained target on a message hash when the caller sends no session id.for trigger in [ClassifyTrigger::NewSession, ClassifyTrigger::UserTurn] {let config = TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),classify_trigger: trigger,message_hash_fallback: true,..TaskClassifierConfig::default()@@ -1314,7 +1383,10 @@ mod tests {)?;}let every_request = TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),classify_trigger: ClassifyTrigger::EveryRequest,message_hash_fallback: true,..TaskClassifierConfig::default()@@ -1357,9 +1429,9 @@ mod tests {#[test]fn capability_boundaries_apply_monotonic_threshold_steps() -> Result<()> {- let policy = TaskClassifierPolicy::new(&TaskClassifierConfig {+ let policy = TaskClassifierPolicy::new(&LlmCapabilityConfig {threshold_step: 0.1,- ..test_config(0.4)+ ..llm_config(0.4)});assert_eq!(diff --git a/crates/libsy/src/algorithms/stage.rs b/crates/libsy/src/algorithms/stage.rsindex c2f576287..cc565f61f 100644--- a/crates/libsy/src/algorithms/stage.rs+++ b/crates/libsy/src/algorithms/stage.rs@@ -259,6 +259,7 @@ pub(crate) fn build_stage_route(config: StageRouterConfig) -> Result<FallThrough#[cfg(test)]mod tests {+ use crate::{CapabilityJudgeConfig, LlmCapabilityConfig};use std::collections::HashMap;use std::sync::Arc;@@ -376,7 +377,10 @@ mod tests {let mut config = config();config.llm_fallback = Some(LlmFallback {config: TaskClassifierConfig {- base_threshold: -0.1,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: -0.1,+ ..LlmCapabilityConfig::default()+ }),..Default::default()},});@@ -411,7 +415,10 @@ mod tests {let mut c = config();c.llm_fallback = Some(LlmFallback {config: TaskClassifierConfig {- base_threshold: 0.5,+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: 0.5,+ ..LlmCapabilityConfig::default()+ }),recent_turn_window: Some(3),..Default::default()},diff --git a/crates/libsy/src/lib.rs b/crates/libsy/src/lib.rsindex 9b484ae27..405dd2f3d 100644--- a/crates/libsy/src/lib.rs+++ b/crates/libsy/src/lib.rs@@ -21,8 +21,8 @@ mod algorithms;pub use algorithms::advisor_gate::{AdvisorGate, AdvisorGateConfig, GateTrigger};pub use algorithms::composite::{CompositeRouter, CompositeRouterConfig};pub use algorithms::llm_class::{- CustomClassifierConfig, CustomClassifierPolicy, LlmClassifierConfig, LlmTaskClassifier,- TaskClassifierConfig,+ CapabilityJudgeConfig, CustomClassifierConfig, CustomClassifierPolicy, LlmCapabilityConfig,+ LlmClassifierConfig, LlmTaskClassifier, TaskClassifierConfig,};pub use algorithms::noop::Noop;pub use algorithms::passthrough::Passthrough;diff --git a/crates/switchyard-py/src/libsy_bindings.rs b/crates/switchyard-py/src/libsy_bindings.rsindex 64484ccd8..f61369fcf 100644--- a/crates/switchyard-py/src/libsy_bindings.rs+++ b/crates/switchyard-py/src/libsy_bindings.rs@@ -15,11 +15,12 @@ use pyo3::exceptions::{use pyo3::prelude::*;use serde_json::Value;use switchyard_libsy::{- Algorithm, CallModel, ClassifierContractConfig, ClassifierResponseFormat, ClassifyTrigger,- CustomClassifierConfig, CustomClassifierPolicy, DeescalationConfig, EscalationJudgeConfig,- HandoffNoteConfig, LibsyError as RustLibsyError, LlmClassifierConfig, LlmFallback,- LlmTaskClassifier, Noop, PickerMode, Random, RoutingOutcome, RuntimeModels, StageRouter,- StageRouterConfig, Step as RustStep, StepStream, TaskClassifierConfig, ToolSemantics,+ Algorithm, CallModel, CapabilityJudgeConfig, ClassifierContractConfig,+ ClassifierResponseFormat, ClassifyTrigger, CustomClassifierConfig, CustomClassifierPolicy,+ DeescalationConfig, EscalationJudgeConfig, HandoffNoteConfig, LibsyError as RustLibsyError,+ LlmCapabilityConfig, LlmClassifierConfig, LlmFallback, LlmTaskClassifier, Noop, PickerMode,+ Random, RoutingOutcome, RuntimeModels, StageRouter, StageRouterConfig, Step as RustStep,+ StepStream, TaskClassifierConfig, ToolSemantics,};use switchyard_protocol::{Category, LlmClientError, LlmResponse, LlmResponseStream, LlmResponseStreamEvent, Metadata,@@ -330,14 +331,16 @@ impl PyTaskClassifierConfig {) -> PyResult<Self> {Ok(Self {inner: TaskClassifierConfig {+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold,+ threshold_step,+ contract: classifier_contract(prompt, response_format_type)?,+ max_output_tokens,+ }),fail_open: true,- base_threshold,- threshold_step,classify_trigger: classify_trigger(session_affinity),message_hash_fallback,recent_turn_window,- contract: classifier_contract(prompt, response_format_type)?,- max_output_tokens,},})}diff --git a/crates/switchyard-runner/src/algorithm.rs b/crates/switchyard-runner/src/algorithm.rsindex acb2644c8..5cc838209 100644--- a/crates/switchyard-runner/src/algorithm.rs+++ b/crates/switchyard-runner/src/algorithm.rs@@ -10,12 +10,12 @@ use std::path::PathBuf;use std::sync::Arc;use libsy::{- AdvisorGate, AdvisorGateConfig, Algorithm, ClassifierContractConfig, ClassifierResponseFormat,- ClassifyTrigger, CompositeRouter, CompositeRouterConfig, CustomClassifierConfig,- CustomClassifierPolicy, EscalationJudgeConfig, GateTrigger, HandoffNoteConfig,- LlmClassifierConfig, LlmFallback, LlmTaskClassifier, Noop, Passthrough, PickerMode,- PlanExecute, PlanExecuteConfig, Random, StageRouter, StageRouterConfig, SubagentRouter,- SubagentRouterConfig, TaskClassifierConfig, ToolSemantics,+ AdvisorGate, AdvisorGateConfig, Algorithm, CapabilityJudgeConfig, ClassifierContractConfig,+ ClassifierResponseFormat, ClassifyTrigger, CompositeRouter, CompositeRouterConfig,+ CustomClassifierConfig, CustomClassifierPolicy, EscalationJudgeConfig, GateTrigger,+ HandoffNoteConfig, LlmCapabilityConfig, LlmClassifierConfig, LlmFallback, LlmTaskClassifier,+ Noop, Passthrough, PickerMode, PlanExecute, PlanExecuteConfig, Random, StageRouter,+ StageRouterConfig, SubagentRouter, SubagentRouterConfig, TaskClassifierConfig, ToolSemantics,};use serde::Deserialize;use switchyard_protocol::{Category, ModelId};@@ -526,15 +526,17 @@ pub struct StageTierConfig {impl StageClassifierConfig {fn task_classifier_config(&self) -> TaskClassifierConfig {TaskClassifierConfig {+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: self.base_threshold,+ threshold_step: self.threshold_step,+ contract: classifier_contract(self.prompt.as_deref())+ .with_response_format_type(self.response_format_type),+ max_output_tokens: self.max_output_tokens,+ }),fail_open: true,- base_threshold: self.base_threshold,- threshold_step: self.threshold_step,classify_trigger: self.classify_trigger,message_hash_fallback: self.message_hash_fallback,recent_turn_window: self.recent_turn_window,- contract: classifier_contract(self.prompt.as_deref())- .with_response_format_type(self.response_format_type),- max_output_tokens: self.max_output_tokens,}}}@@ -1242,15 +1244,17 @@ fn build_algorithm(let algorithm = match mode {LlmClassifierModeConfig::Capability(config) => {let classifier_config = TaskClassifierConfig {+ judge: CapabilityJudgeConfig::Llm(LlmCapabilityConfig {+ base_threshold: config.base_threshold,+ threshold_step: config.threshold_step,+ contract: classifier_contract(config.prompt.as_deref())+ .with_response_format_type(config.response_format_type),+ max_output_tokens: config.max_output_tokens,+ }),fail_open: config.fail_open,- base_threshold: config.base_threshold,- threshold_step: config.threshold_step,classify_trigger: config.classify_trigger,message_hash_fallback: config.message_hash_fallback,recent_turn_window: config.recent_turn_window,- contract: classifier_contract(config.prompt.as_deref())- .with_response_format_type(config.response_format_type),- max_output_tokens: config.max_output_tokens,};LlmTaskClassifier::new(LlmClassifierConfig::Capability {config: classifier_config,@@ -1494,7 +1498,7 @@ fn classifier_contract(prompt: Option<&str>) -> ClassifierContractConfig {}fn default_classifier_max_output_tokens() -> u64 {- TaskClassifierConfig::default().max_output_tokens+ LlmCapabilityConfig::default().max_output_tokens}fn warn_single_target_classifier(route_name: &str, models: &CategoryModelConfig) {