firstpass 0.1.2__tar.gz → 0.1.4__tar.gz

{firstpass-0.1.2 → firstpass-0.1.4}/Cargo.lock

@@ -294,7 +294,7 @@ checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[package]]
 name = "firstpass-bench"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "firstpass-core",
  "reqwest",
@@ -304,7 +304,7 @@ dependencies = [
 
 [[package]]
 name = "firstpass-core"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "hex",
  "jiff",
@@ -318,7 +318,7 @@ dependencies = [
 
 [[package]]
 name = "firstpass-proxy"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "async-trait",
  "axum",

{firstpass-0.1.2 → firstpass-0.1.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.1.2"
+version = "0.1.4"
 edition = "2024"
 rust-version = "1.93"
 license = "Apache-2.0"
@@ -38,7 +38,7 @@ metrics = "0.24"
 metrics-exporter-prometheus = { version = "0.18", default-features = false }
 
 # Internal crates
-firstpass-core = { path = "crates/firstpass-core", version = "0.1.2" }
+firstpass-core = { path = "crates/firstpass-core", version = "0.1.4" }
 
 [profile.release]
 lto = "thin"

{firstpass-0.1.2 → firstpass-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firstpass
-Version: 0.1.2
+Version: 0.1.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Build Tools

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-core/src/config.rs

@@ -38,6 +38,41 @@ pub struct Config {
     /// `deferred_gates`. Declared as `[[gate]]` sections in TOML.
     #[serde(rename = "gate", default)]
     pub gate_defs: Vec<GateDef>,
+    /// Extra model providers a ladder can route to, beyond the built-in `anthropic` / `openai`.
+    /// Any OpenAI-compatible endpoint (Groq, Together, Fireworks, DeepSeek, Mistral, xAI,
+    /// OpenRouter, Ollama, vLLM, Azure, …) is one `[[provider]]` entry — no rebuild. Declared as
+    /// `[[provider]]` sections; a ladder rung is then `<id>/<model>`.
+    #[serde(rename = "provider", default)]
+    pub providers: Vec<ProviderDef>,
+}
+
+/// The wire API a provider speaks. `anthropic` = Messages API; `openai` = Chat Completions API
+/// (the de-facto standard that nearly every hosted and open-source model host implements).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Dialect {
+    /// Anthropic Messages API (`POST /v1/messages`).
+    Anthropic,
+    /// OpenAI Chat Completions API (`POST /v1/chat/completions`).
+    Openai,
+}
+
+/// A model provider a ladder can route to. Declared as `[[provider]]` in TOML; referenced from a
+/// ladder as `<id>/<model>` (e.g. `groq/llama-3.3-70b-versatile`).
+#[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ProviderDef {
+    /// Ladder prefix for this provider, e.g. `"groq"`. Overrides a built-in of the same id.
+    pub id: String,
+    /// Which wire API it speaks.
+    pub dialect: Dialect,
+    /// Base URL, e.g. `"https://api.groq.com/openai"` or `"http://localhost:11434"` for Ollama.
+    pub base_url: String,
+    /// Env var the API key is read from at call time, e.g. `"GROQ_API_KEY"`. Omit for a keyless
+    /// endpoint (local Ollama / vLLM). Per-request BYOK headers still apply to the built-in
+    /// `anthropic` / `openai` providers.
+    #[serde(default)]
+    pub api_key_env: Option<String>,
 }
 
 /// A user-defined gate (SPEC §8.1). Exactly one kind per definition:
@@ -228,6 +263,32 @@ pub struct Escalation {
     /// aggregate gate verdict is `Pass` — byte-identical to today.
     #[serde(default)]
     pub serve_threshold: Option<f64>,
+    /// Online/adaptive conformal (Gibbs-Candès ACI): when set, the serve threshold is tracked
+    /// **live** from deferred feedback instead of held fixed, so served-failure stays at target under
+    /// distribution shift. `None` (default) uses the fixed `serve_threshold` above — byte-identical.
+    #[serde(default)]
+    pub adaptive: Option<AdaptiveConfig>,
+    /// Opt-in: route tool-calling / multimodal requests through enforce instead of falling back to
+    /// observe (ADR 0005). `false` (default) is byte-identical to today — such requests pass through
+    /// un-gated. Turn on **only after** verifying enforce faithfully round-trips your tool workload;
+    /// content fidelity is preserved either way, but escalating a live tool turn is operator-gated.
+    #[serde(default)]
+    pub enforce_structured: bool,
+}
+
+/// Config for online/adaptive conformal serving ([`crate::conformal::AdaptiveConformal`]).
+#[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct AdaptiveConfig {
+    /// Target served-failure rate the online loop holds to.
+    pub alpha: f64,
+    /// Step size (default 0.02) — larger tracks shift faster but noisier.
+    #[serde(default = "default_adaptive_gamma")]
+    pub gamma: f64,
+}
+
+fn default_adaptive_gamma() -> f64 {
+    0.02
 }
 
 const fn default_max_rungs() -> u32 {
@@ -241,6 +302,8 @@ impl Default for Escalation {
             session_promotion: None,
             speculation: 0,
             serve_threshold: None,
+            adaptive: None,
+            enforce_structured: false,
         }
     }
 }
@@ -480,6 +543,54 @@ timeout_ms = 60000
         assert!(matches!(Config::parse(dup), Err(Error::InvalidConfig(_))));
     }
 
+    #[test]
+    fn parses_adaptive_conformal_config() {
+        let c = Config::parse("[escalation.adaptive]\nalpha = 0.1\n").unwrap();
+        let a = c
+            .escalation
+            .adaptive
+            .expect("[escalation.adaptive] should parse");
+        assert!((a.alpha - 0.1).abs() < 1e-9);
+        assert!((a.gamma - 0.02).abs() < 1e-9, "gamma defaults to 0.02");
+        // Absent => None (fixed-threshold serving, default byte-identical behavior).
+        assert!(Config::parse("").unwrap().escalation.adaptive.is_none());
+    }
+
+    #[test]
+    fn parses_provider_entries_and_ladders_can_reference_them() {
+        let c = Config::parse(
+            r#"
+[[provider]]
+id = "groq"
+dialect = "openai"
+base_url = "https://api.groq.com/openai"
+api_key_env = "GROQ_API_KEY"
+
+[[provider]]
+id = "ollama"
+dialect = "openai"
+base_url = "http://localhost:11434"
+
+[[route]]
+match = {}
+mode = "enforce"
+ladder = ["groq/llama-3.3-70b-versatile", "anthropic/claude-sonnet-5"]
+"#,
+        )
+        .unwrap();
+        assert_eq!(c.providers.len(), 2);
+        let groq = &c.providers[0];
+        assert_eq!(groq.id, "groq");
+        assert_eq!(groq.dialect, Dialect::Openai);
+        assert_eq!(groq.base_url, "https://api.groq.com/openai");
+        assert_eq!(groq.api_key_env.as_deref(), Some("GROQ_API_KEY"));
+        // A keyless local endpoint (Ollama) parses with no api_key_env.
+        assert_eq!(c.providers[1].id, "ollama");
+        assert!(c.providers[1].api_key_env.is_none());
+        // Absent => no extra providers (built-ins only).
+        assert!(Config::parse("").unwrap().providers.is_empty());
+    }
+
     #[test]
     fn empty_match_is_wildcard() {
         let m = Match::default();

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-core/src/lib.rs

@@ -31,8 +31,8 @@ pub mod trace;
 pub mod verdict;
 
 pub use config::{
-    Budget, Config, Escalation, GateDef, JudgeDef, Mode, ModelRef, OnExhausted, Route,
-    SessionPromotion,
+    Budget, Config, Dialect, Escalation, GateDef, JudgeDef, Mode, ModelRef, OnExhausted,
+    ProviderDef, Route, SessionPromotion,
 };
 pub use conformal::{ConformalResult, calibrate, served_failure_rate};
 pub use cost::{ModelPrice, PriceTable};

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-proxy/examples/demo.rs

@@ -174,6 +174,7 @@ async fn spawn_proxy(upstream: &str, db: &std::path::Path) -> String {
         providers,
         gate_health: Arc::new(firstpass_proxy::gate::GateHealthRegistry::new()),
         traces,
+        adaptive: None,
     };
     let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
     let addr = listener.local_addr().unwrap();

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-proxy/src/judge.rs

@@ -115,10 +115,7 @@ pub fn build_judge_request(judge_model: &str, rubric: &str, candidate: &str) ->
     ModelRequest {
         model: judge_model.to_owned(),
         system: Some(JUDGE_SYSTEM.to_owned()),
-        messages: vec![ChatMessage {
-            role: "user".to_owned(),
-            content: user,
-        }],
+        messages: vec![ChatMessage::text("user", user)],
         max_tokens: 256,
         tools: Value::Null, // the judge runs no tools (§8.3)
     }
@@ -215,7 +212,7 @@ mod tests {
             "system pins anti-injection"
         );
         assert_eq!(req.tools, Value::Null, "judge runs no tools");
-        let user = &req.messages[0].content;
+        let user = req.messages[0].text_view();
         assert!(user.contains("BEGIN_CANDIDATE") && user.contains("the answer is 42"));
     }
 

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-proxy/src/provider.rs

@@ -11,20 +11,50 @@ use axum::http::HeaderMap;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-/// One message in a normalized chat conversation.
+/// One message in a normalized chat conversation. `content` is either a plain string (the common
+/// case — serializes byte-identically to a text message) OR the original array of content blocks
+/// (`text` / `tool_use` / `tool_result` / `image`), forwarded verbatim so tool and multimodal turns
+/// survive the enforce path (ADR 0005). Use [`ChatMessage::text_view`] to read a text projection for
+/// gating.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ChatMessage {
     /// `"user"`, `"assistant"`, or `"system"`.
     pub role: String,
-    /// Message text.
-    pub content: String,
+    /// Message content — a string, or an array of content blocks, forwarded as-is to the provider.
+    pub content: Value,
+}
+
+impl ChatMessage {
+    /// A text-only message (the common path).
+    #[must_use]
+    pub fn text(role: impl Into<String>, content: impl Into<String>) -> Self {
+        Self {
+            role: role.into(),
+            content: Value::String(content.into()),
+        }
+    }
+
+    /// Concatenate the text this message carries, for gating. A string is itself; an array yields the
+    /// joined `text` blocks (tool_use/tool_result/image blocks contribute no gating text).
+    #[must_use]
+    pub fn text_view(&self) -> String {
+        match &self.content {
+            Value::String(s) => s.clone(),
+            Value::Array(blocks) => blocks
+                .iter()
+                .filter_map(|b| b.get("text").and_then(Value::as_str))
+                .collect::<Vec<_>>()
+                .join("\n"),
+            _ => String::new(),
+        }
+    }
 }
 
 /// A provider-agnostic model request, built once per incoming call and re-used (with
 /// `model` swapped) across every rung of the ladder.
 ///
-// ponytail: multimodal content and tool-result blocks are collapsed to plain text for now —
-// enough to route and gate on. A richer content-block model is a later batch.
+// Message content is carried verbatim (string or content-block array, ADR 0005); gates read a text
+// projection via `ChatMessage::text_view`. `tools` is opaque passthrough.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ModelRequest {
     /// `provider/model`, e.g. `"anthropic/claude-haiku-4-5"`.
@@ -153,7 +183,7 @@ pub trait Provider: Send + Sync + std::fmt::Debug {
 #[derive(Serialize)]
 struct AnthropicWireMessage<'a> {
     role: &'a str,
-    content: &'a str,
+    content: &'a Value,
 }
 
 /// Strip the `provider/` prefix from a ladder model id for the provider's wire API — Anthropic and
@@ -163,6 +193,17 @@ fn wire_model(model: &str) -> &str {
     model.split_once('/').map_or(model, |(_, m)| m)
 }
 
+/// Resolve the API key for a provider call. A configured `api_key_env` wins (that env var is *this*
+/// provider's key — e.g. `GROQ_API_KEY` for a Groq rung); otherwise fall back to the per-request
+/// BYOK override from headers/env (the built-in `anthropic`/`openai` path). Empty string when
+/// neither is set (a keyless local endpoint).
+fn resolve_api_key(api_key_env: Option<&str>, byok_override: Option<&str>) -> String {
+    api_key_env
+        .and_then(|e| std::env::var(e).ok())
+        .or_else(|| byok_override.map(str::to_owned))
+        .unwrap_or_default()
+}
+
 #[derive(Serialize)]
 struct AnthropicWireRequest<'a> {
     model: &'a str,
@@ -179,8 +220,13 @@ struct AnthropicWireRequest<'a> {
 // wire call (see `wire_model`); sending it verbatim 404s.
 #[derive(Debug, Clone)]
 pub struct AnthropicProvider {
+    /// Ladder prefix / trace label for this provider (usually `"anthropic"`).
+    pub id: String,
     /// Base URL, e.g. `https://api.anthropic.com`.
     pub base_url: String,
+    /// Env var the API key is read from when no per-request BYOK header is present. `None` for the
+    /// built-in provider, which resolves the key via [`Auth`] (`x-api-key` header or env).
+    pub api_key_env: Option<String>,
     /// Shared, connection-pooled HTTP client.
     pub http: reqwest::Client,
 }
@@ -188,7 +234,7 @@ pub struct AnthropicProvider {
 #[async_trait]
 impl Provider for AnthropicProvider {
     fn id(&self) -> &str {
-        "anthropic"
+        &self.id
     }
 
     async fn complete(
@@ -196,7 +242,7 @@ impl Provider for AnthropicProvider {
         req: &ModelRequest,
         auth: &Auth,
     ) -> Result<ModelResponse, ProviderError> {
-        let key = auth.anthropic_key.as_deref().unwrap_or_default();
+        let key = resolve_api_key(self.api_key_env.as_deref(), auth.anthropic_key.as_deref());
         let body = AnthropicWireRequest {
             model: wire_model(&req.model),
             system: req.system.as_deref(),
@@ -272,7 +318,7 @@ impl Provider for AnthropicProvider {
 #[derive(Serialize)]
 struct OpenAiWireMessage<'a> {
     role: &'a str,
-    content: &'a str,
+    content: Value,
 }
 
 #[derive(Serialize)]
@@ -289,8 +335,14 @@ struct OpenAiWireRequest<'a> {
 // before relying on it in production.
 #[derive(Debug, Clone)]
 pub struct OpenAiProvider {
-    /// Base URL, e.g. `https://api.openai.com`.
+    /// Ladder prefix / trace label for this provider (`"openai"`, `"groq"`, `"together"`, …).
+    pub id: String,
+    /// Base URL, e.g. `https://api.openai.com` or `https://api.groq.com/openai`.
     pub base_url: String,
+    /// Env var the API key is read from, e.g. `"GROQ_API_KEY"`. `None` for the built-in `openai`
+    /// provider (resolves via [`Auth`]: `authorization` header or `OPENAI_API_KEY`) and for keyless
+    /// local endpoints (Ollama / vLLM).
+    pub api_key_env: Option<String>,
     /// Shared, connection-pooled HTTP client.
     pub http: reqwest::Client,
 }
@@ -298,7 +350,7 @@ pub struct OpenAiProvider {
 #[async_trait]
 impl Provider for OpenAiProvider {
     fn id(&self) -> &str {
-        "openai"
+        &self.id
     }
 
     async fn complete(
@@ -306,17 +358,17 @@ impl Provider for OpenAiProvider {
         req: &ModelRequest,
         auth: &Auth,
     ) -> Result<ModelResponse, ProviderError> {
-        let key = auth.openai_key.as_deref().unwrap_or_default();
+        let key = resolve_api_key(self.api_key_env.as_deref(), auth.openai_key.as_deref());
         let mut messages = Vec::with_capacity(req.messages.len() + 1);
         if let Some(system) = req.system.as_deref() {
             messages.push(OpenAiWireMessage {
                 role: "system",
-                content: system,
+                content: Value::String(system.to_owned()),
             });
         }
         messages.extend(req.messages.iter().map(|m| OpenAiWireMessage {
             role: &m.role,
-            content: &m.content,
+            content: m.content.clone(),
         }));
         let body = OpenAiWireRequest {
             model: wire_model(&req.model),
@@ -393,34 +445,72 @@ impl std::fmt::Debug for ProviderRegistry {
 }
 
 impl ProviderRegistry {
-    /// Build the standard registry: Anthropic + OpenAI, sharing one HTTP client.
-    ///
-    /// The enforce path is request/response (never streamed through the adapter), so the client
-    /// carries a total request timeout as well as a connect timeout — a hung or slow upstream can't
-    /// pin a routing decision indefinitely. Falls back to a default client if the builder fails
-    /// (only on TLS backend init, which is fatal anyway).
-    #[must_use]
-    pub fn new(anthropic_base: impl Into<String>, openai_base: impl Into<String>) -> Self {
-        let http = reqwest::Client::builder()
+    /// One HTTP client shared by every provider. The enforce path is request/response (never
+    /// streamed through the adapter), so it carries a total request timeout as well as a connect
+    /// timeout — a hung or slow upstream can't pin a routing decision indefinitely. Falls back to a
+    /// default client if the builder fails (only on TLS backend init, which is fatal anyway).
+    fn build_http_client() -> reqwest::Client {
+        reqwest::Client::builder()
             .connect_timeout(std::time::Duration::from_secs(10))
             .timeout(std::time::Duration::from_secs(120))
             .build()
-            .unwrap_or_else(|_| reqwest::Client::new());
+            .unwrap_or_else(|_| reqwest::Client::new())
+    }
+
+    /// Build the standard registry: the built-in `anthropic` + `openai` providers.
+    #[must_use]
+    pub fn new(anthropic_base: impl Into<String>, openai_base: impl Into<String>) -> Self {
+        Self::from_config(&[], anthropic_base, openai_base)
+    }
+
+    /// Build the registry with the built-in `anthropic` / `openai` providers plus every configured
+    /// `[[provider]]` entry — so a ladder can route to any OpenAI-compatible or Anthropic-compatible
+    /// endpoint (Groq, Together, Fireworks, DeepSeek, Mistral, xAI, OpenRouter, Ollama, vLLM, Azure,
+    /// …) by id. A `[[provider]]` whose id is `anthropic` or `openai` overrides the built-in default
+    /// (e.g. to point `openai` at Azure). Shares one HTTP client across all of them.
+    #[must_use]
+    pub fn from_config(
+        defs: &[firstpass_core::ProviderDef],
+        anthropic_base: impl Into<String>,
+        openai_base: impl Into<String>,
+    ) -> Self {
+        let http = Self::build_http_client();
         let mut providers: HashMap<String, Arc<dyn Provider>> = HashMap::new();
         providers.insert(
             "anthropic".to_owned(),
             Arc::new(AnthropicProvider {
+                id: "anthropic".to_owned(),
                 base_url: anthropic_base.into(),
+                api_key_env: None,
                 http: http.clone(),
             }),
         );
         providers.insert(
             "openai".to_owned(),
             Arc::new(OpenAiProvider {
+                id: "openai".to_owned(),
                 base_url: openai_base.into(),
-                http,
+                api_key_env: None,
+                http: http.clone(),
             }),
         );
+        for def in defs {
+            let provider: Arc<dyn Provider> = match def.dialect {
+                firstpass_core::Dialect::Anthropic => Arc::new(AnthropicProvider {
+                    id: def.id.clone(),
+                    base_url: def.base_url.clone(),
+                    api_key_env: def.api_key_env.clone(),
+                    http: http.clone(),
+                }),
+                firstpass_core::Dialect::Openai => Arc::new(OpenAiProvider {
+                    id: def.id.clone(),
+                    base_url: def.base_url.clone(),
+                    api_key_env: def.api_key_env.clone(),
+                    http: http.clone(),
+                }),
+            };
+            providers.insert(def.id.clone(), provider);
+        }
         Self { providers }
     }
 
@@ -519,6 +609,100 @@ mod tests {
         assert_eq!(wire_model("claude-opus-4-8"), "claude-opus-4-8"); // no prefix → unchanged
     }
 
+    #[test]
+    fn from_config_registers_custom_providers_alongside_builtins() {
+        let defs = vec![
+            firstpass_core::ProviderDef {
+                id: "groq".to_owned(),
+                dialect: firstpass_core::Dialect::Openai,
+                base_url: "https://api.groq.com/openai".to_owned(),
+                api_key_env: Some("GROQ_API_KEY".to_owned()),
+            },
+            // A custom provider may override a built-in id (e.g. point `openai` at Azure).
+            firstpass_core::ProviderDef {
+                id: "openai".to_owned(),
+                dialect: firstpass_core::Dialect::Openai,
+                base_url: "https://my-azure.openai.azure.com".to_owned(),
+                api_key_env: Some("AZURE_OPENAI_KEY".to_owned()),
+            },
+        ];
+        let reg = ProviderRegistry::from_config(
+            &defs,
+            "https://api.anthropic.com",
+            "https://api.openai.com",
+        );
+        // Built-in anthropic is still present; the custom groq resolves and labels itself "groq".
+        assert_eq!(reg.get("anthropic").unwrap().id(), "anthropic");
+        assert_eq!(reg.get("groq").unwrap().id(), "groq");
+        // Unknown provider → None (router fails over rather than guessing).
+        assert!(reg.get("does-not-exist").is_none());
+    }
+
+    #[test]
+    fn resolve_api_key_prefers_configured_env_then_byok() {
+        // Use PATH (always present) to exercise the env branch without mutating process env.
+        let path = std::env::var("PATH").expect("PATH is set");
+        // Configured env wins over any BYOK override (the env var is *this* provider's key).
+        assert_eq!(resolve_api_key(Some("PATH"), Some("byok")), path);
+        // An unset configured env → fall back to the per-request BYOK override.
+        assert_eq!(
+            resolve_api_key(Some("FIRSTPASS_DEFINITELY_UNSET_KEY"), Some("byok")),
+            "byok"
+        );
+        // No configured env → fall back to BYOK.
+        assert_eq!(resolve_api_key(None, Some("byok")), "byok");
+        // Neither → empty (keyless local endpoint).
+        assert_eq!(resolve_api_key(None, None), "");
+    }
+
+    #[test]
+    fn anthropic_wire_forwards_tool_and_image_content_verbatim() {
+        // ADR 0005 I3 (request side): the Anthropic adapter serializes tool_use / tool_result /
+        // image content blocks byte-for-byte into the wire body — enforce forwards them, it does not
+        // flatten them. A plain-string message still serializes as a bare string (I1).
+        let messages = [
+            ChatMessage::text("user", "hi"),
+            ChatMessage {
+                role: "assistant".to_owned(),
+                content: serde_json::json!([
+                    { "type": "tool_use", "id": "t1", "name": "calc", "input": { "x": 1 } }
+                ]),
+            },
+            ChatMessage {
+                role: "user".to_owned(),
+                content: serde_json::json!([
+                    { "type": "tool_result", "tool_use_id": "t1", "content": "2" },
+                    { "type": "image", "source": { "type": "base64", "media_type": "image/png", "data": "AA==" } }
+                ]),
+            },
+        ];
+        let body = AnthropicWireRequest {
+            model: "claude-haiku-4-5",
+            system: None,
+            max_tokens: 64,
+            messages: messages
+                .iter()
+                .map(|m| AnthropicWireMessage {
+                    role: &m.role,
+                    content: &m.content,
+                })
+                .collect(),
+        };
+        let wire = serde_json::to_value(&body).unwrap();
+        assert_eq!(wire["messages"][0]["content"], serde_json::json!("hi"));
+        assert_eq!(
+            wire["messages"][1]["content"],
+            serde_json::json!([{ "type": "tool_use", "id": "t1", "name": "calc", "input": { "x": 1 } }])
+        );
+        assert_eq!(
+            wire["messages"][2]["content"],
+            serde_json::json!([
+                { "type": "tool_result", "tool_use_id": "t1", "content": "2" },
+                { "type": "image", "source": { "type": "base64", "media_type": "image/png", "data": "AA==" } }
+            ])
+        );
+    }
+
     fn resp(model: &str, text: &str) -> ModelResponse {
         ModelResponse {
             model: model.to_owned(),

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-proxy/src/proxy.rs

@@ -45,6 +45,10 @@ pub struct AppState {
     pub gate_health: Arc<GateHealthRegistry>,
     /// Fire-and-forget sender to the background trace writer.
     pub traces: store::TraceSender,
+    /// Optional online/adaptive conformal serve threshold (Gibbs-Candès ACI). `None` = fixed
+    /// `serve_threshold` from config (default). When present, `/v1/feedback` nudges it live and the
+    /// enforce path reads its current value per request — the reactive, self-tuning loop.
+    pub adaptive: Option<Arc<std::sync::Mutex<firstpass_core::conformal::AdaptiveConformal>>>,
 }
 
 impl std::fmt::Debug for AppState {
@@ -222,6 +226,12 @@ async fn feedback(State(state): State<AppState>, body: Bytes) -> Response {
         }
     }
 
+    // Correctness signal for the online adaptive loop — only a clear Pass/Fail nudges the threshold.
+    let feedback_signal = match verdict {
+        Verdict::Pass => Some(true),
+        Verdict::Fail => Some(false),
+        Verdict::Abstain => None,
+    };
     let dv = DeferredVerdict {
         gate_id: req.gate_id,
         verdict,
@@ -232,11 +242,19 @@ async fn feedback(State(state): State<AppState>, body: Bytes) -> Response {
     let trace_id = req.trace_id.clone();
     match tokio::task::spawn_blocking(move || store::append_deferred(&db, &req.trace_id, &dv)).await
     {
-        Ok(Ok(())) => (
-            axum::http::StatusCode::ACCEPTED,
-            Json(serde_json::json!({ "status": "recorded", "trace_id": trace_id })),
-        )
-            .into_response(),
+        Ok(Ok(())) => {
+            // Close the reactive loop: nudge the live serve threshold toward the target.
+            if let (Some(a), Some(correct)) = (state.adaptive.as_ref(), feedback_signal)
+                && let Ok(mut g) = a.lock()
+            {
+                g.observe_served(correct);
+            }
+            (
+                axum::http::StatusCode::ACCEPTED,
+                Json(serde_json::json!({ "status": "recorded", "trace_id": trace_id })),
+            )
+                .into_response()
+        }
         Ok(Err(e)) => {
             tracing::error!(%e, "feedback: append_deferred failed");
             ProxyError::Internal(e.to_string()).into_response()
@@ -275,29 +293,35 @@ async fn messages(State(state): State<AppState>, headers: HeaderMap, body: Bytes
             // Clone the matched route so no borrow of `state.config` is held across the await;
             // routes are tiny (a handful of strings).
             let route = route.clone();
-            if enforce_can_handle(&features, &body) {
+            if enforce_can_handle(&features, &body, routing.escalation.enforce_structured) {
                 return handle_enforce(&state, &headers, &body, features, &route, session_header)
                     .await;
             }
-            // The request carries tools / images / tool-result blocks the text-only enforce path
-            // can't round-trip faithfully yet. Rather than drop them and serve corrupted output,
-            // fall through to transparent observe passthrough (correct, un-gated) for this request.
+            // With `enforce_structured` off (default), tool/image/tool-block requests fall through
+            // to transparent observe passthrough (correct, un-gated) rather than being routed —
+            // byte-identical to before ADR 0005. (With it on, `enforce_can_handle` returns true and
+            // we never reach here.)
             tracing::info!(
-                "enforce route matched but request has tool/image content; serving via observe passthrough"
+                "enforce route matched but request carries tools/images; serving via observe passthrough"
             );
         }
     }
     observe_passthrough(state, headers, body, session_header).await
 }
 
-/// Whether the enforce path can faithfully handle this request. Enforce normalizes content to
-/// text and re-synthesizes a text response, so it cannot round-trip tool calls or images — a
-/// request that declares tools, carries images, or contains tool_use/tool_result blocks is served
-/// via transparent observe passthrough instead of being silently corrupted.
+/// Whether the enforce path can faithfully handle this request.
 ///
-// ponytail: full tool/multimodal round-tripping through the ladder is the follow-on (needs
-// provider-adapter work + live verification); this guard just refuses to corrupt in the meantime.
-fn enforce_can_handle(features: &Features, body: &[u8]) -> bool {
+/// Request content is carried verbatim (ADR 0005 P1), so tool_use/tool_result/image blocks survive
+/// the round trip, and a streaming client is served the gated result as SSE (P3). Whether such
+/// requests are actually *routed* is the operator's call:
+/// - `enforce_structured == false` (default): tools/images/tool-blocks fall back to observe —
+///   byte-identical to before the ADR (invariant I1).
+/// - `enforce_structured == true` (opt-in, live-verified): tools, images, and streaming all route
+///   through enforce.
+fn enforce_can_handle(features: &Features, body: &[u8], enforce_structured: bool) -> bool {
+    if enforce_structured {
+        return true;
+    }
     features.tool_count == 0 && !features.has_images && !messages_have_tool_blocks(body)
 }
 
@@ -394,6 +418,13 @@ async fn handle_enforce(
         ),
         None => (None, 3, 0, None),
     };
+    // Online adaptive conformal: serve against the LIVE-tracked threshold (updated by /v1/feedback).
+    // Falls back to the fixed config threshold when adaptive is off or its lock is poisoned.
+    let serve_threshold = state
+        .adaptive
+        .as_ref()
+        .and_then(|a| a.lock().ok().map(|g| g.threshold()))
+        .or(serve_threshold);
 
     let ctx = EnforceCtx {
         ladder: &route.ladder,
@@ -420,11 +451,25 @@ async fn handle_enforce(
     offer_trace(&state.traces, trace);
 
     match outcome {
-        EngineOutcome::Served(resp) => (
-            axum::http::StatusCode::OK,
-            Json(anthropic_response_json(&resp)),
-        )
-            .into_response(),
+        EngineOutcome::Served(resp) => {
+            let message = anthropic_response_json(&resp);
+            // A streaming client gets the gated result re-emitted as SSE (ADR 0005 P3): the gate
+            // needs the whole candidate, so enforce can't stream token-by-token from the model — it
+            // buffers to gate, then streams the served blocks out. tool_use blocks are preserved.
+            if is_stream_request(body) {
+                (
+                    axum::http::StatusCode::OK,
+                    [(
+                        axum::http::header::CONTENT_TYPE,
+                        "text/event-stream; charset=utf-8",
+                    )],
+                    anthropic_sse_from_message(&message),
+                )
+                    .into_response()
+            } else {
+                (axum::http::StatusCode::OK, Json(message)).into_response()
+            }
+        }
         EngineOutcome::Failed(msg) => ProxyError::Engine(msg).into_response(),
     }
 }
@@ -432,10 +477,11 @@ async fn handle_enforce(
 /// Parse an Anthropic Messages request body into the normalized [`ModelRequest`]. Returns
 /// `None` if the body isn't valid JSON or lacks a `messages` array.
 ///
-// Content blocks are collapsed to their concatenated text. Requests carrying tool_use/tool_result
-// or image blocks never reach this function — `enforce_can_handle` routes them to transparent
-// observe passthrough instead, so nothing is silently dropped here. Full multimodal round-tripping
-// through the ladder is the follow-up; the enforce beachhead is text/code.
+// Message content is preserved **verbatim** (string or array of blocks) — a plain-string content
+// serializes byte-identical on the wire, and tool_use/tool_result/image blocks survive the round
+// trip (ADR 0005, invariant I2). Gates operate on `ChatMessage::text_view()`, not the raw content,
+// so gate behavior is unchanged. Which requests actually enter enforce is still governed by
+// `enforce_can_handle`; this function only guarantees no fidelity is lost once they do.
 fn parse_model_request(body: &[u8]) -> Option<ModelRequest> {
     let json: Value = serde_json::from_slice(body).ok()?;
     let messages_json = json.get("messages")?.as_array()?;
@@ -447,7 +493,10 @@ fn parse_model_request(body: &[u8]) -> Option<ModelRequest> {
                 .and_then(Value::as_str)
                 .unwrap_or("user")
                 .to_owned(),
-            content: content_to_text(m.get("content")),
+            content: m
+                .get("content")
+                .cloned()
+                .unwrap_or_else(|| Value::String(String::new())),
         })
         .collect();
     let system = json
@@ -473,32 +522,127 @@ fn parse_model_request(body: &[u8]) -> Option<ModelRequest> {
     })
 }
 
-/// Flatten Anthropic message content (a string, or an array of `{type,text}` blocks) to text.
-fn content_to_text(content: Option<&Value>) -> String {
-    match content {
-        Some(Value::String(s)) => s.clone(),
-        Some(Value::Array(blocks)) => blocks
-            .iter()
-            .filter_map(|b| b.get("text").and_then(Value::as_str))
-            .collect::<Vec<_>>()
-            .join("\n"),
-        _ => String::new(),
-    }
-}
-
 /// Render a served [`ModelResponse`] back into an Anthropic Messages response envelope, so the
 /// caller sees the same wire shape regardless of which provider actually answered.
+///
+/// The `content` blocks come **verbatim** from the upstream response (`resp.raw`) when it is an
+/// Anthropic message — so `tool_use` / `thinking` / multiple text blocks reach the caller intact
+/// (ADR 0005 I2). Only when `raw` has no Anthropic `content` array (a synthetic response, or the
+/// OpenAI adapter, which has `choices` instead) do we fall back to a single reconstructed text
+/// block. The envelope (`id`, `model`, `usage`) is always normalized so the served model id is the
+/// prefixed ladder id, not the bare wire id.
 fn anthropic_response_json(resp: &ModelResponse) -> Value {
+    let content = resp
+        .raw
+        .get("content")
+        .filter(|c| c.is_array())
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!([{ "type": "text", "text": resp.text }]));
     serde_json::json!({
         "id": format!("msg_{}", Uuid::now_v7()),
         "type": "message",
         "role": "assistant",
         "model": resp.model,
-        "content": [{ "type": "text", "text": resp.text }],
+        "content": content,
         "usage": { "input_tokens": resp.in_tokens, "output_tokens": resp.out_tokens },
     })
 }
 
+/// Append one `event: <type>\ndata: <json>\n\n` SSE frame.
+fn sse_event(out: &mut String, event: &str, data: &Value) {
+    out.push_str("event: ");
+    out.push_str(event);
+    out.push_str("\ndata: ");
+    out.push_str(&data.to_string());
+    out.push_str("\n\n");
+}
+
+/// Re-emit a served Anthropic message envelope (from [`anthropic_response_json`]) as an SSE stream
+/// body, so a `stream: true` client is served even though enforce buffered the response to gate it
+/// (ADR 0005 P3). The gate needs the full candidate, so this is not token-by-token streaming from
+/// the model — each content block is emitted as a single delta. `tool_use` blocks are preserved:
+/// their `input` is streamed as one `input_json_delta` (invariant I2), so the caller reconstructs
+/// the exact tool call.
+fn anthropic_sse_from_message(message: &Value) -> String {
+    let mut out = String::new();
+
+    // message_start carries the envelope with content emptied — the blocks stream next.
+    let mut start_msg = message.clone();
+    start_msg["content"] = Value::Array(Vec::new());
+    sse_event(
+        &mut out,
+        "message_start",
+        &serde_json::json!({ "type": "message_start", "message": start_msg }),
+    );
+
+    let empty = Vec::new();
+    let blocks = message
+        .get("content")
+        .and_then(Value::as_array)
+        .unwrap_or(&empty);
+    for (i, block) in blocks.iter().enumerate() {
+        match block.get("type").and_then(Value::as_str) {
+            Some("tool_use") => {
+                // Start with an empty input object, then stream the real input as one JSON delta.
+                let mut shell = block.clone();
+                shell["input"] = serde_json::json!({});
+                sse_event(
+                    &mut out,
+                    "content_block_start",
+                    &serde_json::json!({ "type": "content_block_start", "index": i, "content_block": shell }),
+                );
+                let input_json = block
+                    .get("input")
+                    .map_or_else(|| "{}".to_owned(), std::string::ToString::to_string);
+                sse_event(
+                    &mut out,
+                    "content_block_delta",
+                    &serde_json::json!({ "type": "content_block_delta", "index": i,
+                        "delta": { "type": "input_json_delta", "partial_json": input_json } }),
+                );
+            }
+            _ => {
+                // text (and any other text-bearing block): start empty, stream the text as one delta.
+                let text = block.get("text").and_then(Value::as_str).unwrap_or("");
+                sse_event(
+                    &mut out,
+                    "content_block_start",
+                    &serde_json::json!({ "type": "content_block_start", "index": i,
+                        "content_block": { "type": "text", "text": "" } }),
+                );
+                sse_event(
+                    &mut out,
+                    "content_block_delta",
+                    &serde_json::json!({ "type": "content_block_delta", "index": i,
+                        "delta": { "type": "text_delta", "text": text } }),
+                );
+            }
+        }
+        sse_event(
+            &mut out,
+            "content_block_stop",
+            &serde_json::json!({ "type": "content_block_stop", "index": i }),
+        );
+    }
+
+    let out_tokens = message
+        .pointer("/usage/output_tokens")
+        .cloned()
+        .unwrap_or_else(|| Value::from(0));
+    sse_event(
+        &mut out,
+        "message_delta",
+        &serde_json::json!({ "type": "message_delta", "delta": { "stop_reason": "end_turn" },
+            "usage": { "output_tokens": out_tokens } }),
+    );
+    sse_event(
+        &mut out,
+        "message_stop",
+        &serde_json::json!({ "type": "message_stop" }),
+    );
+    out
+}
+
 /// Observe mode (SPEC §7.1a): forward unchanged, return unchanged, trace asynchronously.
 async fn observe_passthrough(
     state: AppState,
@@ -922,7 +1066,7 @@ mod tests {
     }
 
     #[test]
-    fn parse_model_request_flattens_content_blocks() {
+    fn parse_model_request_preserves_content_verbatim_and_projects_text() {
         let body = br#"{"model":"m","system":"sys","max_tokens":50,
             "messages":[{"role":"user","content":[{"type":"text","text":"a"},{"type":"text","text":"b"}]},
                         {"role":"assistant","content":"c"}]}"#;
@@ -930,8 +1074,49 @@ mod tests {
         assert_eq!(req.system.as_deref(), Some("sys"));
         assert_eq!(req.max_tokens, 50);
         assert_eq!(req.messages.len(), 2);
-        assert_eq!(req.messages[0].content, "a\nb");
-        assert_eq!(req.messages[1].content, "c");
+        // I2: the block array is carried verbatim, not flattened away...
+        assert_eq!(
+            req.messages[0].content,
+            serde_json::json!([{"type":"text","text":"a"},{"type":"text","text":"b"}])
+        );
+        // ...and a plain string stays a plain string (I1: byte-identical on the wire).
+        assert_eq!(req.messages[1].content, Value::String("c".to_owned()));
+        // Gates see the same text they always did.
+        assert_eq!(req.messages[0].text_view(), "a\nb");
+        assert_eq!(req.messages[1].text_view(), "c");
+    }
+
+    #[test]
+    fn tool_and_image_blocks_survive_the_request_round_trip() {
+        // ADR 0005 I2: tool_use / tool_result / image blocks are never dropped on the request side.
+        let body = br#"{"model":"m","max_tokens":50,"messages":[
+            {"role":"assistant","content":[{"type":"tool_use","id":"t1","name":"calc","input":{"x":1}}]},
+            {"role":"user","content":[
+                {"type":"tool_result","tool_use_id":"t1","content":"2"},
+                {"type":"image","source":{"type":"base64","media_type":"image/png","data":"AA=="}}
+            ]}]}"#;
+        let req = parse_model_request(body).unwrap();
+        let round_tripped = serde_json::to_value(&req.messages).unwrap();
+        assert_eq!(
+            round_tripped,
+            serde_json::json!([
+                {"role":"assistant","content":[{"type":"tool_use","id":"t1","name":"calc","input":{"x":1}}]},
+                {"role":"user","content":[
+                    {"type":"tool_result","tool_use_id":"t1","content":"2"},
+                    {"type":"image","source":{"type":"base64","media_type":"image/png","data":"AA=="}}
+                ]}
+            ])
+        );
+    }
+
+    #[test]
+    fn text_message_serializes_byte_identical_to_a_plain_string() {
+        // I1: a string-content message must not gain array wrapping on the wire.
+        let m = ChatMessage::text("user", "hello");
+        assert_eq!(
+            serde_json::to_string(&m).unwrap(),
+            r#"{"role":"user","content":"hello"}"#
+        );
     }
 
     #[test]
@@ -1003,6 +1188,7 @@ mod tests {
             providers,
             gate_health: Arc::new(GateHealthRegistry::new()),
             traces,
+            adaptive: None,
         };
         (state, rx)
     }
@@ -1102,6 +1288,7 @@ mod tests {
             providers: ProviderRegistry::new("http://127.0.0.1:1", "http://127.0.0.1:1"),
             gate_health: Arc::new(GateHealthRegistry::new()),
             traces,
+            adaptive: None,
         };
         let resp = messages(State(state), HeaderMap::new(), user_body()).await;
         // Observe path forwards upstream; the bogus host yields a gateway error, not our 200.
@@ -1134,8 +1321,72 @@ mod tests {
         );
         let f_plain = extract_features(&HeaderMap::new(), &plain);
         let f_tools = extract_features(&HeaderMap::new(), &tools);
-        assert!(enforce_can_handle(&f_plain, &plain));
-        assert!(!enforce_can_handle(&f_tools, &tools));
+        // Default (enforce_structured = false): plain text routes, tools fall back to observe.
+        assert!(enforce_can_handle(&f_plain, &plain, false));
+        assert!(!enforce_can_handle(&f_tools, &tools, false));
+    }
+
+    #[test]
+    fn structured_enforce_routes_tools_and_streaming() {
+        // ADR 0005 P2+P3: with the opt-in flag on, tool and streaming requests both route through
+        // enforce (streaming is served as the gated result re-emitted as SSE).
+        let tools = Bytes::from_static(
+            br#"{"model":"m","tools":[{"name":"t"}],"messages":[{"role":"user","content":"hi"}]}"#,
+        );
+        let streaming_tools = Bytes::from_static(
+            br#"{"model":"m","stream":true,"tools":[{"name":"t"}],"messages":[{"role":"user","content":"hi"}]}"#,
+        );
+        let f = extract_features(&HeaderMap::new(), &tools);
+        assert!(enforce_can_handle(&f, &tools, true));
+        assert!(enforce_can_handle(&f, &streaming_tools, true));
+    }
+
+    #[test]
+    fn enforce_sse_reemission_preserves_text_and_tool_use() {
+        // ADR 0005 P3 + I2: a served response with a text block AND a tool_use block round-trips
+        // through the SSE re-emitter — the tool call's input survives as an input_json_delta.
+        let resp = ModelResponse {
+            model: "anthropic/claude-haiku-4-5".to_owned(),
+            text: "let me check".to_owned(),
+            in_tokens: 5,
+            out_tokens: 7,
+            raw: serde_json::json!({
+                "content": [
+                    { "type": "text", "text": "let me check" },
+                    { "type": "tool_use", "id": "tu_1", "name": "get_weather", "input": { "city": "Paris" } }
+                ]
+            }),
+        };
+        let sse = anthropic_sse_from_message(&anthropic_response_json(&resp));
+
+        // Parse every data frame structurally (key order is not part of the contract).
+        let frames: Vec<Value> = sse
+            .lines()
+            .filter_map(|l| l.strip_prefix("data: "))
+            .map(|d| serde_json::from_str::<Value>(d).expect("each SSE data frame is valid JSON"))
+            .collect();
+
+        // Full lifecycle, in order.
+        assert_eq!(frames.first().unwrap()["type"], "message_start");
+        assert_eq!(frames.last().unwrap()["type"], "message_stop");
+        // The text block streams its text as a text_delta.
+        assert!(frames.iter().any(|f| f["delta"]["type"] == "text_delta"
+            && f["delta"]["text"] == "let me check"));
+        // The tool_use block is present with its id/name, and its input streams as one JSON delta —
+        // not dropped (ADR 0005 I2).
+        assert!(
+            frames
+                .iter()
+                .any(|f| f["content_block"]["type"] == "tool_use"
+                    && f["content_block"]["name"] == "get_weather"
+                    && f["content_block"]["id"] == "tu_1")
+        );
+        assert!(
+            frames
+                .iter()
+                .any(|f| f["delta"]["type"] == "input_json_delta"
+                    && f["delta"]["partial_json"] == r#"{"city":"Paris"}"#)
+        );
     }
 
     /// B2: an enforce route serves plain text (200 from the mock) but falls back to transparent
@@ -1168,6 +1419,7 @@ mod tests {
             providers: ProviderRegistry::from_map(map),
             gate_health: Arc::new(GateHealthRegistry::new()),
             traces,
+            adaptive: None,
         };
 
         // Plain text enforces: the mock serves 200.
@@ -1245,10 +1497,43 @@ mod tests {
             providers: ProviderRegistry::new("http://127.0.0.1:1", "http://127.0.0.1:1"),
             gate_health: Arc::new(GateHealthRegistry::new()),
             traces,
+            adaptive: None,
         };
         (state, db, trace_id)
     }
 
+    #[tokio::test]
+    async fn feedback_nudges_the_adaptive_threshold() {
+        use firstpass_core::conformal::AdaptiveConformal;
+        let (mut state, _db, trace_id) = feedback_state().await;
+        let aci = Arc::new(std::sync::Mutex::new(AdaptiveConformal::new(0.1, 0.2, 0.5)));
+        state.adaptive = Some(aci.clone());
+        let before = aci.lock().unwrap().threshold();
+
+        // A served FAILURE raises the threshold (serve more conservatively).
+        let fail = Bytes::from(
+            serde_json::json!({ "trace_id": trace_id, "gate_id": "tests", "verdict": "fail", "reporter": "ci" })
+                .to_string(),
+        );
+        assert_eq!(
+            feedback(State(state.clone()), fail).await.status(),
+            axum::http::StatusCode::ACCEPTED
+        );
+        let after_fail = aci.lock().unwrap().threshold();
+        assert!(
+            after_fail > before,
+            "served fail should raise the live threshold: {before} -> {after_fail}"
+        );
+
+        // A served PASS nudges it back down — the loop is reactive both ways.
+        let pass = Bytes::from(
+            serde_json::json!({ "trace_id": trace_id, "gate_id": "tests", "verdict": "pass", "reporter": "ci" })
+                .to_string(),
+        );
+        let _ = feedback(State(state), pass).await;
+        assert!(aci.lock().unwrap().threshold() < after_fail);
+    }
+
     #[tokio::test]
     async fn feedback_records_a_deferred_verdict_without_breaking_the_chain() {
         let (state, db, trace_id) = feedback_state().await;

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-proxy/src/run.rs

@@ -45,8 +45,35 @@ pub fn build_gate_health(config: &ProxyConfig) -> GateHealthRegistry {
 pub async fn serve(config: ProxyConfig) -> Result<(), Box<dyn std::error::Error>> {
     let (traces, writer) = store::open(&config.db_path)?;
     let bind = config.bind.clone();
-    let providers = ProviderRegistry::new(&config.upstream_anthropic, &config.upstream_openai);
+    // Build the provider registry from any `[[provider]]` entries in the routing config (Groq,
+    // Together, Ollama, …), on top of the built-in anthropic/openai defaults. No config => defaults.
+    let provider_defs = config
+        .routing
+        .as_ref()
+        .map(|r| r.providers.as_slice())
+        .unwrap_or_default();
+    let providers = ProviderRegistry::from_config(
+        provider_defs,
+        &config.upstream_anthropic,
+        &config.upstream_openai,
+    );
     let gate_health = build_gate_health(&config);
+    // Online adaptive conformal (opt-in): seed the live threshold from the fixed one (or 0.5) and
+    // let /v1/feedback track it. Absent config => None => fixed-threshold behavior, byte-identical.
+    let adaptive = config
+        .routing
+        .as_ref()
+        .and_then(|r| r.escalation.adaptive.as_ref())
+        .map(|a| {
+            let init = config
+                .routing
+                .as_ref()
+                .and_then(|r| r.escalation.serve_threshold)
+                .unwrap_or(0.5);
+            Arc::new(std::sync::Mutex::new(
+                firstpass_core::conformal::AdaptiveConformal::new(a.alpha, a.gamma, init),
+            ))
+        });
 
     let state = AppState {
         config: Arc::new(config),
@@ -59,6 +86,7 @@ pub async fn serve(config: ProxyConfig) -> Result<(), Box<dyn std::error::Error>
         providers,
         gate_health: Arc::new(gate_health),
         traces,
+        adaptive,
     };
 
     let listener = tokio::net::TcpListener::bind(&bind).await?;

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-proxy/tests/end_to_end.rs

@@ -116,6 +116,7 @@ async fn spawn_proxy(upstream: &str, ladder: &[&str]) -> (String, std::path::Pat
         providers,
         gate_health: Arc::new(firstpass_proxy::gate::GateHealthRegistry::new()),
         traces,
+        adaptive: None,
     };
 
     let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

{firstpass-0.1.2 → firstpass-0.1.4}/crates/firstpass-proxy/tests/observe_loop.rs

@@ -57,6 +57,7 @@ async fn spawn_proxy(upstream: &str) -> (String, std::path::PathBuf) {
         providers,
         gate_health: Arc::new(firstpass_proxy::gate::GateHealthRegistry::new()),
         traces,
+        adaptive: None,
     };
 
     let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();