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
feat(server): configure system prompts by target (#464)
Alex Fournier872a2e457ec0
diff --git a/crates/switchyard-runner/src/algorithm.rs b/crates/switchyard-runner/src/algorithm.rsindex d3e5f78ac..0e1ede289 100644--- a/crates/switchyard-runner/src/algorithm.rs+++ b/crates/switchyard-runner/src/algorithm.rs@@ -14,8 +14,7 @@ use libsy::{ClassifyTrigger, CompositeRouter, CompositeRouterConfig, CustomClassifierConfig,CustomClassifierPolicy, EscalationJudgeConfig, GateTrigger, HandoffNoteConfig,LlmClassifierConfig, LlmFallback, LlmTaskClassifier, Noop, Passthrough, PickerMode, Random,- StageRouter, StageRouterConfig, SubagentRouter, SubagentRouterConfig, TargetPrompts,- TaskClassifierConfig,+ StageRouter, StageRouterConfig, SubagentRouter, SubagentRouterConfig, TaskClassifierConfig,};use serde::Deserialize;use switchyard_protocol::ModelId;@@ -395,12 +394,6 @@ pub struct StageTierConfig {/// Notes handed to a tier when the router switches to it.#[serde(default)]pub handoff_notes: Option<HandoffNoteConfig>,- /// System prompt handed to the capable tier.- #[serde(default)]- pub capable_system_prompt: Option<String>,- /// System prompt handed to the efficient tier.- #[serde(default)]- pub efficient_system_prompt: Option<String>,}impl StageClassifierConfig {@@ -531,6 +524,40 @@ impl AlgorithmSpec {}names}++ /// Response target and routing-only dependency for routers that answer while routing.+ pub(crate) fn routing_response_and_dependency(&self) -> Option<(&str, &str)> {+ match self {+ Self::LlmClassifier { config, .. }+ if matches!(+ config.mode.unwrap_or(if config.escalation.is_some() {+ ClassifierMode::Escalation+ } else {+ ClassifierMode::Capability+ }),+ ClassifierMode::Escalation+ ) =>+ {+ Some((+ config.weak_target.as_deref()?,+ config.classifier_target.as_str(),+ ))+ }+ Self::Advisor {+ executor_target,+ advisor_target,+ ..+ } => Some((executor_target, advisor_target)),+ Self::Noop { .. }+ | Self::Random { .. }+ | Self::Passthrough { .. }+ | Self::LlmClassifier { .. }+ | Self::StageRouter { .. }+ | Self::Composite { .. }+ | Self::PrefillRouter { .. } => None,+ }+ }+/// Builds this algorithm after resolving configured target names.pub fn build(&self,@@ -963,8 +990,6 @@ fn build_algorithm(confidence_threshold,recent_turn_window,handoff_notes,- capable_system_prompt,- efficient_system_prompt,} = tiers;if matches!(picker, PickerMode::CapableFirst) {tracing::warn!(@@ -976,12 +1001,6 @@ fn build_algorithm(let mut config = StageRouterConfig::new(*picker, *confidence_threshold);config.recent_window = *recent_turn_window;config.handoff_notes = handoff_notes.clone();- config.tier_prompts = tier_prompts(- &capable,- capable_system_prompt.as_deref(),- &efficient,- efficient_system_prompt.as_deref(),- );// The judge is called through its own target, so it is not a routing// destination and stays out of the tier pair.config.llm_fallback = classifier@@ -1016,12 +1035,6 @@ fn build_algorithm(StageRouterConfig::new(PickerMode::EfficientFirst, stage.confidence_threshold);stage_config.recent_window = stage.recent_turn_window;stage_config.handoff_notes = stage.handoff_notes.clone();- stage_config.tier_prompts = tier_prompts(- &capable,- stage.capable_system_prompt.as_deref(),- &efficient,- stage.efficient_system_prompt.as_deref(),- );let config = CompositeRouterConfig {judge_target,judge: classifier.task_classifier_config(),@@ -1159,23 +1172,6 @@ fn default_classifier_max_output_tokens() -> u64 {TaskClassifierConfig::default().max_output_tokens}-/// Keys each configured system prompt by the target it belongs to.-fn tier_prompts(- capable: &str,- capable_prompt: Option<&str>,- efficient: &str,- efficient_prompt: Option<&str>,-) -> TargetPrompts {- let mut prompts = TargetPrompts::default();- if let Some(prompt) = capable_prompt {- prompts = prompts.with(capable, prompt);- }- if let Some(prompt) = efficient_prompt {- prompts = prompts.with(efficient, prompt);- }- prompts-}-fn resolve_targets<'a>(route_name: &str,names: impl IntoIterator<Item = &'a str>,diff --git a/crates/switchyard-runner/src/config.rs b/crates/switchyard-runner/src/config.rsindex c1fea1464..a4bb309aa 100644--- a/crates/switchyard-runner/src/config.rs+++ b/crates/switchyard-runner/src/config.rs@@ -71,6 +71,11 @@ struct RouteConfig {algorithm: AlgorithmSpec,}+struct TargetPromptPolicy {+ prompts: HashMap<ModelId, String>,+ routing_answer_target: Option<ModelId>,+}+impl<'de> Deserialize<'de> for RouteConfig {fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where@@ -299,7 +304,67 @@ impl DeploymentConfig {let client: Arc<dyn RoutedLlmClient> = client.clone();by_model.insert(target.id.clone(), client);}- Ok((ClientRouter::new(by_model), caller_auth))+ let TargetPromptPolicy {+ prompts,+ routing_answer_target,+ } = self.build_route_target_prompts(route_name, route)?;+ let router =+ ClientRouter::new_with_target_prompts(by_model, prompts, routing_answer_target);+ Ok((router, caller_auth))+ }++ /// Builds the effective prompt policy for this route's completion targets.+ fn build_route_target_prompts(+ &self,+ route_name: &str,+ route: &RouteConfig,+ ) -> RunnerResult<TargetPromptPolicy> {+ let mut prompts = HashMap::new();+ let mut aliases = HashMap::<&ModelId, Option<&str>>::new();+ for name in route.algorithm.routing_target_names() {+ let target = self.targets.get(name).ok_or_else(|| {+ RunnerError::configuration(format!("route references unknown target {name}"))+ })?;+ let prompt = target.system_prompt.as_deref();+ if aliases+ .insert(&target.id, prompt)+ .is_some_and(|configured| configured != prompt)+ {+ return Err(RunnerError::configuration(format!(+ "route {route_name} maps completion target aliases to model {} with different system_prompt values",+ target.id+ )));+ }+ if let Some(prompt) = prompt {+ prompts.insert(target.id.clone(), prompt.to_string());+ }+ }+ let mut policy = TargetPromptPolicy {+ prompts,+ routing_answer_target: None,+ };+ let Some((response_name, dependency_name)) =+ route.algorithm.routing_response_and_dependency()+ else {+ return Ok(policy);+ };+ let response = self.targets.get(response_name).ok_or_else(|| {+ RunnerError::configuration(format!("route references unknown target {response_name}"))+ })?;+ if !policy.prompts.contains_key(&response.id) {+ return Ok(policy);+ }+ let dependency = self.targets.get(dependency_name).ok_or_else(|| {+ RunnerError::configuration(format!("route references unknown target {dependency_name}"))+ })?;+ if response.id == dependency.id {+ return Err(RunnerError::configuration(format!(+ "route {route_name} cannot apply system_prompt to target {response_name}: model {} is also used by routing-only target {dependency_name}",+ response.id,+ )));+ }+ policy.routing_answer_target = Some(response.id.clone());+ Ok(policy)}fn fallback_base_url(&self) -> RunnerResult<Option<String>> {@@ -423,6 +488,7 @@ struct TargetConfig {llm_client: String,#[serde(default)]extra_body: BTreeMap<String, Value>,+ system_prompt: Option<String>,}#[derive(Clone, Copy, Debug, Deserialize)]@@ -768,6 +834,49 @@ confidence_threshold = 0.5Ok(())}+ #[test]+ fn aliased_completion_targets_reject_prompt_conflicts() {+ let configured = stage_config()+ .replace(+ "id = \"strong/model\"\nllm_client = \"responses\"",+ "id = \"strong/model\"\nllm_client = \"responses\"\nsystem_prompt = \"capable\"",+ )+ .replace(+ "[routes.stage]",+ "[targets.strong_alias]\nid = \"strong/model\"\nllm_client = \"responses\"\n\n[routes.stage]",+ )+ .replace("efficient_target = \"weak\"", "efficient_target = \"strong_alias\"");+ let message = error_message(&configured);+ assert!(+ message.contains("completion target aliases to model strong/model with different system_prompt values"),+ "unexpected error: {message}"+ );+ }++ #[test]+ fn prompted_routing_response_cannot_share_a_model_with_a_dependency() {+ let configured = VALID_CONFIG+ .replace(+ "id = \"classifier/model\"\nllm_client = \"primary\"",+ "id = \"weak/model\"\nllm_client = \"primary\"",+ )+ .replace(+ "id = \"weak/model\"\nllm_client = \"anthropic\"",+ "id = \"weak/model\"\nllm_client = \"anthropic\"\nsystem_prompt = \"answer prompt\"",+ )+ .replace(+ "base_threshold = 0.5",+ "base_threshold = 0.5\nescalation = { confirmations = 1 }",+ );++ let message = error_message(&configured);++ assert!(+ message.contains("cannot apply system_prompt to target weak: model weak/model is also used by routing-only target classifier"),+ "unexpected error: {message}"+ );+ }+#[test]fn rejects_invalid_unreferenced_llm_client() {let invalid = format!(diff --git a/crates/switchyard-server/CONFIGURATION.md b/crates/switchyard-server/CONFIGURATION.mdindex ae40d38eb..f7458bc95 100644--- a/crates/switchyard-server/CONFIGURATION.md+++ b/crates/switchyard-server/CONFIGURATION.md@@ -14,9 +14,13 @@ max_retries = 2[targets.model]id = "provider/model"llm_client = "provider"+system_prompt = "Follow this model's deployment instructions."extra_body = { chat_template_kwargs = { enable_thinking = false } }```+`system_prompt` is prepended when the target is a completion destination. Switchyard+prepares each fallback independently, so a failed target's prompt is not carried to the next one.+`extra_body` is target-specific. It shallow-merges top-level provider options intothe outbound request, while explicit request fields win on conflicts.diff --git a/crates/switchyard-server/README.md b/crates/switchyard-server/README.mdindex 87c281886..b14b7fa37 100644--- a/crates/switchyard-server/README.md+++ b/crates/switchyard-server/README.md@@ -17,6 +17,7 @@ max_retries = 2[targets.model_a]id = "model/a"llm_client = "example"+system_prompt = "Use the fast path for routine work."extra_body = { service_tier = "priority" }[targets.model_b]@@ -84,6 +85,8 @@ client's `base_url` should receive the caller's login. A forwarding route mustbe called through the matching provider API.Target-level `extra_body` values are shallow-merged into the upstream request whenthe request does not already contain that key.+Target-level `system_prompt` values are prepended when that target serves a completion.+Selected and fallback targets are prepared independently.`max_retries` defaults to `2` and applies to transport failures, timeouts, HTTP 408/429, and 5xxresponses.@@ -169,7 +172,8 @@ target and summarizes its score, confidence, and input-dimension histograms. Thewith `/v1/stats/reset`; the process-lifetime counters on `/metrics` remain cumulative.Token counting selects an Anthropic-format completion target, preferring target names or model IDs-containing `opus`, `sonnet`, then `haiku`. Other ties preserve the route's target order.+containing `opus`, `sonnet`, then `haiku`. Other ties preserve the route's target order. Target+system prompts are applied to answer calls, not token-count requests.## Metricsdiff --git a/crates/switchyard-server/tests/server.rs b/crates/switchyard-server/tests/server.rsindex 43e6abf7f..0f6567092 100644--- a/crates/switchyard-server/tests/server.rs+++ b/crates/switchyard-server/tests/server.rs@@ -99,19 +99,36 @@ impl Drop for MockUpstream {}}+fn user_prompt(body: &Value) -> &str {+ body["messages"]+ .as_array()+ .and_then(|messages| messages.iter().find(|message| message["role"] == "user"))+ .and_then(|message| message["content"].as_str())+ .unwrap_or_default()+}++fn has_system_prompt(call: &Value, expected: &str) -> bool {+ call["messages"].as_array().is_some_and(|messages| {+ messages.iter().any(|message| {+ message["role"] == "system" && message["content"].as_str() == Some(expected)+ })+ })+}+async fn upstream_chat(State(calls): State<Arc<Mutex<Vec<Value>>>>,Json(body): Json<Value>,) -> HttpResponse {calls.lock().await.push(body.clone());- if body["messages"][0]["content"] == "fail" {+ let prompt = user_prompt(&body);+ if prompt == "fail" {return (StatusCode::IM_A_TEAPOT,Json(json!({"error": {"message": "upstream rejected request"}})),).into_response();}- if body["messages"][0]["content"] == "auth-fail" {+ if prompt == "auth-fail" {return (StatusCode::UNAUTHORIZED,Json(json!({"error": {"message": "upstream authentication failed"}})),@@ -120,13 +137,12 @@ async fn upstream_chat(}let model = body["model"].as_str().unwrap_or("unknown").to_string();- let prompt = body["messages"][0]["content"].as_str().unwrap_or("");if prompt == "retry-once"&& calls.lock().await.iter()- .filter(|call| call["messages"][0]["content"] == "retry-once")+ .filter(|call| user_prompt(call) == "retry-once").count()== 1{@@ -144,7 +160,7 @@ async fn upstream_chat().into_response();}- if model == "model/weak" && body["messages"][0]["content"] == "overflow" {+ if model == "model/weak" && prompt == "overflow" {return (StatusCode::BAD_REQUEST,Json(json!({@@ -159,7 +175,7 @@ async fn upstream_chat(if body["stream"].as_bool() == Some(true) {// Streamed tool call, for the namespace-on-every-event assertions. The// model calls a tool by the name it was given, so echo that name back.- if body["messages"][0]["content"] == "mcp-tool-call" {+ if prompt == "mcp-tool-call" {let called = body["tool_choice"]["function"]["name"].as_str().or_else(|| body["tools"][0]["function"]["name"].as_str())@@ -178,7 +194,7 @@ async fn upstream_chat();return Sse::new(stream).into_response();}- if body["messages"][0]["content"] == "stream-error" {+ if prompt == "stream-error" {let events = [json!({"id": "chatcmpl-stream-error", "model": model, "choices": [{"index": 0, "delta": {"role": "assistant"}}]}).to_string(),json!({"id": "chatcmpl-stream-error", "model": model, "choices": [{"index": 0, "delta": {"content": "before"}}]}).to_string(),@@ -240,7 +256,7 @@ async fn upstream_chat(}// Buffered tool call, the non-streaming counterpart of the branch above.- if body["messages"][0]["content"] == "mcp-tool-call" {+ if prompt == "mcp-tool-call" {let called = body["tool_choice"]["function"]["name"].as_str().or_else(|| body["tools"][0]["function"]["name"].as_str())@@ -291,10 +307,9 @@ async fn upstream_chat(} else {r#"{"decision":{"target":"premium"}}"#}- } else if model == "model/classifier"- && body- .pointer("/response_format/json_schema/schema/properties/escalate")- .is_some()+ } else if body+ .pointer("/response_format/json_schema/schema/properties/escalate")+ .is_some(){r#"{"escalate":false,"reason":"making progress"}"#} else if model == "model/classifier" && requests_schema_invalid_verdict {@@ -900,10 +915,12 @@ max_retries = 0[targets.first]id = "{first}"llm_client = "mock"+system_prompt = "weak answer prompt"[targets.second]id = "{second}"llm_client = "mock"+system_prompt = "strong answer prompt"[routes.random]id = "{ROUTE_MODEL}"@@ -1115,6 +1132,7 @@ base_url = "{model_url}"[targets.judge]id = "model/classifier"llm_client = "judge_provider"+system_prompt = "judge target prompt"[targets.quality]id = "model/strong"@@ -1124,6 +1142,7 @@ llm_client = "model_provider"id = "model/weak"llm_client = "model_provider"extra_body = {{ service_tier = "priority" }}+system_prompt = "economy answer prompt"[routes.classify]id = "switchyard/classify"@@ -1218,6 +1237,14 @@ escalation = {{ confirmations = 1 }});assert_eq!(model_upstream.models().await, ["model/weak"]);assert_eq!(judge_upstream.models().await, ["model/classifier"]);+ assert!(has_system_prompt(+ &model_upstream.calls.lock().await[0],+ "economy answer prompt"+ ));+ assert!(!has_system_prompt(+ &judge_upstream.calls.lock().await[0],+ "judge target prompt"+ ));Ok(())}@@ -1341,8 +1368,6 @@ efficient_target = "weak"picker = "efficient_first"confidence_threshold = 0.5recent_turn_window = 3-capable_system_prompt = "diagnose before you edit"-efficient_system_prompt = "follow the settled plan"[routes.stage.handoff_notes]escalation_note = "the previous model was stalling"@@ -1648,16 +1673,18 @@ format = "openai_chat"base_url = "{base_url}"[targets.classifier]-id = "model/classifier"+id = "model/strong"llm_client = "upstream"[targets.strong]id = "model/strong"llm_client = "upstream"+system_prompt = "strong answer prompt"[targets.weak]id = "model/weak"llm_client = "upstream"+system_prompt = "weak answer prompt"[routes.escalation]id = "switchyard/escalation"@@ -1685,7 +1712,11 @@ escalation = {{ confirmations = 1 }}).await?;assert_eq!(response.status, StatusCode::OK);- assert_eq!(upstream.models().await, ["model/weak", "model/classifier"]);+ assert_eq!(upstream.models().await, ["model/weak", "model/strong"]);+ let calls = upstream.calls.lock().await;+ assert!(has_system_prompt(&calls[0], "weak answer prompt"));+ assert!(!has_system_prompt(&calls[1], "strong answer prompt"));+ drop(calls);let stats = send(&app,@@ -1700,7 +1731,7 @@ escalation = {{ confirmations = 1 }}assert_eq!(stats["total_prompt_tokens"], 20);assert_eq!(stats["total_completion_tokens"], 4);assert_eq!(stats["models"]["model/weak"]["calls"], 1);- assert_eq!(stats["models"]["model/classifier"]["calls"], 1);+ assert_eq!(stats["models"]["model/strong"]["calls"], 1);let process_stats = send(&app, "GET", "/v1/stats", None).await?.json()?;assert_eq!(process_stats["total_requests"], 1);@@ -1824,6 +1855,7 @@ llm_client = "responses"[targets.strong]id = "real/opus"llm_client = "claude"+system_prompt = "completion instructions"[targets.other]id = "real/sonnet"@@ -1874,6 +1906,7 @@ targets = ["responses", "other", "strong"]let calls = upstream.calls.lock().await;assert_eq!(calls.len(), 3);assert_eq!(calls[0]["model"], "real/opus");+ assert!(calls[0].get("system").is_none());assert_eq!(calls[1],json!({@@ -2715,13 +2748,23 @@ async fn unavailable_target_fails_over_across_endpoints_and_stops_when_exhausted);assert_eq!(response.json()?["model"], "model/strong");let calls = upstream.calls.lock().await;+ let candidate_calls = &calls[previous_call_count..];assert_eq!(- calls[previous_call_count..]+ candidate_calls.iter().map(|call| call["model"].as_str().unwrap_or("")).collect::<Vec<_>>(),["model/weak", "model/strong"]);+ assert!(has_system_prompt(&candidate_calls[0], "weak answer prompt"));+ assert!(has_system_prompt(+ &candidate_calls[1],+ "strong answer prompt"+ ));+ assert!(!has_system_prompt(+ &candidate_calls[1],+ "weak answer prompt"+ ));}let stats = send(&app, "GET", "/v1/stats", None).await?.json()?;@@ -3195,10 +3238,12 @@ base_url = "{base_url}"[targets.executor]id = "model/executor"llm_client = "upstream"+system_prompt = "executor answer prompt"[targets.advisor]id = "model/advisor"llm_client = "upstream"+system_prompt = "advisor target prompt"[routes.gated]id = "switchyard/advisor"@@ -3239,6 +3284,10 @@ async fn advisor_route_approve_flow_and_stats() -> TestResult {);// Executor turn first, then the review consult.assert_eq!(upstream.models().await, ["model/executor", "model/advisor"]);+ let calls = upstream.calls.lock().await;+ assert!(has_system_prompt(&calls[0], "executor answer prompt"));+ assert!(!has_system_prompt(&calls[1], "advisor target prompt"));+ drop(calls);let stats = send(&app, "GET", "/v1/stats", None).await?.json()?;assert_eq!(stats["models"]["model/executor"]["calls"], 1);diff --git a/docs/reference/toml_schema.md b/docs/reference/toml_schema.mdindex 8147b3130..2708b68db 100644--- a/docs/reference/toml_schema.md+++ b/docs/reference/toml_schema.md@@ -88,8 +88,20 @@ calls an upstream.|---|:---:|---|---|| `id` | Yes | — | Exact model ID sent upstream. || `llm_client` | Yes | — | Key under `[llm_clients]`. |+| `system_prompt` | No | unset | System prompt prepended when this target serves a completion. || `extra_body` | No | `{}` | Values merged into the upstream request when the request does not already set that key. |+Each selected or fallback target is prepared from the routed request independently. A prompt+configured for one target is therefore not carried into another target's fallback request.+Judge-only, classifier-only, and reviewer-only targets are not completion destinations and do not+receive this prompt.++Escalation's weak target and Advisor's executor produce a candidate response while routing, so+their target prompt is applied to that call. A prompted target in either role cannot use the same+model ID as that route's judge or reviewer because those calls would otherwise be indistinguishable+at the client boundary; Switchyard rejects that configuration when it loads.+Token-count requests do not apply target system prompts.+## `[routes.<name>]`Every route takes the common keys below, plus the keys for its type.@@ -236,8 +248,6 @@ optional `handoff_notes` and `classifier` tables and for tuning.| `picker` | Yes | — | `efficient_first`, or `capable_first` (experimental, unbenchmarked). Tier used when the signals are not confident. || `confidence_threshold` | Yes | — | Corroboration a decisive pick needs. In `[0, 1]`. || `recent_turn_window` | No | `3` | Trailing tool results the signals are computed over. |-| `capable_system_prompt` | No | unset | System prompt handed to the capable tier. |-| `efficient_system_prompt` | No | unset | System prompt handed to the efficient tier. || `classifier.classify_trigger` | No | `every_request` | When the judge runs. See the `llm_classifier` route. `new_session` has no effect here. || `classifier.response_format_type` | No | `json_schema` | Structured-output mode for the optional classifier judge. Use `json_object` when the classifier provider does not support JSON Schema; Switchyard adds the schema to the prompt and validates the verdict locally. || `subagents` | No | unset | Nested `passthrough` or custom `llm_classifier` policy used only for delegated sub-agent work. See [Sub-Agent-Aware Routing](../routing_algorithms/subagent_routing.md). |@@ -258,8 +268,6 @@ configuration. Today a classifier sets the tier a stage router falls open to whe| `stage.efficient_target` | Yes | — | Efficient tier. || `stage.confidence_threshold` | Yes | — | Corroboration a decisive signal needs. In `[0, 1]`. || `stage.recent_turn_window` | No | `3` | Trailing tool results the signals are computed over. |-| `stage.capable_system_prompt` | No | unset | System prompt handed to the capable tier. |-| `stage.efficient_system_prompt` | No | unset | System prompt handed to the efficient tier. || `subagents` | No | unset | Nested policy used only for delegated sub-agent work. |The tier is retained per session. A deployment that sends no session ID needsdiff --git a/docs/routing_algorithms/stage_router_routing.md b/docs/routing_algorithms/stage_router_routing.mdindex c91750d00..95c484721 100644--- a/docs/routing_algorithms/stage_router_routing.md+++ b/docs/routing_algorithms/stage_router_routing.md@@ -185,10 +185,12 @@ api_key_env = "OPENROUTER_API_KEY"[targets.strong]id = "openai/gpt-4o"llm_client = "openrouter"+# system_prompt = "diagnose before you edit" # optional[targets.weak]id = "openai/gpt-4o-mini"llm_client = "openrouter"+# system_prompt = "follow the settled plan" # optional[routes.stage]id = "switchyard/stage"@@ -222,15 +224,6 @@ escalation_note = "the previous model was stalling; pick up the diagnosis"# only_on_wrong_signal_escalation = true # default; set false to always send```-### Optional: per-tier system prompts--```toml-[routes.stage]-# ...-capable_system_prompt = "diagnose before you edit"-efficient_system_prompt = "follow the settled plan"-```-### Optional: LLM classifier fallbackThe block is optional, and omitting it is the default. With no