Give the coder runtime real tiers, a local lane, metering, and revocation

Diff

3 files changed, +2043 -144

                    print!("{}", chunk);
                    use std::io::Write;
                    let _ = std::io::stdout().flush();
                }).await.map_err(|e| e.to_string())?;
                }).await.map_err(|e| e.to_string());
                // The thread is revoked whether the turn worked or not: a
                // failed turn still opened one, and one left open holds its
                // grant's remaining budget.
                let revoked = runtime.close().await;
                // A turn that could not reach a model is a failure, and says
                // so in the shape every other refusal here uses.
                let result = match result {
                    Ok(result) => result,
                    Err(error) => fail(&error),
                };
                println!("\n\nTurn result:\n{}", result);
                if let Some(model) = &runtime.last_model {
                    println!("Model: {model}");
                }
                if runtime.last_usage.reported() {
                    println!("Usage: {}", runtime.last_usage.line());
                }
                if let Err(error) = revoked {
                    eprintln!("oa: the thread was not revoked: {error}");
                }
            } else {
                crate::interactive::run_tui(coder, token).await?;
            }

1		-	`//! Live OpenAgents inference proxy client & streaming multi-turn loop`
2		-	`//! Replicates coder-thread.ts behavior over POST /api/v1/threads and POST /api/inference/proxy`
	1	+	`//! The coder execution layer: tiers, threads, grants, and the streaming turn.`
	2	+	`//!`
	3	+	`//! Two lanes reach a model, and they share nothing but this file's message`
	4	+	`//! list:`
	5	+	`//!`
	6	+	//! - The thread lane opens `POST /api/v1/threads`, takes the grant that
	7	+	//! comes back, and streams `POST /api/inference/proxy` with the grant's
	8	+	//! bearer token. The thread is revoked with `DELETE /api/v1/threads/{id}`.
	9	+	`//! - The local lane talks to an Ollama server on this machine and never`
	10	+	`//! touches openagents.com at all, so it answers with the proxy unreachable.`
	11	+	`//!`
	12	+	`//! ## A turn that cannot reach a model fails`
	13	+	`//!`
	14	+	//! Every path out of [`CoderRuntimeSession::execute_turn`] is either the
	15	+	//! model's own words or an `Err`. There is no fallback model, no synthesized
	16	+	`//! reply, and no invented grant. Two of those existed here and both reached`
	17	+	//! readers: `create_thread` answered a refusal by returning a grant it made up
	18	+	`//! with the caller's own PAT inside it, and the proxy arm answered a rejected`
	19	+	//! request with the sentence `Completed autonomous reasoning turn (offline
	20	+	//! fallback).` and exit 0. Neither comes back.
	21	+	`//!`
	22	+	`//! ## Model ids are the server's, not this file's`
	23	+	`//!`
	24	+	//! The deployment publishes its catalog at `GET /api/v1/models` and refuses
	25	+	`//! anything outside it. A previous version of this file carried five model ids`
	26	+	//! it had invented — `gemini-3.7-pro`, `claude-3-7-sonnet`, `codex-preview`
	27	+	//! among them — and sent them as the thread's `lane`, which the server also
	28	+	`//! refuses. The tier table below maps the names a reader types onto ids the`
	29	+	`//! catalog actually served when it was written, and a name outside that table`
	30	+	`//! is checked against the live catalog before a thread is opened rather than`
	31	+	`//! guessed at.`
3	32
4	33		`use crate::tools::{HarnessToolRegistry, ToolCall, ToolDefinition};`
5	34		`use eventsource_stream::Eventsource;`

use serde::{Deserialize, Serialize};
use std::time::Duration;

type Failure = Box<dyn std::error::Error + Send + Sync>;

pub const THREAD_LANE_NOTICE: &str =
    "You answer through the OpenAgents inference proxy, on a thread opened for this session. \
    Every round of tool calls re-sends the whole conversation to a metered model, so batch \
    independent commands into one call and keep large dumps out of the transcript.";

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum Lane {
    OxAlpha,
    GeminiFlash,
    GeminiPro,
    ClaudeCode,
    Codex,
    Ollama(String),
pub const LOCAL_LANE_NOTICE: &str =
    "You answer from a model running on this machine through Ollama. Nothing in this \
    conversation leaves the machine and nothing is metered, but the context window is a \
    fraction of a hosted model's, so keep large dumps out of the transcript.";

/// Where an Ollama server listens unless `OPENAGENTS_OLLAMA_HOST` says otherwise.
pub const OLLAMA_HOST: &str = "http://127.0.0.1:11434";

/// How many rounds of tool calls one turn may take before it has to answer.
///
/// A backstop against a model that loops, not a budget.
const MAX_TOOL_STEPS: usize = 30;

/// The tier names a reader may type, and the catalog id each one opens on.
///
/// A tier is the unit `--lane` deals in: `flash` is the fast lane whatever
/// model is behind it this month, so renaming a vendor model is a one-line
/// change here and nothing else in the crate holds a vendor string. The ids on
/// the right were served by `GET /api/v1/models` when this was written; the
/// server is the authority and refuses any that stop being true.
pub const TIERS: &[(&str, &str)] = &[
    ("flash", "gemini-3.7-flash"),
    ("pro", "gpt-5.6-luna"),
    ("ox-alpha", "ox-alpha"),
];

/// What `--lane` takes, for a refusal that leaves the reader somewhere to go.
pub fn admitted_lanes() -> String {
    let tiers = TIERS
        .iter()
        .map(|(name, id)| format!("{name} ({id})"))
        .collect::<Vec<_>>()
        .join(", ");
    format!(
        "auto (the deployment's own default), {tiers}, \
         local or ollama:<model> for a model on this machine"
    )
}

impl Default for Lane {
    fn default() -> Self {
        Lane::OxAlpha
    }
/// Which lane a turn runs on.
///
/// [`Lane::from_str`] is total on purpose: an unrecognised name becomes
/// [`Lane::Named`] and is checked against the live catalog at the top of the
/// turn, so `--lane bogus` is refused by name with the list of what this
/// deployment serves. It used to fall through to `_ => Lane::OxAlpha`, which
/// ran the default lane while the reader believed they had chosen another.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
pub enum Lane {
    /// No model named at thread open. The deployment's own default answers.
    Auto,
    /// The `ox-alpha` tier.
    #[default]
    OxAlpha,
    /// The fast tier.
    Flash,
    /// The strong tier.
    Pro,
    /// A model id named directly, checked against `GET /api/v1/models`.
    Named(String),
    /// Ollama on this machine. An empty string means "whatever is installed".
    Local(String),
}

impl Lane {
    /// Named `from_str` rather than `FromStr::from_str` because it cannot
    /// fail: a name nothing admits is carried to the turn, where the catalog
    /// settles it and the refusal can name what this deployment serves.
    #[allow(clippy::should_implement_trait)]
    pub fn from_str(s: &str) -> Self {
        match s.to_lowercase().as_str() {
            "ox-alpha" | "ox" => Lane::OxAlpha,
            "gemini" | "gemini-flash" => Lane::GeminiFlash,
            "gemini-pro" => Lane::GeminiPro,
            "claude" => Lane::ClaudeCode,
            "codex" => Lane::Codex,
        match s.trim().to_lowercase().as_str() {
            "" | "auto" => Lane::Auto,
            "ox-alpha" | "ox" | "openagents" => Lane::OxAlpha,
            "flash" | "coder-flash" | "gemini" | "gemini-flash" | "gemini-3.7-flash" => Lane::Flash,
            "pro" | "coder-pro" | "gpt-5.6-luna" | "luna" => Lane::Pro,
            "local" | "ollama" => Lane::Local(String::new()),
            other if other.starts_with("ollama:") => {
                Lane::Ollama(other.trim_start_matches("ollama:").to_string())
                Lane::Local(other.trim_start_matches("ollama:").trim().to_string())
            }
            _ => Lane::OxAlpha,
            other => Lane::Named(other.to_string()),
        }
    }

    /// The catalog id to send at thread open, or `None` to let the server pick.
    pub fn model_id(&self) -> Option<&str> {
        match self {
            Lane::Auto => None,
            Lane::OxAlpha => Some("ox-alpha"),
            Lane::Flash => Some(TIERS[0].1),
            Lane::Pro => Some(TIERS[1].1),
            Lane::Named(id) => Some(id.as_str()),
            // The local lane names its model to Ollama, never to the server.
            Lane::Local(_) => None,
        }
    }

    /// Whether this lane answers from this machine.
    pub fn is_local(&self) -> bool {
        matches!(self, Lane::Local(_))
    }

    /// The tier this lane belongs to: `auto`, `flash`, `pro`, or `local`.
    ///
    /// A model id no tier pins has no tier, which is a different answer from
    /// "auto" and is worth keeping separate — a reader who named a model
    /// directly did not ask for a tier.
    pub fn tier(&self) -> Option<&'static str> {
        match self {
            Lane::Auto => Some("auto"),
            Lane::Flash => Some("flash"),
            Lane::Pro => Some("pro"),
            Lane::Local(_) => Some("local"),
            Lane::OxAlpha | Lane::Named(_) => None,
        }
    }

    pub fn model_name(&self) -> &str {
    /// The name for this lane on a status line.
    pub fn label(&self) -> String {
        match self {
            Lane::OxAlpha => "ox-alpha",
            Lane::GeminiFlash => "gemini-3.7-flash",
            Lane::GeminiPro => "gemini-3.7-pro",
            Lane::ClaudeCode => "claude-3-7-sonnet",
            Lane::Codex => "codex-preview",
            Lane::Ollama(m) => m.as_str(),
            Lane::Auto => "Coder Auto".to_string(),
            Lane::Flash => "Coder Flash".to_string(),
            Lane::Pro => "Coder Pro".to_string(),
            Lane::Local(model) if model.is_empty() => "Coder Local".to_string(),
            Lane::Local(model) => format!("Coder Local ({model})"),
            Lane::OxAlpha => "Coder (ox-alpha)".to_string(),
            Lane::Named(id) => format!("Coder ({id})"),
        }
    }
}

66	183		`format!("{head}…")`
67	184		`}`
68	185
	186	+	/// One model as `GET /api/v1/models` publishes it.
	187	+	`#[derive(Debug, Clone, PartialEq, Eq)]`
	188	+	`pub struct ServedModel {`
	189	+	`pub id: String,`
	190	+	`/// Served here and its provider credential configured.`
	191	+	`pub available: bool,`
	192	+	`pub default: bool,`
	193	+	`}`
	194	+
	195	+	`/// What one turn spent, as the server reported it.`
	196	+	`///`
	197	+	`/// Reported rather than estimated. The proxy sends a final chunk carrying`
	198	+	/// `usage` and Ollama sends its counts on the `done` line; both land here, and
	199	+	`/// a lane that reports nothing leaves this zero rather than guessing.`
	200	+	`#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]`
	201	+	`pub struct TurnUsage {`
	202	+	`pub prompt_tokens: u64,`
	203	+	`pub completion_tokens: u64,`
	204	+	`pub total_tokens: u64,`
	205	+	`}`
	206	+
	207	+	`impl TurnUsage {`
	208	+	`fn add(&mut self, other: TurnUsage) {`
	209	+	`self.prompt_tokens += other.prompt_tokens;`
	210	+	`self.completion_tokens += other.completion_tokens;`
	211	+	`self.total_tokens += other.total_tokens;`
	212	+	`}`
	213	+
	214	+	`pub fn reported(&self) -> bool {`
	215	+	`self.total_tokens > 0 \|\| self.prompt_tokens > 0 \|\| self.completion_tokens > 0`
	216	+	`}`
	217	+
	218	+	`/// One line for a transcript or a status bar.`
	219	+	`pub fn line(&self) -> String {`
	220	+	`format!(`
	221	+	`"{} prompt + {} completion = {} tokens",`
	222	+	`self.prompt_tokens, self.completion_tokens, self.total_tokens`
	223	+	`)`
	224	+	`}`
	225	+	`}`
	226	+
	227	+	`/// A grant the server issued. Never constructed from anything else.`
69	228		`#[derive(Debug, Clone, Serialize, Deserialize)]`
70	229		`pub struct InferenceGrant {`
71	230		`pub thread_id: String,`


pub struct CoderRuntimeSession {
    pub lane: Lane,
    /// The grant the last turn opened, so a caller can report the model that
    /// actually answered rather than the one it would have asked for.
    /// The grant this session opened, reused across its turns.
    ///
    /// `None` on the local lane, always: there is no grant to hold, and
    /// putting a made-up one here is the bug this file exists to keep dead.
    pub last_grant: Option<InferenceGrant>,
    /// The model that actually answered the last turn.
    ///
    /// From the grant on the thread lane, and from the resolved Ollama name on
    /// the local lane. A caller reporting what answered should read this
    /// rather than the lane, which is only what was asked for.
    pub last_model: Option<String>,
    /// What the last turn spent, summed over its steps.
    pub last_usage: TurnUsage,
    /// The reasoning the last turn emitted, if the model emits any.
    ///
    /// Kept off the content callback deliberately: `delta.reasoning` and
    /// `delta.content` interleave on the wire, and appending both to the
    /// transcript would put the model's scratch work in the middle of its
    /// answer. It is parsed, summed and kept here so a caller that wants to
    /// show it can, and the transcript stays the answer.
    pub last_reasoning: String,
    pub api_base: String,
    pub user_token: Option<String>,
    pub ollama_host: String,
    pub http: reqwest::Client,
    pub tools: HarnessToolRegistry,
    pub messages: Vec<ChatMessage>,
    /// The thread to revoke when the session closes.
    thread_id: Option<String>,
}

impl CoderRuntimeSession {
    pub fn new(lane: Lane, api_base: Option<String>, user_token: Option<String>, tools: HarnessToolRegistry) -> Self {
    pub fn new(
        lane: Lane,
        api_base: Option<String>,
        user_token: Option<String>,
        tools: HarnessToolRegistry,
    ) -> Self {
        Self {
            lane,
            last_grant: None,
            last_model: None,
            last_usage: TurnUsage::default(),
            last_reasoning: String::new(),
            // `OPENAGENTS_API_BASE` points the session at another host. A test
            // that has to prove the streaming path end to end needs somewhere
            // to point it that is not production, and an operator on staging
            // needs the same switch.
            api_base: api_base
                .or_else(|| std::env::var("OPENAGENTS_API_BASE").ok().filter(|v| !v.trim().is_empty()))
                .or_else(|| {
                    std::env::var("OPENAGENTS_API_BASE")
                        .ok()
                        .filter(|v| !v.trim().is_empty())
                })
                .unwrap_or_else(|| "https://openagents.com/api/v1".to_string()),
            user_token,
            ollama_host: std::env::var("OPENAGENTS_OLLAMA_HOST")
                .ok()
                .filter(|v| !v.trim().is_empty())
                .unwrap_or_else(|| OLLAMA_HOST.to_string()),
            http: reqwest::Client::builder()
                .timeout(Duration::from_secs(300))
                .build()
                .unwrap_or_default(),
            tools,
            messages: Vec::new(),
            thread_id: None,
        }
    }

    pub fn build_system_prompt(&self, tool_defs: &[ToolDefinition]) -> String {
        let notice = if self.lane.is_local() {
            LOCAL_LANE_NOTICE
        } else {
            THREAD_LANE_NOTICE
        };
        let mut lines = vec![
            format!("You are `openagents coder`, a coding assistant in a terminal. {}", THREAD_LANE_NOTICE),
            format!("You are `openagents coder`, a coding assistant in a terminal. {notice}"),
            "".to_string(),
            "Answer very concisely unless the reader asks for a longer response.".to_string(),
            "".to_string(),

                say plainly when something would need a tool you do not have.".to_string()
            );
        } else {
            lines.push(format!("You have {} tools, and no others:", tool_defs.len()));
            lines.push(format!(
                "You have {} tools, and no others:",
                tool_defs.len()
            ));
            for t in tool_defs {
                lines.push(format!("- `{}`", t.name));
            }

150	355		`lines.join("\n")`
151	356		`}`
152	357
153		-	`pub async fn create_thread(&self) -> Result<InferenceGrant, Box<dyn std::error::Error + Send + Sync>> {`
	358	+	`// ───────────────────────────────────────────────────────── the catalog`
	359	+
	360	+	`/// What this deployment serves, read from the server rather than assumed.`
	361	+	`pub async fn served_models(&self) -> Result<Vec<ServedModel>, Failure> {`
	362	+	`let url = format!("{}/models", self.api_base);`
	363	+	`let mut request = self.http.get(&url).timeout(Duration::from_secs(15));`
	364	+	`if let Some(token) = &self.user_token {`
	365	+	`request = request.bearer_auth(token);`
	366	+	`}`
	367	+	`let resp = request.send().await.map_err(\|error\| -> Failure {`
	368	+	`format!("{url} could not be reached: {error}").into()`
	369	+	`})?;`
	370	+	`if !resp.status().is_success() {`
	371	+	`let status = resp.status();`
	372	+	`let body = resp.text().await.unwrap_or_default();`
	373	+	`return Err(format!(`
	374	+	`"{url} refused the catalog request: {status} {}",`
	375	+	`snippet(&body)`
	376	+	`)`
	377	+	`.into());`
	378	+	`}`
	379	+	`let body: serde_json::Value = resp.json().await?;`
	380	+	`let models = body`
	381	+	`.get("models")`
	382	+	`.and_then(\|v\| v.as_array())`
	383	+	`.ok_or_else(\|\| -> Failure { format!("{url} published no model list").into() })?;`
	384	+	`Ok(models`
	385	+	`.iter()`
	386	+	`.filter_map(\|model\| {`
	387	+	`let id = model.get("id").and_then(\|v\| v.as_str())?;`
	388	+	`Some(ServedModel {`
	389	+	`id: id.to_string(),`
	390	+	// Any word other than `available` is read as unavailable: a
	391	+	`// vocabulary this client has not seen is a reason to pick`
	392	+	`// another model, not to assume the new word is benign.`
	393	+	`available: model.get("availability").and_then(\|v\| v.as_str())`
	394	+	`== Some("available"),`
	395	+	`default: model.get("default").and_then(\|v\| v.as_bool()) == Some(true),`
	396	+	`})`
	397	+	`})`
	398	+	`.collect())`
	399	+	`}`
	400	+
	401	+	`/// Refuse a directly-named model the catalog cannot answer with.`
	402	+	`///`
	403	+	`/// The tiers skip this: they are checked at open, and the server's own 422`
	404	+	`/// carries the news if one is retired. Only a name this crate does not`
	405	+	/// recognise pays for the round trip, and it pays it so that `--lane
	406	+	/// bogus` earns a sentence naming what it could have said instead.
	407	+	`async fn check_named(&self, id: &str) -> Result<(), Failure> {`
	408	+	`let served = match self.served_models().await {`
	409	+	`Ok(served) => served,`
	410	+	`Err(error) => {`
	411	+	`return Err(format!(`
	412	+	`"'{id}' is not a lane this CLI knows, and the catalog that would settle it \`
	413	+	`could not be read: {error}. Lanes: {}.",`
	414	+	`admitted_lanes()`
	415	+	`)`
	416	+	`.into())`
	417	+	`}`
	418	+	`};`
	419	+	`let usable: Vec<&str> = served`
	420	+	`.iter()`
	421	+	`.filter(\|m\| m.available)`
	422	+	`.map(\|m\| m.id.as_str())`
	423	+	`.collect();`
	424	+	`let alternatives = if usable.is_empty() {`
	425	+	`"This deployment has no model with a configured provider credential.".to_string()`
	426	+	`} else {`
	427	+	`format!("This deployment serves {}.", usable.join(", "))`
	428	+	`};`
	429	+
	430	+	`match served.iter().find(\|m\| m.id == id) {`
	431	+	`None => Err(format!(`
	432	+	`"'{id}' is not a lane this CLI knows and no model of that name is served here. \`
	433	+	`{alternatives} Lanes: {}.",`
	434	+	`admitted_lanes()`
	435	+	`)`
	436	+	`.into()),`
	437	+	`Some(model) if !model.available => Err(format!(`
	438	+	`"'{id}' is in the catalog but its provider is not configured on this deployment. \`
	439	+	`{alternatives}"`
	440	+	`)`
	441	+	`.into()),`
	442	+	`Some(_) => Ok(()),`
	443	+	`}`
	444	+	`}`
	445	+
	446	+	`// ────────────────────────────────────────────────── threads and grants`
	447	+
	448	+	`pub async fn create_thread(&self) -> Result<InferenceGrant, Failure> {`
154	449		`let url = format!("{}/threads", self.api_base);`
155	450		`let mut headers = HeaderMap::new();`
156	451		`headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));`
157	452		`if let Some(tok) = &self.user_token {`
158		-	`headers.insert(AUTHORIZATION, HeaderValue::from_str(&format!("Bearer {}", tok))?);`
	453	+	`headers.insert(`
	454	+	`AUTHORIZATION,`
	455	+	`HeaderValue::from_str(&format!("Bearer {tok}"))?,`
	456	+	`);`
	457	+	`}`
	458	+
	459	+	// `lane` is the thread's execution shape and the server admits only
	460	+	// `thread` and `local`; this path is the proxy, which is `thread`. It
	461	+	`// used to send a model name here and every request was refused with`
	462	+	// `"ox-alpha" is not an admitted lane` — invisibly, because the caller
	463	+	`// answered the refusal with a fabricated grant.`
	464	+	`//`
	465	+	// `model` is separate and optional. Omitting it opens on the
	466	+	// deployment's own default, which is what `Lane::Auto` wants; naming
	467	+	`// one pins the lane. Either way the grant that comes back is the`
	468	+	`// authority on which model answers, and that is what gets reported.`
	469	+	`let mut body = serde_json::json!({`
	470	+	`"objective": "Coding assistant session",`
	471	+	`"lane": "thread",`
	472	+	`});`
	473	+	`if let Some(model) = self.lane.model_id() {`
	474	+	`body["model"] = serde_json::json!(model);`
159	475		`}`
160	476
161		-	`let resp = self.http.post(&url)`
	477	+	`let resp = self`
	478	+	`.http`
	479	+	`.post(&url)`
162	480		`.headers(headers)`
163		-	// `lane` is the thread's execution shape, and the server admits
164		-	// only `thread` and `local` — this path is the proxy, which
165		-	// is `thread`. It used to send a model name here, and every
166		-	// request was refused with `"ox-alpha" is not an admitted lane`;
167		-	`// the refusal was invisible because the caller answered it with a`
168		-	`// fabricated grant. A model cannot be named at thread open at all:`
169		-	`// the endpoint publishes no model parameter and the grant the`
170		-	`// server returns pins the model that answers.`
171		-	`.json(&serde_json::json!({`
172		-	`"objective": "Coding assistant session",`
173		-	`"lane": "thread",`
174		-	`}))`
	481	+	`.json(&body)`
175	482		`.send()`
176	483		`.await?;`
177	484
178		-	`if resp.status().is_success() {`
179		-	`let body: serde_json::Value = resp.json().await?;`
180		-	`let thread = body.get("thread").cloned().unwrap_or(serde_json::json!({}));`
181		-	`let grant = body.get("grant").cloned().unwrap_or(serde_json::json!({}));`
182		-
183		-	`let thread_id = thread.get("id").and_then(\|v\| v.as_str()).unwrap_or("th_active").to_string();`
184		-	`let token = grant.get("token").and_then(\|v\| v.as_str()).unwrap_or("").to_string();`
185		-	`let grant_url = grant.get("url").and_then(\|v\| v.as_str()).unwrap_or("https://openagents.com/api/inference/proxy").to_string();`
186		-	`let model = grant.get("model").and_then(\|v\| v.as_str()).unwrap_or(self.lane.model_name()).to_string();`
187		-
188		-	`Ok(InferenceGrant {`
189		-	`thread_id,`
190		-	`token,`
191		-	`proxy_url: grant_url,`
192		-	`model,`
193		-	`})`
194		-	`} else {`
	485	+	`if !resp.status().is_success() {`
195	486		`// This used to invent a grant with a placeholder token and carry`
196	487		`// on, so a refused request reached the reader as a completed turn.`
197		-	`// Say what happened instead; the caller puts it on the transcript.`
	488	+	`let status = resp.status();`
	489	+	`let text = resp.text().await.unwrap_or_default();`
	490	+	`return Err(format!(`
	491	+	`"{url} refused the thread request: {status} {}",`
	492	+	`snippet(&text)`
	493	+	`)`
	494	+	`.into());`
	495	+	`}`
	496	+
	497	+	`let body: serde_json::Value = resp.json().await?;`
	498	+	`let thread = body.get("thread").cloned().unwrap_or(serde_json::json!({}));`
	499	+	`let grant = body.get("grant").cloned().unwrap_or(serde_json::json!({}));`
	500	+
	501	+	`let thread_id = thread`
	502	+	`.get("id")`
	503	+	`.and_then(\|v\| v.as_str())`
	504	+	`.ok_or_else(\|\| -> Failure {`
	505	+	`format!("{url} accepted the thread but published no id").into()`
	506	+	`})?`
	507	+	`.to_string();`
	508	+	`let token = grant`
	509	+	`.get("token")`
	510	+	`.and_then(\|v\| v.as_str())`
	511	+	`.filter(\|t\| !t.is_empty())`
	512	+	`.ok_or_else(\|\| -> Failure {`
	513	+	`format!(`
	514	+	`"{url} opened thread {thread_id} but minted no inference grant, \`
	515	+	`so there is no token to call the proxy with"`
	516	+	`)`
	517	+	`.into()`
	518	+	`})?`
	519	+	`.to_string();`
	520	+	`let proxy_url = grant`
	521	+	`.get("url")`
	522	+	`.and_then(\|v\| v.as_str())`
	523	+	`.ok_or_else(\|\| -> Failure {`
	524	+	`format!("the grant on thread {thread_id} names no proxy url").into()`
	525	+	`})?`
	526	+	`.to_string();`
	527	+	`let model = grant`
	528	+	`.get("model")`
	529	+	`.and_then(\|v\| v.as_str())`
	530	+	`.ok_or_else(\|\| -> Failure {`
	531	+	`format!("the grant on thread {thread_id} names no model").into()`
	532	+	`})?`
	533	+	`.to_string();`
	534	+
	535	+	`Ok(InferenceGrant {`
	536	+	`thread_id,`
	537	+	`token,`
	538	+	`proxy_url,`
	539	+	`model,`
	540	+	`})`
	541	+	`}`
	542	+
	543	+	`/// Revoke this session's thread.`
	544	+	`///`
	545	+	/// A thread left open holds its grant's remaining budget. `DELETE
	546	+	/// /api/v1/threads/{id}` closes both and returns the grant's spend, which
	547	+	`/// is why the reply is worth reading rather than discarding.`
	548	+	`pub async fn close(&mut self) -> Result<Option<TurnUsage>, Failure> {`
	549	+	`let Some(thread_id) = self.thread_id.take() else {`
	550	+	`return Ok(None);`
	551	+	`};`
	552	+	`self.last_grant = None;`
	553	+	`let url = format!("{}/threads/{thread_id}", self.api_base);`
	554	+	`let mut request = self.http.delete(&url).timeout(Duration::from_secs(30));`
	555	+	`if let Some(token) = &self.user_token {`
	556	+	`request = request.bearer_auth(token);`
	557	+	`}`
	558	+	`let resp = request.send().await.map_err(\|error\| -> Failure {`
	559	+	`format!("{url} could not be reached: {error}").into()`
	560	+	`})?;`
	561	+	`if !resp.status().is_success() {`
198	562		`let status = resp.status();`
199	563		`let body = resp.text().await.unwrap_or_default();`
200		-	`Err(format!("{} refused the thread request: {} {}", url, status, snippet(&body)).into())`
	564	+	`return Err(`
	565	+	`format!("{url} refused the revocation: {status} {}", snippet(&body)).into(),`
	566	+	`);`
201	567		`}`
	568	+	`let body: serde_json::Value = resp.json().await.unwrap_or(serde_json::json!({}));`
	569	+	`let spent = body.get("grant").and_then(\|g\| g.get("spent"));`
	570	+	`Ok(spent.map(\|spent\| TurnUsage {`
	571	+	`prompt_tokens: 0,`
	572	+	`completion_tokens: 0,`
	573	+	`total_tokens: spent`
	574	+	`.get("total_tokens")`
	575	+	`.and_then(\|v\| v.as_u64())`
	576	+	`.unwrap_or(0),`
	577	+	`}))`
202	578		`}`
203	579
204		-	`pub async fn execute_turn<F>(&mut self, prompt: &str, mut chunk_callback: F) -> Result<String, Box<dyn std::error::Error + Send + Sync>>`
	580	+	`// ─────────────────────────────────────────────────────────── the turn`
	581	+
	582	+	`pub async fn execute_turn<F>(`
	583	+	`&mut self,`
	584	+	`prompt: &str,`
	585	+	`chunk_callback: F,`
	586	+	`) -> Result<String, Failure>`
205	587		`where`
206	588		`F: FnMut(&str) + Send + 'static,`
207	589		`{`

            tool_call_id: None,
        });

        let grant = self.create_thread().await?;
        self.last_grant = Some(grant.clone());
        self.last_usage = TurnUsage::default();
        self.last_reasoning.clear();

        let mut max_steps = 30;
        let mut final_answer = String::new();
        if self.lane.is_local() {
            self.run_local_turn(&tool_defs, chunk_callback).await
        } else {
            self.run_thread_turn(&tool_defs, chunk_callback).await
        }
    }

        while max_steps > 0 {
            max_steps -= 1;
    async fn run_thread_turn<F>(
        &mut self,
        tool_defs: &[ToolDefinition],
        mut chunk_callback: F,
    ) -> Result<String, Failure>
    where
        F: FnMut(&str) + Send + 'static,
    {
        if let Lane::Named(id) = self.lane.clone() {
            self.check_named(&id).await?;
        }

        // One thread per session, reused across its turns. Opening a fresh one
        // per turn threw away the conversation's own budget and left a trail of
        // open threads nothing ever revoked.
        let grant = match &self.last_grant {
            Some(grant) => grant.clone(),
            None => {
                let grant = self.create_thread().await?;
                self.thread_id = Some(grant.thread_id.clone());
                self.last_grant = Some(grant.clone());
                grant
            }
        };
        self.last_model = Some(grant.model.clone());

        let mut final_answer = String::new();

        for _ in 0..MAX_TOOL_STEPS {
            let req_body = serde_json::json!({
                "model": grant.model,
                "messages": self.messages,


            let mut headers = HeaderMap::new();
            headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
            headers.insert(AUTHORIZATION, HeaderValue::from_str(&format!("Bearer {}", grant.token))?);
            headers.insert(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {}", grant.token))?,
            );

            let resp = self.http.post(&grant.proxy_url)
            let resp = self
                .http
                .post(&grant.proxy_url)
                .headers(headers)
                .json(&req_body)
                .send()

                    let status = r.status();
                    let body = r.text().await.unwrap_or_default();
                    return Err(format!(
                        "{} refused the turn: {} {}",
                        "{} refused the turn: {status} {}",
                        grant.proxy_url,
                        status,
                        snippet(&body)
                    )
                    .into());
                }
                Err(error) => {
                    return Err(
                        format!("{} could not be reached: {}", grant.proxy_url, error).into()
                    )
                    return Err(format!("{} could not be reached: {error}", grant.proxy_url).into())
                }
            };

            let mut stream = resp.bytes_stream().eventsource();
            let mut turn_content = String::new();
            let mut tool_calls_map: std::collections::BTreeMap<usize, (String, String, String)> = std::collections::BTreeMap::new();
            let mut step = StepAccumulator::default();

            while let Some(event) = stream.next().await {
                let event = match event {
                    Ok(ev) => ev,
                    Err(_) => break,
                    Ok(event) => event,
                    Err(error) => {
                        return Err(format!(
                            "the reply from {} stopped mid-stream: {error}",
                            grant.proxy_url
                        )
                        .into())
                    }
                };
                if event.data == "[DONE]" {
                    break;
                }
                if let Ok(json) = serde_json::from_str::<serde_json::Value>(&event.data) {
                    if let Some(choices) = json.get("choices").and_then(|v| v.as_array()) {
                        if let Some(choice) = choices.get(0) {
                            if let Some(delta) = choice.get("delta") {
                                if let Some(content) = delta.get("content").and_then(|v| v.as_str()) {
                                    chunk_callback(content);
                                    turn_content.push_str(content);
                                }
                                if let Some(t_calls) = delta.get("tool_calls").and_then(|v| v.as_array()) {
                                    for tc in t_calls {
                                        let index = tc.get("index").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
                                        let entry = tool_calls_map.entry(index).or_insert((String::new(), String::new(), String::new()));
                                        if let Some(id) = tc.get("id").and_then(|v| v.as_str()) {
                                            entry.0.push_str(id);
                                        }
                                        if let Some(f) = tc.get("function") {
                                            if let Some(name) = f.get("name").and_then(|v| v.as_str()) {
                                                entry.1.push_str(name);
                                            }
                                            if let Some(args) = f.get("arguments").and_then(|v| v.as_str()) {
                                                entry.2.push_str(args);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                let Ok(json) = serde_json::from_str::<serde_json::Value>(&event.data) else {
                    continue;
                };
                step.absorb_openai(&json, &mut chunk_callback);
            }

            if tool_calls_map.is_empty() {
                final_answer = turn_content;
            self.last_usage.add(step.usage);
            self.last_reasoning.push_str(&step.reasoning);

            if step.tool_calls.is_empty() {
                final_answer = step.content;
                break;
            }
            self.run_tools(step).await;
        }

            let mut recorded_tool_calls = Vec::new();
            for (_, (id, name, args_str)) in &tool_calls_map {
                recorded_tool_calls.push(serde_json::json!({
        Ok(final_answer)
    }

    /// Record the assistant's tool calls, run them, and put the results back.
    async fn run_tools(&mut self, step: StepAccumulator) {
        let recorded: Vec<serde_json::Value> = step
            .tool_calls
            .values()
            .map(|(id, name, args)| {
                serde_json::json!({
                    "id": id,
                    "type": "function",
                    "function": { "name": name, "arguments": args }
                })
            })
            .collect();

        self.messages.push(ChatMessage {
            role: "assistant".to_string(),
            content: if step.content.is_empty() {
                None
            } else {
                Some(step.content)
            },
            tool_calls: Some(recorded),
            tool_call_id: None,
        });

        for (id, name, args_str) in step.tool_calls.into_values() {
            let arguments: serde_json::Value =
                serde_json::from_str(&args_str).unwrap_or(serde_json::json!({}));
            let call = ToolCall {
                id: id.clone(),
                name: name.clone(),
                arguments,
            };
            let result = self.tools.execute_tool(&call).await;
            self.messages.push(ChatMessage {
                role: "tool".to_string(),
                content: Some(result.output),
                tool_calls: None,
                tool_call_id: Some(id),
            });
        }
    }

    // ────────────────────────────────────────────────────── the local lane

    /// The Ollama models installed here, most recently modified first.
    pub async fn installed_local_models(&self) -> Result<Vec<String>, Failure> {
        let url = format!("{}/api/tags", self.ollama_host.trim_end_matches('/'));
        let resp = self
            .http
            .get(&url)
            .timeout(Duration::from_secs(5))
            .send()
            .await
            .map_err(|error| -> Failure {
                format!(
                    "no Ollama server answered at {}: {error}. \
                     Start one, or choose a hosted lane.",
                    self.ollama_host
                )
                .into()
            })?;
        if !resp.status().is_success() {
            return Err(format!("{url} refused the model list: {}", resp.status()).into());
        }
        let body: serde_json::Value = resp.json().await?;
        let mut models: Vec<(String, String)> = body
            .get("models")
            .and_then(|v| v.as_array())
            .map(|models| {
                models
                    .iter()
                    .filter_map(|m| {
                        let name = m.get("name").and_then(|v| v.as_str())?;
                        let modified = m
                            .get("modified_at")
                            .and_then(|v| v.as_str())
                            .unwrap_or_default();
                        Some((name.to_string(), modified.to_string()))
                    })
                    .collect()
            })
            .unwrap_or_default();
        models.sort_by(|left, right| right.1.cmp(&left.1));
        Ok(models.into_iter().map(|(name, _)| name).collect())
    }

    /// The installed model a name means.
    ///
    /// Exact first, so a full name is never reinterpreted; then the family
    /// prefix, because a reader who pulled `qwen3.8:27b-mtp-q8_0` says
    /// `qwen3.8` and sending that unresolved earns `model not found` from a
    /// server that has the model. An empty name takes the most recently
    /// modified, which is the one they were last working with.
    async fn resolve_local_model(&self, wanted: &str) -> Result<String, Failure> {
        let installed = self.installed_local_models().await?;
        if installed.is_empty() {
            return Err(format!(
                "the Ollama server at {} has no models installed. \
                 Pull one with `ollama pull <model>`.",
                self.ollama_host
            )
            .into());
        }
        if wanted.is_empty() {
            return Ok(installed[0].clone());
        }
        if installed.iter().any(|m| m == wanted) {
            return Ok(wanted.to_string());
        }
        if let Some(family) = installed
            .iter()
            .find(|m| m.starts_with(&format!("{wanted}:")))
        {
            return Ok(family.clone());
        }
        Err(format!(
            "the Ollama server at {} does not have '{wanted}'. It has: {}.",
            self.ollama_host,
            installed.join(", ")
        )
        .into())
    }

    async fn run_local_turn<F>(
        &mut self,
        tool_defs: &[ToolDefinition],
        mut chunk_callback: F,
    ) -> Result<String, Failure>
    where
        F: FnMut(&str) + Send + 'static,
    {
        let Lane::Local(wanted) = self.lane.clone() else {
            return Err("run_local_turn was called off the local lane".into());
        };
        let model = self.resolve_local_model(&wanted).await?;
        self.last_model = Some(format!("ollama:{model}"));
        // No grant is minted here and none is invented: the model is on this
        // machine, so there is nothing for the server to authorise.
        self.last_grant = None;

        let url = format!("{}/api/chat", self.ollama_host.trim_end_matches('/'));
        let mut final_answer = String::new();

        for _ in 0..MAX_TOOL_STEPS {
            let req_body = serde_json::json!({
                "model": model,
                "messages": self.messages.iter().map(ollama_message).collect::<Vec<_>>(),
                "tools": tool_defs.iter().map(|t| serde_json::json!({
                    "type": "function",
                    "function": {
                        "name": name,
                        "arguments": args_str
                        "name": t.name,
                        "description": t.description,
                        "parameters": t.parameters
                    }
                })).collect::<Vec<_>>(),
                "stream": true
            });

            let resp = self.http.post(&url).json(&req_body).send().await;
            let resp = match resp {
                Ok(r) if r.status().is_success() => r,
                Ok(r) => {
                    let status = r.status();
                    let body = r.text().await.unwrap_or_default();
                    return Err(
                        format!("{url} refused the turn: {status} {}", snippet(&body)).into(),
                    );
                }
                Err(error) => return Err(format!("{url} could not be reached: {error}").into()),
            };

            // Ollama streams newline-delimited JSON rather than server-sent
            // events, so the frames are split here rather than by `Eventsource`.
            let mut bytes = resp.bytes_stream();
            let mut pending = String::new();
            let mut step = StepAccumulator::default();

            while let Some(chunk) = bytes.next().await {
                let chunk = chunk.map_err(|error| -> Failure {
                    format!("the reply from {url} stopped mid-stream: {error}").into()
                })?;
                pending.push_str(&String::from_utf8_lossy(&chunk));
                while let Some(newline) = pending.find('\n') {
                    let line: String = pending.drain(..=newline).collect();
                    let line = line.trim().to_string();
                    if line.is_empty() {
                        continue;
                    }
                    if let Ok(json) = serde_json::from_str::<serde_json::Value>(&line) {
                        step.absorb_ollama(&json, &mut chunk_callback);
                    }
                }));
                }
            }
            let tail = pending.trim();
            if !tail.is_empty() {
                if let Ok(json) = serde_json::from_str::<serde_json::Value>(tail) {
                    step.absorb_ollama(&json, &mut chunk_callback);
                }
            }

            self.messages.push(ChatMessage {
                role: "assistant".to_string(),
                content: if turn_content.is_empty() { None } else { Some(turn_content) },
                tool_calls: Some(recorded_tool_calls),
                tool_call_id: None,
            self.last_usage.add(step.usage);
            self.last_reasoning.push_str(&step.reasoning);

            if step.tool_calls.is_empty() {
                final_answer = step.content;
                break;
            }
            self.run_tools(step).await;
        }

        Ok(final_answer)
    }
}

/// A thread left open holds its grant's remaining budget, and the interactive
/// session has no place to await a revocation on its way out. This is the
/// backstop: best effort, on whatever runtime is still up. `close` is the path
/// that can be awaited and proven, and it clears the id so this does not fire
/// twice.
impl Drop for CoderRuntimeSession {
    fn drop(&mut self) {
        let Some(thread_id) = self.thread_id.take() else {
            return;
        };
        let Ok(handle) = tokio::runtime::Handle::try_current() else {
            return;
        };
        let url = format!("{}/threads/{thread_id}", self.api_base);
        let token = self.user_token.clone();
        let http = self.http.clone();
        handle.spawn(async move {
            let mut request = http.delete(&url).timeout(Duration::from_secs(10));
            if let Some(token) = token {
                request = request.bearer_auth(token);
            }
            let _ = request.send().await;
        });
    }
}

/// What one call to a model produced, before the caller decides what it means.
#[derive(Default)]
struct StepAccumulator {
    content: String,
    reasoning: String,
    usage: TurnUsage,
    /// Keyed by the wire's `index` so fragments land in call order.
    tool_calls: std::collections::BTreeMap<usize, (String, String, String)>,
}

impl StepAccumulator {
    /// One OpenAI-shaped streaming chunk.
    ///
    /// `content`, `reasoning` and `tool_calls` interleave inside one `delta`,
    /// and `usage` arrives on a chunk of its own with an empty `choices` array
    /// — which is why usage is read before the choices are.
    fn absorb_openai<F: FnMut(&str)>(&mut self, json: &serde_json::Value, on_chunk: &mut F) {
        if let Some(usage) = json.get("usage") {
            self.usage.add(TurnUsage {
                prompt_tokens: field(usage, "prompt_tokens"),
                completion_tokens: field(usage, "completion_tokens"),
                total_tokens: field(usage, "total_tokens"),
            });
        }

        let Some(delta) = json
            .get("choices")
            .and_then(|v| v.as_array())
            .and_then(|choices| choices.first())
            .and_then(|choice| choice.get("delta"))
        else {
            return;
        };

        if let Some(reasoning) = delta.get("reasoning").and_then(|v| v.as_str()) {
            self.reasoning.push_str(reasoning);
        }
        if let Some(content) = delta.get("content").and_then(|v| v.as_str()) {
            if !content.is_empty() {
                on_chunk(content);
                self.content.push_str(content);
            }
        }
        if let Some(calls) = delta.get("tool_calls").and_then(|v| v.as_array()) {
            for call in calls {
                let index = call.get("index").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
                let entry = self.tool_calls.entry(index).or_default();
                if let Some(id) = call.get("id").and_then(|v| v.as_str()) {
                    entry.0.push_str(id);
                }
                if let Some(function) = call.get("function") {
                    if let Some(name) = function.get("name").and_then(|v| v.as_str()) {
                        entry.1.push_str(name);
                    }
                    if let Some(args) = function.get("arguments").and_then(|v| v.as_str()) {
                        entry.2.push_str(args);
                    }
                }
            }
        }
    }

    /// One Ollama-shaped streaming line.
    ///
    /// The counts arrive on the `done` line, the model's scratch work under
    /// `thinking`, and a tool call whole rather than in fragments — with its
    /// arguments as an object, where the proxy sends a string.
    fn absorb_ollama<F: FnMut(&str)>(&mut self, json: &serde_json::Value, on_chunk: &mut F) {
        if json.get("done").and_then(|v| v.as_bool()) == Some(true) {
            self.usage.add(TurnUsage {
                prompt_tokens: field(json, "prompt_eval_count"),
                completion_tokens: field(json, "eval_count"),
                total_tokens: field(json, "prompt_eval_count") + field(json, "eval_count"),
            });
        }

            for (_, (id, name, args_str)) in tool_calls_map {
                let parsed_args: serde_json::Value = serde_json::from_str(&args_str).unwrap_or(serde_json::json!({}));
                let call = ToolCall {
                    id: id.clone(),
                    name: name.clone(),
                    arguments: parsed_args,
        let Some(message) = json.get("message") else {
            return;
        };
        if let Some(thinking) = message.get("thinking").and_then(|v| v.as_str()) {
            self.reasoning.push_str(thinking);
        }
        if let Some(content) = message.get("content").and_then(|v| v.as_str()) {
            if !content.is_empty() {
                on_chunk(content);
                self.content.push_str(content);
            }
        }
        if let Some(calls) = message.get("tool_calls").and_then(|v| v.as_array()) {
            for call in calls {
                let Some(function) = call.get("function") else {
                    continue;
                };
                let index = self.tool_calls.len();
                let name = function
                    .get("name")
                    .and_then(|v| v.as_str())
                    .unwrap_or_default()
                    .to_string();
                let arguments = match function.get("arguments") {
                    Some(serde_json::Value::String(raw)) => raw.clone(),
                    Some(value) => value.to_string(),
                    None => "{}".to_string(),
                };
                let result = self.tools.execute_tool(&call).await;
                self.messages.push(ChatMessage {
                    role: "tool".to_string(),
                    content: Some(result.output),
                    tool_calls: None,
                    tool_call_id: Some(id),
                });
                // Ollama mints no call id and the tool result has to name the
                // call it answers, so one is made from the position. This is a
                // local correlation key, not a server-issued identifier.
                self.tool_calls
                    .insert(index, (format!("local_{index}_{name}"), name, arguments));
            }
        }
    }
}

        Ok(final_answer)
fn field(value: &serde_json::Value, key: &str) -> u64 {
    value.get(key).and_then(|v| v.as_u64()).unwrap_or(0)
}

/// One message in the shape Ollama's chat API takes back.
///
/// The differences from the proxy's shape are small and all load-bearing:
/// `arguments` is an object rather than a string, and a tool result is named by
/// `tool_name` rather than by a call id Ollama never issued.
fn ollama_message(message: &ChatMessage) -> serde_json::Value {
    let mut out = serde_json::json!({
        "role": message.role,
        "content": message.content.clone().unwrap_or_default(),
    });
    if let Some(calls) = &message.tool_calls {
        out["tool_calls"] = serde_json::Value::Array(
            calls
                .iter()
                .map(|call| {
                    let function = call
                        .get("function")
                        .cloned()
                        .unwrap_or(serde_json::json!({}));
                    let name = function
                        .get("name")
                        .cloned()
                        .unwrap_or(serde_json::json!(""));
                    let arguments = match function.get("arguments") {
                        Some(serde_json::Value::String(raw)) => {
                            serde_json::from_str(raw).unwrap_or(serde_json::json!({}))
                        }
                        Some(value) => value.clone(),
                        None => serde_json::json!({}),
                    };
                    serde_json::json!({ "function": { "name": name, "arguments": arguments } })
                })
                .collect(),
        );
    }
    if message.role == "tool" {
        if let Some(id) = &message.tool_call_id {
            // `local_<index>_<name>` — the name is what Ollama matches on.
            let name = id.splitn(3, '_').nth(2).unwrap_or(id);
            out["tool_name"] = serde_json::json!(name);
        }
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn tier_names_map_onto_catalog_ids() {
        assert_eq!(Lane::from_str("flash").model_id(), Some("gemini-3.7-flash"));
        assert_eq!(Lane::from_str("pro").model_id(), Some("gpt-5.6-luna"));
        assert_eq!(Lane::from_str("ox-alpha").model_id(), Some("ox-alpha"));
        assert_eq!(Lane::from_str("auto").model_id(), None);
    }

    /// The invented ids are gone. Every id this file can send is one the
    /// deployment's catalog listed: `gemini-3.7-flash`, `ox-alpha`,
    /// `gpt-5.6-luna`. `gemini-3.7-pro`, `claude-3-7-sonnet` and
    /// `codex-preview` were never served by anything.
    #[test]
    fn no_lane_sends_a_model_id_that_was_made_up() {
        const SERVED: [&str; 3] = ["gemini-3.7-flash", "ox-alpha", "gpt-5.6-luna"];
        for (name, _) in TIERS {
            let lane = Lane::from_str(name);
            let id = lane.model_id().expect("a tier pins a model");
            assert!(
                SERVED.contains(&id),
                "tier '{name}' opens on '{id}', which the catalog did not list"
            );
        }
    }

    #[test]
    fn an_unknown_name_is_carried_as_named_rather_than_becoming_the_default() {
        assert_eq!(Lane::from_str("bogus"), Lane::Named("bogus".to_string()));
        assert_eq!(Lane::from_str("claude"), Lane::Named("claude".to_string()));
        assert_ne!(Lane::from_str("bogus"), Lane::OxAlpha);
    }

    #[test]
    fn the_local_lane_is_parsed_from_both_spellings() {
        assert_eq!(Lane::from_str("local"), Lane::Local(String::new()));
        assert_eq!(
            Lane::from_str("ollama:qwen3:0.6b"),
            Lane::Local("qwen3:0.6b".to_string())
        );
        assert!(Lane::from_str("ollama:qwen3:0.6b").is_local());
        assert!(!Lane::from_str("flash").is_local());
        // The local lane names no catalog model, because no grant carries it.
        assert_eq!(Lane::from_str("ollama:qwen3").model_id(), None);
    }

    #[test]
    fn every_tier_has_a_name_and_a_label() {
        assert_eq!(Lane::from_str("auto").tier(), Some("auto"));
        assert_eq!(Lane::from_str("flash").tier(), Some("flash"));
        assert_eq!(Lane::from_str("pro").tier(), Some("pro"));
        assert_eq!(Lane::from_str("local").tier(), Some("local"));
        assert_eq!(Lane::from_str("bogus").tier(), None);
        assert_eq!(Lane::from_str("flash").label(), "Coder Flash");
        assert_eq!(
            Lane::from_str("ollama:qwen3:0.6b").label(),
            "Coder Local (qwen3:0.6b)"
        );
    }

    #[test]
    fn the_admitted_lane_sentence_names_every_way_in() {
        let sentence = admitted_lanes();
        for fragment in ["auto", "flash", "pro", "ox-alpha", "ollama:<model>"] {
            assert!(
                sentence.contains(fragment),
                "'{fragment}' missing from: {sentence}"
            );
        }
    }

    #[test]
    fn usage_sums_across_the_steps_of_a_turn() {
        let mut usage = TurnUsage::default();
        assert!(!usage.reported());
        usage.add(TurnUsage {
            prompt_tokens: 99,
            completion_tokens: 17,
            total_tokens: 116,
        });
        usage.add(TurnUsage {
            prompt_tokens: 140,
            completion_tokens: 8,
            total_tokens: 148,
        });
        assert!(usage.reported());
        assert_eq!(usage.line(), "239 prompt + 25 completion = 264 tokens");
    }

    /// The exact frames a live `ox-alpha` turn sent, in order: reasoning
    /// first, then the answer, then usage on a chunk with no choices at all.
    #[test]
    fn a_real_proxy_stream_yields_the_answer_the_reasoning_and_the_counts() {
        let frames = [
            r#"{"choices":[{"delta":{"reasoning":"The user wants "},"index":0}],"model":"ox-alpha"}"#,
            r#"{"choices":[{"delta":{"reasoning":"PONG."},"index":0}],"model":"ox-alpha"}"#,
            r#"{"choices":[{"delta":{"content":"PONG"},"index":0}],"model":"ox-alpha"}"#,
            r#"{"choices":[{"delta":{},"finish_reason":"stop","index":0}],"model":"ox-alpha"}"#,
            r#"{"choices":[],"model":"ox-alpha","usage":{"completion_tokens":17,"prompt_tokens":99,"total_tokens":116}}"#,
        ];
        let mut step = StepAccumulator::default();
        let mut streamed = String::new();
        {
            let mut sink = |chunk: &str| streamed.push_str(chunk);
            for frame in frames {
                step.absorb_openai(&serde_json::from_str(frame).unwrap(), &mut sink);
            }
        }

        assert_eq!(step.content, "PONG");
        // Reasoning is parsed and kept, and stays off the transcript.
        assert_eq!(step.reasoning, "The user wants PONG.");
        assert_eq!(streamed, "PONG", "reasoning leaked into the answer");
        assert_eq!(step.usage.total_tokens, 116);
        assert_eq!(step.usage.prompt_tokens, 99);
        assert_eq!(step.usage.completion_tokens, 17);
    }

    #[test]
    fn tool_call_fragments_are_joined_by_their_index() {
        let frames = [
            r#"{"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_a","function":{"name":"read_","arguments":"{\"path\":"}}]}}]}"#,
            r#"{"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"name":"file","arguments":"\"a.txt\"}"}}]}}]}"#,
            r#"{"choices":[{"delta":{"tool_calls":[{"index":1,"id":"call_b","function":{"name":"ls","arguments":"{}"}}]}}]}"#,
        ];
        let mut step = StepAccumulator::default();
        let mut sink = |_: &str| {};
        for frame in frames {
            step.absorb_openai(&serde_json::from_str(frame).unwrap(), &mut sink);
        }
        let calls: Vec<_> = step.tool_calls.into_values().collect();
        assert_eq!(calls.len(), 2);
        assert_eq!(calls[0].0, "call_a");
        assert_eq!(calls[0].1, "read_file");
        assert_eq!(calls[0].2, r#"{"path":"a.txt"}"#);
        assert_eq!(calls[1].1, "ls");
    }

    /// The exact frames a live `qwen3:0.6b` turn sent.
    #[test]
    fn a_real_ollama_stream_yields_the_answer_and_the_counts() {
        let frames = [
            r#"{"model":"qwen3:0.6b","message":{"role":"assistant","thinking":"short"},"done":false}"#,
            r#"{"model":"qwen3:0.6b","message":{"role":"assistant","content":"PO"},"done":false}"#,
            r#"{"model":"qwen3:0.6b","message":{"role":"assistant","content":"NG"},"done":false}"#,
            r#"{"model":"qwen3:0.6b","message":{"role":"assistant","content":""},"done":true,"done_reason":"stop","prompt_eval_count":19,"eval_count":28}"#,
        ];
        let mut step = StepAccumulator::default();
        let mut streamed = String::new();
        {
            let mut sink = |chunk: &str| streamed.push_str(chunk);
            for frame in frames {
                step.absorb_ollama(&serde_json::from_str(frame).unwrap(), &mut sink);
            }
        }

        assert_eq!(streamed, "PONG");
        assert_eq!(step.content, "PONG");
        assert_eq!(step.reasoning, "short");
        assert_eq!(step.usage.prompt_tokens, 19);
        assert_eq!(step.usage.completion_tokens, 28);
        assert_eq!(step.usage.total_tokens, 47);
    }

    #[test]
    fn an_ollama_tool_call_arrives_whole_with_object_arguments() {
        let frame = r#"{"message":{"role":"assistant","tool_calls":[{"function":{"name":"read_file","arguments":{"path":"a.txt"}}}]},"done":false}"#;
        let mut step = StepAccumulator::default();
        let mut sink = |_: &str| {};
        step.absorb_ollama(&serde_json::from_str(frame).unwrap(), &mut sink);
        let calls: Vec<_> = step.tool_calls.into_values().collect();
        assert_eq!(calls.len(), 1);
        assert_eq!(calls[0].1, "read_file");
        let parsed: serde_json::Value = serde_json::from_str(&calls[0].2).unwrap();
        assert_eq!(parsed["path"], "a.txt");
    }

    #[test]
    fn a_tool_result_goes_back_to_ollama_named_by_its_tool() {
        let message = ChatMessage {
            role: "tool".to_string(),
            content: Some("hello".to_string()),
            tool_calls: None,
            tool_call_id: Some("local_0_read_file".to_string()),
        };
        let wire = ollama_message(&message);
        assert_eq!(wire["role"], "tool");
        assert_eq!(wire["content"], "hello");
        assert_eq!(wire["tool_name"], "read_file");
    }

    #[test]
    fn an_assistant_tool_call_reaches_ollama_with_its_arguments_parsed() {
        let message = ChatMessage {
            role: "assistant".to_string(),
            content: None,
            tool_calls: Some(vec![serde_json::json!({
                "id": "call_a",
                "type": "function",
                "function": { "name": "read_file", "arguments": "{\"path\":\"a.txt\"}" }
            })]),
            tool_call_id: None,
        };
        let wire = ollama_message(&message);
        assert_eq!(wire["tool_calls"][0]["function"]["name"], "read_file");
        assert_eq!(
            wire["tool_calls"][0]["function"]["arguments"]["path"], "a.txt",
            "Ollama takes arguments as an object, not as the proxy's string"
        );
    }

    /// The local lane's system prompt must not promise a metered proxy, and the
    /// thread lane's must not promise that nothing leaves the machine.
    #[test]
    fn each_lane_tells_the_model_where_it_is_running() {
        let local = CoderRuntimeSession::new(
            Lane::Local("qwen3".to_string()),
            Some("http://127.0.0.1:1/api/v1".to_string()),
            None,
            HarnessToolRegistry::new(Some(std::env::temp_dir())),
        );
        assert!(local.build_system_prompt(&[]).contains("on this machine"));

        let hosted = CoderRuntimeSession::new(
            Lane::OxAlpha,
            Some("http://127.0.0.1:1/api/v1".to_string()),
            None,
            HarnessToolRegistry::new(Some(std::env::temp_dir())),
        );
        assert!(hosted
            .build_system_prompt(&[])
            .contains("OpenAgents inference proxy"));
    }
}

1	+	`//! What the coder runtime does on the wire, proved against real sockets.`
2	+	`//!`
3	+	//! Every test here runs the production `CoderRuntimeSession` against a server
4	+	`//! this file starts on a real port. Nothing is mocked between the session and`
5	+	`//! the socket, so a passing test means the bytes were right.`
6	+	`//!`
7	+	`//! Two things these tests are careful about, because the versions they replace`
8	+	`//! were not:`
9	+	`//!`
10	+	`//! - Streaming is proved with a clock. Asserting that the reply eventually`
11	+	`//! contains the text is satisfied by a response assembled in one block at the`
12	+	`//! end. So the server holds the rest of the stream open, and the assertion is`
13	+	`//! that a chunk reached the caller measurably before the turn returned.`
14	+	//! - A failure is proved to be a failure. `assert!(result.is_ok())` passed
15	+	`//! precisely while this runtime answered every refusal with a made-up grant`
16	+	//! and a sentence about an offline fallback. These assert on `Err` and on
17	+	`//! what it says.`
18	+
19	+	`use openagents_cli::runtime::{CoderRuntimeSession, Lane, TurnUsage};`
20	+	`use openagents_cli::tools::HarnessToolRegistry;`
21	+	`use std::sync::{Arc, Mutex};`
22	+	`use std::time::{Duration, Instant};`
23	+	`use tokio::io::{AsyncReadExt, AsyncWriteExt};`
24	+
25	+	`// ─────────────────────────────────────────────────────────────── the server`
26	+
27	+	`/// What one connection should be answered with.`
28	+	`enum Reply {`
29	+	`/// Status line, content type, and body.`
30	+	`Body(u16, &'static str, String),`
31	+	`/// An event stream: each frame, with an optional pause before one of them.`
32	+	`Sse(Vec<String>, Option<(usize, Duration)>),`
33	+	`/// Newline-delimited JSON, the shape Ollama streams.`
34	+	`Ndjson(Vec<String>, Option<(usize, Duration)>),`
35	+	`}`
36	+
37	+	`/// A server that records what it was asked and answers from a script.`
38	+	`struct Stub {`
39	+	`base: String,`
40	+	`requests: Arc<Mutex<Vec<String>>>,`
41	+	`}`
42	+
43	+	`impl Stub {`
44	+	`/// Every request this stub has taken, headers and body, most recent last.`
45	+	`fn requests(&self) -> Vec<String> {`
46	+	`self.requests.lock().unwrap().clone()`
47	+	`}`
48	+
49	+	`fn request_lines(&self) -> Vec<String> {`
50	+	`self.requests()`
51	+	`.iter()`
52	+	`.map(\|r\| r.lines().next().unwrap_or_default().to_string())`
53	+	`.collect()`
54	+	`}`
55	+	`}`
56	+
57	+	`/// Start a stub whose handler picks a reply from the request text.`
58	+	`fn start<H>(handler: H) -> Stub`
59	+	`where`
60	+	`H: Fn(&str, &str) -> Reply + Send + Sync + 'static,`
61	+	`{`
62	+	`let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();`
63	+	`listener.set_nonblocking(true).unwrap();`
64	+	`let port = listener.local_addr().unwrap().port();`
65	+	`let listener = tokio::net::TcpListener::from_std(listener).unwrap();`
66	+	`let origin = format!("http://127.0.0.1:{port}");`
67	+	`let base = format!("{origin}/api/v1");`
68	+	`let requests = Arc::new(Mutex::new(Vec::new()));`
69	+
70	+	`let seen = Arc::clone(&requests);`
71	+	`let handler = Arc::new(handler);`
72	+	`tokio::spawn(async move {`
73	+	`loop {`
74	+	`let Ok((mut socket, _)) = listener.accept().await else {`
75	+	`return;`
76	+	`};`
77	+	`let seen = Arc::clone(&seen);`
78	+	`let handler = Arc::clone(&handler);`
79	+	`let origin = origin.clone();`
80	+	`tokio::spawn(async move {`
81	+	`let Some(request) = read_request(&mut socket).await else {`
82	+	`return;`
83	+	`};`
84	+	`seen.lock().unwrap().push(request.clone());`
85	+	`match handler(&request, &origin) {`
86	+	`Reply::Body(status, content_type, body) => {`
87	+	`let head = format!(`
88	+	`"HTTP/1.1 {status} X\r\ncontent-type: {content_type}\r\n\`
89	+	`content-length: {}\r\nconnection: close\r\n\r\n",`
90	+	`body.len()`
91	+	`);`
92	+	`let _ = socket.write_all(head.as_bytes()).await;`
93	+	`let _ = socket.write_all(body.as_bytes()).await;`
94	+	`}`
95	+	`Reply::Sse(frames, pause) => {`
96	+	`let _ = socket`
97	+	`.write_all(`
98	+	`b"HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\n\`
99	+	`connection: close\r\n\r\n",`
100	+	`)`
101	+	`.await;`
102	+	`let _ = socket.flush().await;`
103	+	`for (index, frame) in frames.iter().enumerate() {`
104	+	`if let Some((at, delay)) = pause {`
105	+	`if index == at {`
106	+	`tokio::time::sleep(delay).await;`
107	+	`}`
108	+	`}`
109	+	`let _ = socket`
110	+	`.write_all(format!("data: {frame}\n\n").as_bytes())`
111	+	`.await;`
112	+	`let _ = socket.flush().await;`
113	+	`}`
114	+	`let _ = socket.write_all(b"data: [DONE]\n\n").await;`
115	+	`let _ = socket.flush().await;`
116	+	`}`
117	+	`Reply::Ndjson(lines, pause) => {`
118	+	`let _ = socket`
119	+	`.write_all(`
120	+	`b"HTTP/1.1 200 OK\r\ncontent-type: application/x-ndjson\r\n\`
121	+	`connection: close\r\n\r\n",`
122	+	`)`
123	+	`.await;`
124	+	`let _ = socket.flush().await;`
125	+	`for (index, line) in lines.iter().enumerate() {`
126	+	`if let Some((at, delay)) = pause {`
127	+	`if index == at {`
128	+	`tokio::time::sleep(delay).await;`
129	+	`}`
130	+	`}`
131	+	`let _ = socket.write_all(format!("{line}\n").as_bytes()).await;`
132	+	`let _ = socket.flush().await;`
133	+	`}`
134	+	`}`
135	+	`}`
136	+	`let _ = socket.flush().await;`
137	+	`let _ = socket.shutdown().await;`
138	+	`});`
139	+	`}`
140	+	`});`
141	+
142	+	`Stub { base, requests }`
143	+	`}`
144	+
145	+	`async fn read_request(socket: &mut tokio::net::TcpStream) -> Option<String> {`
146	+	`let mut request = Vec::new();`
147	+	`let mut buffer = [0u8; 4096];`
148	+	`loop {`
149	+	`let read = socket.read(&mut buffer).await.ok()?;`
150	+	`if read == 0 {`
151	+	`break;`
152	+	`}`
153	+	`request.extend_from_slice(&buffer[..read]);`
154	+	`let text = String::from_utf8_lossy(&request);`
155	+	`if let Some(headers_end) = text.find("\r\n\r\n") {`
156	+	`let length = text`
157	+	`.lines()`
158	+	`.find_map(\|line\| {`
159	+	`line.strip_prefix("content-length: ")`
160	+	`.or_else(\|\| line.strip_prefix("Content-Length: "))`
161	+	`})`
162	+	`.and_then(\|value\| value.trim().parse::<usize>().ok())`
163	+	`.unwrap_or(0);`
164	+	`if request.len() >= headers_end + 4 + length {`
165	+	`break;`
166	+	`}`
167	+	`}`
168	+	`}`
169	+	`Some(String::from_utf8_lossy(&request).to_string())`
170	+	`}`
171	+
172	+	`fn grant_body(origin: &str, model: &str) -> String {`
173	+	`format!(`
174	+	`r#"{{"thread":{{"id":"th_test"}},"grant":{{"token":"sig_test","url":"{origin}/api/inference/proxy","model":"{model}"}}}}"#`
175	+	`)`
176	+	`}`
177	+
178	+	`fn frame(json: serde_json::Value) -> String {`
179	+	`json.to_string()`
180	+	`}`
181	+
182	+	`fn tools() -> HarnessToolRegistry {`
183	+	`HarnessToolRegistry::new(Some(std::env::temp_dir()))`
184	+	`}`
185	+
186	+	`fn session(lane: Lane, base: String) -> CoderRuntimeSession {`
187	+	`CoderRuntimeSession::new(lane, Some(base), Some("oat_test".to_string()), tools())`
188	+	`}`
189	+
190	+	`/// A port nothing listens on, so a connection to it is refused at once.`
191	+	`const DEAD: &str = "http://127.0.0.1:1/api/v1";`
192	+
193	+	`// ──────────────────────────────────────────────────────── the streaming clock`
194	+
195	+	`/// The reply arrives while the turn is still open, not assembled at the end.`
196	+	`///`
197	+	/// The server sends `PO`, waits 700ms, then sends `NG`. The assertion is on
198	+	`/// the gap between the first chunk and the return: a batched response would`
199	+	`/// deliver both at once and close that gap to nothing.`
200	+	`#[tokio::test]`
201	+	`async fn a_chunk_reaches_the_caller_before_the_turn_returns() {`
202	+	`let stub = start(\|request, origin\| {`
203	+	`if request.starts_with("POST /api/v1/threads") {`
204	+	`return Reply::Body(200, "application/json", grant_body(origin, "ox-alpha"));`
205	+	`}`
206	+	`Reply::Sse(`
207	+	`vec![`
208	+	`frame(serde_json::json!({"choices":[{"delta":{"content":"PO"}}]})),`
209	+	`frame(serde_json::json!({"choices":[{"delta":{"content":"NG"}}]})),`
210	+	`],`
211	+	`Some((1, Duration::from_millis(700))),`
212	+	`)`
213	+	`});`
214	+
215	+	`let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<(String, Instant)>();`
216	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
217	+
218	+	`let started = Instant::now();`
219	+	`let answer = session`
220	+	`.execute_turn("say pong", move \|chunk\| {`
221	+	`let _ = tx.send((chunk.to_string(), Instant::now()));`
222	+	`})`
223	+	`.await`
224	+	`.expect("the turn failed");`
225	+	`let returned = Instant::now();`
226	+
227	+	`let mut chunks = Vec::new();`
228	+	`while let Ok(chunk) = rx.try_recv() {`
229	+	`chunks.push(chunk);`
230	+	`}`
231	+
232	+	`assert_eq!(`
233	+	`chunks`
234	+	`.iter()`
235	+	`.map(\|(text, _)\| text.as_str())`
236	+	`.collect::<Vec<_>>(),`
237	+	`vec!["PO", "NG"],`
238	+	`"the reply did not arrive in pieces"`
239	+	`);`
240	+	`assert_eq!(answer, "PONG");`
241	+
242	+	`let first = chunks[0].1;`
243	+	`let lead = returned.duration_since(first);`
244	+	`assert!(`
245	+	`lead >= Duration::from_millis(500),`
246	+	`"the first chunk landed only {lead:?} before the turn returned, so this run \`
247	+	`does not distinguish streaming from a batched reply (turn took {:?})",`
248	+	`returned.duration_since(started)`
249	+	`);`
250	+	`}`
251	+
252	+	`// ─────────────────────────────────────────────────────────────── the metering`
253	+
254	+	`/// A turn reports what it spent, taken from the server's own usage chunk.`
255	+	`#[tokio::test]`
256	+	`async fn a_turn_reports_the_tokens_the_server_counted() {`
257	+	`let stub = start(\|request, origin\| {`
258	+	`if request.starts_with("POST /api/v1/threads") {`
259	+	`return Reply::Body(200, "application/json", grant_body(origin, "ox-alpha"));`
260	+	`}`
261	+	`Reply::Sse(`
262	+	`vec![`
263	+	`frame(serde_json::json!({"choices":[{"delta":{"reasoning":"thinking"}}]})),`
264	+	`frame(serde_json::json!({"choices":[{"delta":{"content":"PONG"}}]})),`
265	+	`frame(serde_json::json!({`
266	+	`"choices": [],`
267	+	`"usage": {"prompt_tokens": 99, "completion_tokens": 17, "total_tokens": 116}`
268	+	`})),`
269	+	`],`
270	+	`None,`
271	+	`)`
272	+	`});`
273	+
274	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
275	+	`let answer = session.execute_turn("say pong", \|_\| {}).await.unwrap();`
276	+
277	+	`assert_eq!(answer, "PONG");`
278	+	`assert_eq!(`
279	+	`session.last_usage,`
280	+	`TurnUsage {`
281	+	`prompt_tokens: 99,`
282	+	`completion_tokens: 17,`
283	+	`total_tokens: 116`
284	+	`}`
285	+	`);`
286	+	`assert_eq!(`
287	+	`session.last_usage.line(),`
288	+	`"99 prompt + 17 completion = 116 tokens"`
289	+	`);`
290	+	`// The reasoning was parsed and kept off the answer.`
291	+	`assert_eq!(session.last_reasoning, "thinking");`
292	+	`}`
293	+
294	+	`// ────────────────────────────────────────────────────────────── the lifecycle`
295	+
296	+	`/// The thread the session opened is revoked, and the request is the server's.`
297	+	`#[tokio::test]`
298	+	`async fn the_session_revokes_its_thread_when_it_closes() {`
299	+	`let stub = start(\|request, origin\| {`
300	+	`if request.starts_with("POST /api/v1/threads") {`
301	+	`return Reply::Body(200, "application/json", grant_body(origin, "ox-alpha"));`
302	+	`}`
303	+	`if request.starts_with("DELETE /api/v1/threads/") {`
304	+	`return Reply::Body(`
305	+	`200,`
306	+	`"application/json",`
307	+	`r#"{"grant":{"status":"revoked","spent":{"calls":1,"total_tokens":116}},`
308	+	`"thread":{"id":"th_test","status":"cancelled"}}"#`
309	+	`.to_string(),`
310	+	`);`
311	+	`}`
312	+	`Reply::Sse(`
313	+	`vec![frame(`
314	+	`serde_json::json!({"choices":[{"delta":{"content":"ok"}}]}),`
315	+	`)],`
316	+	`None,`
317	+	`)`
318	+	`});`
319	+
320	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
321	+	`session.execute_turn("hello", \|_\| {}).await.unwrap();`
322	+	`let spent = session.close().await.expect("the revocation failed");`
323	+
324	+	`let lines = stub.request_lines();`
325	+	`assert!(`
326	+	`lines`
327	+	`.iter()`
328	+	`.any(\|line\| line.starts_with("DELETE /api/v1/threads/th_test")),`
329	+	`"no revocation was sent; the stub saw {lines:?}"`
330	+	`);`
331	+	`assert_eq!(spent.map(\|usage\| usage.total_tokens), Some(116));`
332	+
333	+	`// The revocation carried the account's own credential, not the grant's.`
334	+	`let delete = stub`
335	+	`.requests()`
336	+	`.into_iter()`
337	+	`.find(\|r\| r.starts_with("DELETE"))`
338	+	`.unwrap();`
339	+	`assert!(delete.contains("Bearer oat_test"), "{delete}");`
340	+
341	+	`// And it does not fire twice.`
342	+	`assert!(session.close().await.unwrap().is_none());`
343	+	`assert_eq!(`
344	+	`stub.request_lines()`
345	+	`.iter()`
346	+	`.filter(\|line\| line.starts_with("DELETE"))`
347	+	`.count(),`
348	+	`1`
349	+	`);`
350	+	`}`
351	+
352	+	`/// One thread serves the whole session rather than one per turn.`
353	+	`#[tokio::test]`
354	+	`async fn a_second_turn_reuses_the_first_turns_thread() {`
355	+	`let stub = start(\|request, origin\| {`
356	+	`if request.starts_with("POST /api/v1/threads") {`
357	+	`return Reply::Body(200, "application/json", grant_body(origin, "ox-alpha"));`
358	+	`}`
359	+	`Reply::Sse(`
360	+	`vec![frame(`
361	+	`serde_json::json!({"choices":[{"delta":{"content":"ok"}}]}),`
362	+	`)],`
363	+	`None,`
364	+	`)`
365	+	`});`
366	+
367	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
368	+	`session.execute_turn("one", \|_\| {}).await.unwrap();`
369	+	`session.execute_turn("two", \|_\| {}).await.unwrap();`
370	+
371	+	`let opens = stub`
372	+	`.request_lines()`
373	+	`.iter()`
374	+	`.filter(\|line\| line.starts_with("POST /api/v1/threads"))`
375	+	`.count();`
376	+	`assert_eq!(opens, 1, "each turn opened its own thread");`
377	+	`}`
378	+
379	+	`// ────────────────────────────────────────────────────────────── the lane gate`
380	+
381	+	`/// A lane nothing admits is refused by name, with what the deployment serves.`
382	+	`///`
383	+	/// `Lane::from_str` used to answer any unrecognised name with `Lane::OxAlpha`,
384	+	/// so `--lane bogus` ran the default and said nothing about it.
385	+	`#[tokio::test]`
386	+	`async fn an_unadmitted_lane_is_refused_with_the_ones_that_work() {`
387	+	`let stub = start(\|request, _origin\| {`
388	+	`if request.starts_with("GET /api/v1/models") {`
389	+	`return Reply::Body(`
390	+	`200,`
391	+	`"application/json",`
392	+	`r#"{"default":"gemini-3.7-flash","models":[`
393	+	`{"id":"gemini-3.7-flash","availability":"available","default":true},`
394	+	`{"id":"ox-alpha","availability":"available","default":false}]}"#`
395	+	`.to_string(),`
396	+	`);`
397	+	`}`
398	+	`Reply::Body(500, "application/json", "{}".to_string())`
399	+	`});`
400	+
401	+	`let mut session = session(Lane::from_str("bogus"), stub.base.clone());`
402	+	`let error = session`
403	+	`.execute_turn("hello", \|_\| {})`
404	+	`.await`
405	+	`.expect_err("an unadmitted lane ran a turn");`
406	+	`let message = error.to_string();`
407	+
408	+	`assert!(message.contains("bogus"), "{message}");`
409	+	`assert!(message.contains("ox-alpha"), "{message}");`
410	+	`assert!(message.contains("gemini-3.7-flash"), "{message}");`
411	+	`for tier in ["auto", "flash", "pro", "ollama:<model>"] {`
412	+	`assert!(`
413	+	`message.contains(tier),`
414	+	`"the refusal does not name {tier}: {message}"`
415	+	`);`
416	+	`}`
417	+	`// And no thread was opened for a lane that cannot run.`
418	+	`assert!(`
419	+	`!stub`
420	+	`.request_lines()`
421	+	`.iter()`
422	+	`.any(\|line\| line.starts_with("POST /api/v1/threads")),`
423	+	`"a refused lane still opened a thread"`
424	+	`);`
425	+	`}`
426	+
427	+	`/// A model in the catalog whose provider is not configured is refused too.`
428	+	`#[tokio::test]`
429	+	`async fn a_served_but_unconfigured_model_is_refused() {`
430	+	`let stub = start(\|request, _origin\| {`
431	+	`if request.starts_with("GET /api/v1/models") {`
432	+	`return Reply::Body(`
433	+	`200,`
434	+	`"application/json",`
435	+	`r#"{"models":[`
436	+	`{"id":"quiet-one","availability":"unavailable","default":false},`
437	+	`{"id":"ox-alpha","availability":"available","default":true}]}"#`
438	+	`.to_string(),`
439	+	`);`
440	+	`}`
441	+	`Reply::Body(500, "application/json", "{}".to_string())`
442	+	`});`
443	+
444	+	`let mut session = session(Lane::from_str("quiet-one"), stub.base.clone());`
445	+	`let message = session`
446	+	`.execute_turn("hello", \|_\| {})`
447	+	`.await`
448	+	`.expect_err("an unavailable model ran a turn")`
449	+	`.to_string();`
450	+	`assert!(message.contains("provider is not configured"), "{message}");`
451	+	`assert!(message.contains("ox-alpha"), "{message}");`
452	+	`}`
453	+
454	+	`/// A tier opens on the catalog id it names, and the grant's model is reported.`
455	+	`#[tokio::test]`
456	+	`async fn a_tier_opens_its_thread_on_the_model_it_names() {`
457	+	`let stub = start(\|request, origin\| {`
458	+	`if request.starts_with("POST /api/v1/threads") {`
459	+	`return Reply::Body(`
460	+	`200,`
461	+	`"application/json",`
462	+	`grant_body(origin, "gemini-3.7-flash"),`
463	+	`);`
464	+	`}`
465	+	`Reply::Sse(`
466	+	`vec![frame(`
467	+	`serde_json::json!({"choices":[{"delta":{"content":"hi"}}]}),`
468	+	`)],`
469	+	`None,`
470	+	`)`
471	+	`});`
472	+
473	+	`let mut session = session(Lane::from_str("flash"), stub.base.clone());`
474	+	`session.execute_turn("hello", \|_\| {}).await.unwrap();`
475	+
476	+	`let open = stub`
477	+	`.requests()`
478	+	`.into_iter()`
479	+	`.find(\|r\| r.starts_with("POST /api/v1/threads"))`
480	+	`.unwrap();`
481	+	`assert!(open.contains(r#""model":"gemini-3.7-flash""#), "{open}");`
482	+	`// The lane the server admits, not a model name in the lane field.`
483	+	`assert!(open.contains(r#""lane":"thread""#), "{open}");`
484	+	`assert_eq!(session.last_model.as_deref(), Some("gemini-3.7-flash"));`
485	+	`assert_eq!(`
486	+	`session.last_grant.as_ref().map(\|g\| g.model.as_str()),`
487	+	`Some("gemini-3.7-flash")`
488	+	`);`
489	+	`}`
490	+
491	+	/// `auto` names no model, so the deployment's own default answers.
492	+	`#[tokio::test]`
493	+	`async fn the_auto_lane_names_no_model_at_all() {`
494	+	`let stub = start(\|request, origin\| {`
495	+	`if request.starts_with("POST /api/v1/threads") {`
496	+	`return Reply::Body(`
497	+	`200,`
498	+	`"application/json",`
499	+	`grant_body(origin, "gemini-3.7-flash"),`
500	+	`);`
501	+	`}`
502	+	`Reply::Sse(`
503	+	`vec![frame(`
504	+	`serde_json::json!({"choices":[{"delta":{"content":"hi"}}]}),`
505	+	`)],`
506	+	`None,`
507	+	`)`
508	+	`});`
509	+
510	+	`let mut session = session(Lane::from_str("auto"), stub.base.clone());`
511	+	`session.execute_turn("hello", \|_\| {}).await.unwrap();`
512	+
513	+	`let open = stub`
514	+	`.requests()`
515	+	`.into_iter()`
516	+	`.find(\|r\| r.starts_with("POST /api/v1/threads"))`
517	+	`.unwrap();`
518	+	`let body = open.split("\r\n\r\n").nth(1).unwrap_or_default();`
519	+	`assert!(!body.contains("\"model\""), "auto pinned a model: {body}");`
520	+	`// What answered is still reported, because the grant said so.`
521	+	`assert_eq!(session.last_model.as_deref(), Some("gemini-3.7-flash"));`
522	+	`}`
523	+
524	+	`// ───────────────────────────────────────────────────────────── no fabrication`
525	+
526	+	`/// A refused thread is an error, not a grant this process invented.`
527	+	`#[tokio::test]`
528	+	`async fn a_refused_thread_ends_the_turn() {`
529	+	`let stub = start(\|_request, _origin\| {`
530	+	`Reply::Body(`
531	+	`422,`
532	+	`"application/json",`
533	+	`r#"{"errors":{"model":["\"bogus\" is not an admitted model."]},"status":422}"#`
534	+	`.to_string(),`
535	+	`)`
536	+	`});`
537	+
538	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
539	+	`let message = session`
540	+	`.execute_turn("hello", \|_\| {})`
541	+	`.await`
542	+	`.expect_err("a 422 thread request produced a completed turn")`
543	+	`.to_string();`
544	+
545	+	`assert!(message.contains("422"), "{message}");`
546	+	`assert!(message.contains("not an admitted model"), "{message}");`
547	+	`assert!(!message.contains("offline fallback"), "{message}");`
548	+	`assert!(session.last_grant.is_none(), "a grant was invented anyway");`
549	+	`}`
550	+
551	+	`/// A thread that opens without a grant is an error too.`
552	+	`///`
553	+	`/// The local lane opens exactly such a thread — it mints no grant, because`
554	+	`/// nothing carries its model to a provider. Reaching the proxy with a token`
555	+	`/// taken from that reply is what the old code did with the caller's PAT.`
556	+	`#[tokio::test]`
557	+	`async fn a_thread_with_no_grant_ends_the_turn() {`
558	+	`let stub = start(\|_request, _origin\| {`
559	+	`Reply::Body(`
560	+	`200,`
561	+	`"application/json",`
562	+	`r#"{"thread":{"id":"th_test","status":"open"}}"#.to_string(),`
563	+	`)`
564	+	`});`
565	+
566	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
567	+	`let message = session`
568	+	`.execute_turn("hello", \|_\| {})`
569	+	`.await`
570	+	`.expect_err("a thread with no grant produced a completed turn")`
571	+	`.to_string();`
572	+	`assert!(message.contains("minted no inference grant"), "{message}");`
573	+	`}`
574	+
575	+	`/// A refused proxy call is an error, with the server's own words.`
576	+	`#[tokio::test]`
577	+	`async fn a_refused_proxy_call_ends_the_turn() {`
578	+	`let stub = start(\|request, origin\| {`
579	+	`if request.starts_with("POST /api/v1/threads") {`
580	+	`return Reply::Body(200, "application/json", grant_body(origin, "ox-alpha"));`
581	+	`}`
582	+	`Reply::Body(`
583	+	`402,`
584	+	`"application/json",`
585	+	`r#"{"error":"the grant's budget is spent"}"#.to_string(),`
586	+	`)`
587	+	`});`
588	+
589	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
590	+	`let message = session`
591	+	`.execute_turn("hello", \|_\| {})`
592	+	`.await`
593	+	`.expect_err("a 402 from the proxy produced a completed turn")`
594	+	`.to_string();`
595	+	`assert!(message.contains("402"), "{message}");`
596	+	`assert!(message.contains("budget is spent"), "{message}");`
597	+	`}`
598	+
599	+	`/// An unreachable proxy is an error, not an empty success.`
600	+	`#[tokio::test]`
601	+	`async fn an_unreachable_host_ends_the_turn() {`
602	+	`let mut session = session(Lane::OxAlpha, DEAD.to_string());`
603	+	`let message = session`
604	+	`.execute_turn("hello", \|_\| {})`
605	+	`.await`
606	+	`.expect_err("an unreachable host produced a completed turn")`
607	+	`.to_string();`
608	+	`assert!(!message.is_empty());`
609	+	`assert!(session.last_grant.is_none());`
610	+	`}`
611	+
612	+	`// ─────────────────────────────────────────────────────────── the tool loop`
613	+
614	+	`/// The model's tool call runs, and its result goes back on the next request.`
615	+	`#[tokio::test]`
616	+	`async fn a_tool_call_runs_and_its_output_returns_to_the_model() {`
617	+	`let round = Arc::new(std::sync::atomic::AtomicUsize::new(0));`
618	+	`let counter = Arc::clone(&round);`
619	+	`let stub = start(move \|request, origin\| {`
620	+	`if request.starts_with("POST /api/v1/threads") {`
621	+	`return Reply::Body(200, "application/json", grant_body(origin, "ox-alpha"));`
622	+	`}`
623	+	`let step = counter.fetch_add(1, std::sync::atomic::Ordering::SeqCst);`
624	+	`if step == 0 {`
625	+	`let call = serde_json::json!({"choices": [{"delta": {"tool_calls": [{`
626	+	`"index": 0,`
627	+	`"id": "call_a",`
628	+	`"function": {"name": "shell", "arguments": "{\"command\":\"echo marker-9f3\"}"}`
629	+	`}]}}]});`
630	+	`return Reply::Sse(vec![frame(call)], None);`
631	+	`}`
632	+	`Reply::Sse(`
633	+	`vec![frame(`
634	+	`serde_json::json!({"choices":[{"delta":{"content":"the marker is marker-9f3"}}]}),`
635	+	`)],`
636	+	`None,`
637	+	`)`
638	+	`});`
639	+
640	+	`let mut session = session(Lane::OxAlpha, stub.base.clone());`
641	+	`let answer = session.execute_turn("run it", \|_\| {}).await.unwrap();`
642	+	`assert_eq!(answer, "the marker is marker-9f3");`
643	+
644	+	`let proxy_calls: Vec<String> = stub`
645	+	`.requests()`
646	+	`.into_iter()`
647	+	`.filter(\|r\| r.starts_with("POST /api/inference/proxy"))`
648	+	`.collect();`
649	+	`assert_eq!(proxy_calls.len(), 2, "the loop did not take a second step");`
650	+	`assert!(`
651	+	`proxy_calls[1].contains("marker-9f3") && proxy_calls[1].contains(r#""role":"tool""#),`
652	+	`"the tool's output did not go back as a tool message:\n{}",`
653	+	`proxy_calls[1]`
654	+	`);`
655	+	`assert!(`
656	+	`proxy_calls[1].contains("call_a"),`
657	+	`"the tool result did not name the call it answers"`
658	+	`);`
659	+	`}`
660	+
661	+	`// ───────────────────────────────────────────────────────────── the local lane`
662	+
663	+	`fn ollama_stub() -> Stub {`
664	+	`start(\|request, _origin\| {`
665	+	`if request.starts_with("GET /api/tags") {`
666	+	`return Reply::Body(`
667	+	`200,`
668	+	`"application/json",`
669	+	`r#"{"models":[`
670	+	`{"name":"older:1b","modified_at":"2026-01-01T00:00:00Z"},`
671	+	`{"name":"qwen3:0.6b","modified_at":"2026-08-25T15:08:15Z"}]}"#`
672	+	`.to_string(),`
673	+	`);`
674	+	`}`
675	+	`Reply::Ndjson(`
676	+	`vec![`
677	+	`serde_json::json!({"message":{"role":"assistant","thinking":"brief"},"done":false})`
678	+	`.to_string(),`
679	+	`serde_json::json!({"message":{"role":"assistant","content":"PO"},"done":false})`
680	+	`.to_string(),`
681	+	`serde_json::json!({"message":{"role":"assistant","content":"NG"},"done":false})`
682	+	`.to_string(),`
683	+	`serde_json::json!({`
684	+	`"message": {"role":"assistant","content":""},`
685	+	`"done": true,`
686	+	`"prompt_eval_count": 19,`
687	+	`"eval_count": 28`
688	+	`})`
689	+	`.to_string(),`
690	+	`],`
691	+	`Some((2, Duration::from_millis(700))),`
692	+	`)`
693	+	`})`
694	+	`}`
695	+
696	+	`/// The local lane answers with the OpenAgents host unreachable, and streams.`
697	+	`///`
698	+	/// `api_base` points at a closed port for the whole turn: a single request to
699	+	`/// openagents.com would fail the turn, so a pass is proof that none was made.`
700	+	`#[tokio::test]`
701	+	`async fn the_local_lane_answers_with_the_proxy_unreachable() {`
702	+	`let ollama = ollama_stub();`
703	+	`let mut session = session(Lane::from_str("ollama:qwen3:0.6b"), DEAD.to_string());`
704	+	`session.ollama_host = ollama.base.trim_end_matches("/api/v1").to_string();`
705	+
706	+	`let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<(String, Instant)>();`
707	+	`let answer = session`
708	+	`.execute_turn("say pong", move \|chunk\| {`
709	+	`let _ = tx.send((chunk.to_string(), Instant::now()));`
710	+	`})`
711	+	`.await`
712	+	`.expect("the local turn failed");`
713	+	`let returned = Instant::now();`
714	+
715	+	`assert_eq!(answer, "PONG");`
716	+	`assert_eq!(session.last_model.as_deref(), Some("ollama:qwen3:0.6b"));`
717	+	`// No grant, and none invented: the model is on this machine.`
718	+	`assert!(session.last_grant.is_none());`
719	+	`assert_eq!(session.last_reasoning, "brief");`
720	+	`assert_eq!(`
721	+	`session.last_usage,`
722	+	`TurnUsage {`
723	+	`prompt_tokens: 19,`
724	+	`completion_tokens: 28,`
725	+	`total_tokens: 47`
726	+	`}`
727	+	`);`
728	+
729	+	`let mut chunks = Vec::new();`
730	+	`while let Ok(chunk) = rx.try_recv() {`
731	+	`chunks.push(chunk);`
732	+	`}`
733	+	`assert_eq!(`
734	+	`chunks.iter().map(\|(t, _)\| t.as_str()).collect::<Vec<_>>(),`
735	+	`vec!["PO", "NG"]`
736	+	`);`
737	+	`let lead = returned.duration_since(chunks[0].1);`
738	+	`assert!(`
739	+	`lead >= Duration::from_millis(500),`
740	+	`"the first chunk landed only {lead:?} before the turn returned, so this run \`
741	+	`does not distinguish streaming from a batched reply"`
742	+	`);`
743	+
744	+	`// The whole exchange was with the local server.`
745	+	`let lines = ollama.request_lines();`
746	+	`assert!(`
747	+	`lines.iter().any(\|l\| l.starts_with("GET /api/tags")),`
748	+	`"{lines:?}"`
749	+	`);`
750	+	`assert!(`
751	+	`lines.iter().any(\|l\| l.starts_with("POST /api/chat")),`
752	+	`"{lines:?}"`
753	+	`);`
754	+	`}`
755	+
756	+	`/// A short name resolves to the installed model whose family it names.`
757	+	`#[tokio::test]`
758	+	`async fn a_family_name_resolves_to_the_installed_model() {`
759	+	`let ollama = ollama_stub();`
760	+	`let mut session = session(Lane::from_str("ollama:qwen3"), DEAD.to_string());`
761	+	`session.ollama_host = ollama.base.trim_end_matches("/api/v1").to_string();`
762	+
763	+	`session.execute_turn("hello", \|_\| {}).await.unwrap();`
764	+	`assert_eq!(session.last_model.as_deref(), Some("ollama:qwen3:0.6b"));`
765	+
766	+	`let chat = ollama`
767	+	`.requests()`
768	+	`.into_iter()`
769	+	`.find(\|r\| r.starts_with("POST /api/chat"))`
770	+	`.unwrap();`
771	+	`assert!(chat.contains(r#""model":"qwen3:0.6b""#), "{chat}");`
772	+	`}`
773	+
774	+	`/// With no model named, the most recently pulled one answers.`
775	+	`#[tokio::test]`
776	+	`async fn the_bare_local_lane_takes_the_most_recent_model() {`
777	+	`let ollama = ollama_stub();`
778	+	`let mut session = session(Lane::from_str("local"), DEAD.to_string());`
779	+	`session.ollama_host = ollama.base.trim_end_matches("/api/v1").to_string();`
780	+
781	+	`session.execute_turn("hello", \|_\| {}).await.unwrap();`
782	+	`assert_eq!(session.last_model.as_deref(), Some("ollama:qwen3:0.6b"));`
783	+	`}`
784	+
785	+	`/// A name no installed model matches is refused, with what is installed.`
786	+	`#[tokio::test]`
787	+	`async fn a_missing_local_model_is_refused_by_name() {`
788	+	`let ollama = ollama_stub();`
789	+	`let mut session = session(Lane::from_str("ollama:llama9"), DEAD.to_string());`
790	+	`session.ollama_host = ollama.base.trim_end_matches("/api/v1").to_string();`
791	+
792	+	`let message = session`
793	+	`.execute_turn("hello", \|_\| {})`
794	+	`.await`
795	+	`.expect_err("a missing local model answered anyway")`
796	+	`.to_string();`
797	+	`assert!(message.contains("llama9"), "{message}");`
798	+	`assert!(message.contains("qwen3:0.6b"), "{message}");`
799	+	`}`
800	+
801	+	`/// No Ollama server is a failed turn, not a fallback to the hosted lane.`
802	+	`#[tokio::test]`
803	+	`async fn no_local_server_ends_the_turn() {`
804	+	`let mut session = session(Lane::from_str("local"), DEAD.to_string());`
805	+	`session.ollama_host = "http://127.0.0.1:1".to_string();`
806	+
807	+	`let message = session`
808	+	`.execute_turn("hello", \|_\| {})`
809	+	`.await`
810	+	`.expect_err("a missing Ollama server produced a completed turn")`
811	+	`.to_string();`
812	+	`assert!(message.contains("no Ollama server answered"), "{message}");`
813	+	`assert!(message.contains("choose a hosted lane"), "{message}");`
814	+	`}`
815	+
816	+	`/// A local tool call runs and returns to the local model.`
817	+	`#[tokio::test]`
818	+	`async fn the_local_lane_runs_tools_and_feeds_the_result_back() {`
819	+	`let round = Arc::new(std::sync::atomic::AtomicUsize::new(0));`
820	+	`let counter = Arc::clone(&round);`
821	+	`let ollama = start(move \|request, _origin\| {`
822	+	`if request.starts_with("GET /api/tags") {`
823	+	`return Reply::Body(`
824	+	`200,`
825	+	`"application/json",`
826	+	`r#"{"models":[{"name":"qwen3:0.6b","modified_at":"2026-08-25T15:08:15Z"}]}"#`
827	+	`.to_string(),`
828	+	`);`
829	+	`}`
830	+	`let step = counter.fetch_add(1, std::sync::atomic::Ordering::SeqCst);`
831	+	`if step == 0 {`
832	+	`return Reply::Ndjson(`
833	+	`vec![serde_json::json!({`
834	+	`"message": {"role":"assistant","content":"","tool_calls":[{`
835	+	`"function": {"name":"shell","arguments":{"command":"echo marker-4c1"}}`
836	+	`}]},`
837	+	`"done": false`
838	+	`})`
839	+	`.to_string()],`
840	+	`None,`
841	+	`);`
842	+	`}`
843	+	`Reply::Ndjson(`
844	+	`vec![serde_json::json!({`
845	+	`"message": {"role":"assistant","content":"marker-4c1"},`
846	+	`"done": true,`
847	+	`"prompt_eval_count": 5,`
848	+	`"eval_count": 3`
849	+	`})`
850	+	`.to_string()],`
851	+	`None,`
852	+	`)`
853	+	`});`
854	+
855	+	`let mut session = session(Lane::from_str("local"), DEAD.to_string());`
856	+	`session.ollama_host = ollama.base.trim_end_matches("/api/v1").to_string();`
857	+	`let answer = session.execute_turn("run it", \|_\| {}).await.unwrap();`
858	+	`assert_eq!(answer, "marker-4c1");`
859	+
860	+	`let chats: Vec<String> = ollama`
861	+	`.requests()`
862	+	`.into_iter()`
863	+	`.filter(\|r\| r.starts_with("POST /api/chat"))`
864	+	`.collect();`
865	+	`assert_eq!(chats.len(), 2, "the local loop did not take a second step");`
866	+	`assert!(`
867	+	`chats[1].contains("marker-4c1") && chats[1].contains(r#""role":"tool""#),`
868	+	`"the tool output did not go back to the local model:\n{}",`
869	+	`chats[1]`
870	+	`);`
871	+	`assert!(`
872	+	`chats[1].contains(r#""tool_name":"shell""#),`
873	+	`"the tool result did not name its tool for Ollama:\n{}",`
874	+	`chats[1]`
875	+	`);`
876	+	`}`

Commit

Give the coder runtime real tiers, a local lane, metering, and revocation

Deploy story

Not deployed through the forge lane

Changed files

Diff

780	780		`print!("{}", chunk);`
781	781		`use std::io::Write;`
782	782		`let _ = std::io::stdout().flush();`
783		-	`}).await.map_err(\|e\| e.to_string())?;`
	783	+	`}).await.map_err(\|e\| e.to_string());`
	784	+	`// The thread is revoked whether the turn worked or not: a`
	785	+	`// failed turn still opened one, and one left open holds its`
	786	+	`// grant's remaining budget.`
	787	+	`let revoked = runtime.close().await;`
	788	+	`// A turn that could not reach a model is a failure, and says`
	789	+	`// so in the shape every other refusal here uses.`
	790	+	`let result = match result {`
	791	+	`Ok(result) => result,`
	792	+	`Err(error) => fail(&error),`
	793	+	`};`
784	794		`println!("\n\nTurn result:\n{}", result);`
	795	+	`if let Some(model) = &runtime.last_model {`
	796	+	`println!("Model: {model}");`
	797	+	`}`
	798	+	`if runtime.last_usage.reported() {`
	799	+	`println!("Usage: {}", runtime.last_usage.line());`
	800	+	`}`
	801	+	`if let Err(error) = revoked {`
	802	+	`eprintln!("oa: the thread was not revoked: {error}");`
	803	+	`}`
785	804		`} else {`
786	805		`crate::interactive::run_tui(coder, token).await?;`
787	806		`}`

8	37		`use serde::{Deserialize, Serialize};`
9	38		`use std::time::Duration;`
10	39
	40	+	`type Failure = Box<dyn std::error::Error + Send + Sync>;`
	41	+
11	42		`pub const THREAD_LANE_NOTICE: &str =`
12	43		`"You answer through the OpenAgents inference proxy, on a thread opened for this session. \`
13	44		`Every round of tool calls re-sends the whole conversation to a metered model, so batch \`
14	45		`independent commands into one call and keep large dumps out of the transcript.";`
15	46
16		-	`#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]`
17		-	`pub enum Lane {`
18		-	`OxAlpha,`
19		-	`GeminiFlash,`
20		-	`GeminiPro,`
21		-	`ClaudeCode,`
22		-	`Codex,`
23		-	`Ollama(String),`
	47	+	`pub const LOCAL_LANE_NOTICE: &str =`
	48	+	`"You answer from a model running on this machine through Ollama. Nothing in this \`
	49	+	`conversation leaves the machine and nothing is metered, but the context window is a \`
	50	+	`fraction of a hosted model's, so keep large dumps out of the transcript.";`
	51	+
	52	+	/// Where an Ollama server listens unless `OPENAGENTS_OLLAMA_HOST` says otherwise.
	53	+	`pub const OLLAMA_HOST: &str = "http://127.0.0.1:11434";`
	54	+
	55	+	`/// How many rounds of tool calls one turn may take before it has to answer.`
	56	+	`///`
	57	+	`/// A backstop against a model that loops, not a budget.`
	58	+	`const MAX_TOOL_STEPS: usize = 30;`
	59	+
	60	+	`/// The tier names a reader may type, and the catalog id each one opens on.`
	61	+	`///`
	62	+	/// A tier is the unit `--lane` deals in: `flash` is the fast lane whatever
	63	+	`/// model is behind it this month, so renaming a vendor model is a one-line`
	64	+	`/// change here and nothing else in the crate holds a vendor string. The ids on`
	65	+	/// the right were served by `GET /api/v1/models` when this was written; the
	66	+	`/// server is the authority and refuses any that stop being true.`
	67	+	`pub const TIERS: &[(&str, &str)] = &[`
	68	+	`("flash", "gemini-3.7-flash"),`
	69	+	`("pro", "gpt-5.6-luna"),`
	70	+	`("ox-alpha", "ox-alpha"),`
	71	+	`];`
	72	+
	73	+	/// What `--lane` takes, for a refusal that leaves the reader somewhere to go.
	74	+	`pub fn admitted_lanes() -> String {`
	75	+	`let tiers = TIERS`
	76	+	`.iter()`
	77	+	`.map(\|(name, id)\| format!("{name} ({id})"))`
	78	+	`.collect::<Vec<_>>()`
	79	+	`.join(", ");`
	80	+	`format!(`
	81	+	`"auto (the deployment's own default), {tiers}, \`
	82	+	`local or ollama:<model> for a model on this machine"`
	83	+	`)`
24	84		`}`
25	85
26		-	`impl Default for Lane {`
27		-	`fn default() -> Self {`
28		-	`Lane::OxAlpha`
29		-	`}`
	86	+	`/// Which lane a turn runs on.`
	87	+	`///`
	88	+	/// [`Lane::from_str`] is total on purpose: an unrecognised name becomes
	89	+	/// [`Lane::Named`] and is checked against the live catalog at the top of the
	90	+	/// turn, so `--lane bogus` is refused by name with the list of what this
	91	+	/// deployment serves. It used to fall through to `_ => Lane::OxAlpha`, which
	92	+	`/// ran the default lane while the reader believed they had chosen another.`
	93	+	`#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]`
	94	+	`pub enum Lane {`
	95	+	`/// No model named at thread open. The deployment's own default answers.`
	96	+	`Auto,`
	97	+	/// The `ox-alpha` tier.
	98	+	`#[default]`
	99	+	`OxAlpha,`
	100	+	`/// The fast tier.`
	101	+	`Flash,`
	102	+	`/// The strong tier.`
	103	+	`Pro,`
	104	+	/// A model id named directly, checked against `GET /api/v1/models`.
	105	+	`Named(String),`
	106	+	`/// Ollama on this machine. An empty string means "whatever is installed".`
	107	+	`Local(String),`
30	108		`}`
31	109
32	110		`impl Lane {`
	111	+	/// Named `from_str` rather than `FromStr::from_str` because it cannot
	112	+	`/// fail: a name nothing admits is carried to the turn, where the catalog`
	113	+	`/// settles it and the refusal can name what this deployment serves.`
	114	+	`#[allow(clippy::should_implement_trait)]`
33	115		`pub fn from_str(s: &str) -> Self {`
34		-	`match s.to_lowercase().as_str() {`
35		-	`"ox-alpha" \| "ox" => Lane::OxAlpha,`
36		-	`"gemini" \| "gemini-flash" => Lane::GeminiFlash,`
37		-	`"gemini-pro" => Lane::GeminiPro,`
38		-	`"claude" => Lane::ClaudeCode,`
39		-	`"codex" => Lane::Codex,`
	116	+	`match s.trim().to_lowercase().as_str() {`
	117	+	`"" \| "auto" => Lane::Auto,`
	118	+	`"ox-alpha" \| "ox" \| "openagents" => Lane::OxAlpha,`
	119	+	`"flash" \| "coder-flash" \| "gemini" \| "gemini-flash" \| "gemini-3.7-flash" => Lane::Flash,`
	120	+	`"pro" \| "coder-pro" \| "gpt-5.6-luna" \| "luna" => Lane::Pro,`
	121	+	`"local" \| "ollama" => Lane::Local(String::new()),`
40	122		`other if other.starts_with("ollama:") => {`
41		-	`Lane::Ollama(other.trim_start_matches("ollama:").to_string())`
	123	+	`Lane::Local(other.trim_start_matches("ollama:").trim().to_string())`
42	124		`}`
43		-	`_ => Lane::OxAlpha,`
	125	+	`other => Lane::Named(other.to_string()),`
	126	+	`}`
	127	+	`}`
	128	+
	129	+	/// The catalog id to send at thread open, or `None` to let the server pick.
	130	+	`pub fn model_id(&self) -> Option<&str> {`
	131	+	`match self {`
	132	+	`Lane::Auto => None,`
	133	+	`Lane::OxAlpha => Some("ox-alpha"),`
	134	+	`Lane::Flash => Some(TIERS[0].1),`
	135	+	`Lane::Pro => Some(TIERS[1].1),`
	136	+	`Lane::Named(id) => Some(id.as_str()),`
	137	+	`// The local lane names its model to Ollama, never to the server.`
	138	+	`Lane::Local(_) => None,`
	139	+	`}`
	140	+	`}`
	141	+
	142	+	`/// Whether this lane answers from this machine.`
	143	+	`pub fn is_local(&self) -> bool {`
	144	+	`matches!(self, Lane::Local(_))`
	145	+	`}`
	146	+
	147	+	/// The tier this lane belongs to: `auto`, `flash`, `pro`, or `local`.
	148	+	`///`
	149	+	`/// A model id no tier pins has no tier, which is a different answer from`
	150	+	`/// "auto" and is worth keeping separate — a reader who named a model`
	151	+	`/// directly did not ask for a tier.`
	152	+	`pub fn tier(&self) -> Option<&'static str> {`
	153	+	`match self {`
	154	+	`Lane::Auto => Some("auto"),`
	155	+	`Lane::Flash => Some("flash"),`
	156	+	`Lane::Pro => Some("pro"),`
	157	+	`Lane::Local(_) => Some("local"),`
	158	+	`Lane::OxAlpha \| Lane::Named(_) => None,`
44	159		`}`
45	160		`}`
46	161
47		-	`pub fn model_name(&self) -> &str {`
	162	+	`/// The name for this lane on a status line.`
	163	+	`pub fn label(&self) -> String {`
48	164		`match self {`
49		-	`Lane::OxAlpha => "ox-alpha",`
50		-	`Lane::GeminiFlash => "gemini-3.7-flash",`
51		-	`Lane::GeminiPro => "gemini-3.7-pro",`
52		-	`Lane::ClaudeCode => "claude-3-7-sonnet",`
53		-	`Lane::Codex => "codex-preview",`
54		-	`Lane::Ollama(m) => m.as_str(),`
	165	+	`Lane::Auto => "Coder Auto".to_string(),`
	166	+	`Lane::Flash => "Coder Flash".to_string(),`
	167	+	`Lane::Pro => "Coder Pro".to_string(),`
	168	+	`Lane::Local(model) if model.is_empty() => "Coder Local".to_string(),`
	169	+	`Lane::Local(model) => format!("Coder Local ({model})"),`
	170	+	`Lane::OxAlpha => "Coder (ox-alpha)".to_string(),`
	171	+	`Lane::Named(id) => format!("Coder ({id})"),`
55	172		`}`
56	173		`}`
57	174		`}`

87	246
88	247		`pub struct CoderRuntimeSession {`
89	248		`pub lane: Lane,`
90		-	`/// The grant the last turn opened, so a caller can report the model that`
91		-	`/// actually answered rather than the one it would have asked for.`
	249	+	`/// The grant this session opened, reused across its turns.`
	250	+	`///`
	251	+	/// `None` on the local lane, always: there is no grant to hold, and
	252	+	`/// putting a made-up one here is the bug this file exists to keep dead.`
92	253		`pub last_grant: Option<InferenceGrant>,`
	254	+	`/// The model that actually answered the last turn.`
	255	+	`///`
	256	+	`/// From the grant on the thread lane, and from the resolved Ollama name on`
	257	+	`/// the local lane. A caller reporting what answered should read this`
	258	+	`/// rather than the lane, which is only what was asked for.`
	259	+	`pub last_model: Option<String>,`
	260	+	`/// What the last turn spent, summed over its steps.`
	261	+	`pub last_usage: TurnUsage,`
	262	+	`/// The reasoning the last turn emitted, if the model emits any.`
	263	+	`///`
	264	+	/// Kept off the content callback deliberately: `delta.reasoning` and
	265	+	/// `delta.content` interleave on the wire, and appending both to the
	266	+	`/// transcript would put the model's scratch work in the middle of its`
	267	+	`/// answer. It is parsed, summed and kept here so a caller that wants to`
	268	+	`/// show it can, and the transcript stays the answer.`
	269	+	`pub last_reasoning: String,`
93	270		`pub api_base: String,`
94	271		`pub user_token: Option<String>,`
	272	+	`pub ollama_host: String,`
95	273		`pub http: reqwest::Client,`
96	274		`pub tools: HarnessToolRegistry,`
97	275		`pub messages: Vec<ChatMessage>,`
	276	+	`/// The thread to revoke when the session closes.`
	277	+	`thread_id: Option<String>,`
98	278		`}`
99	279
100	280		`impl CoderRuntimeSession {`
101		-	`pub fn new(lane: Lane, api_base: Option<String>, user_token: Option<String>, tools: HarnessToolRegistry) -> Self {`
	281	+	`pub fn new(`
	282	+	`lane: Lane,`
	283	+	`api_base: Option<String>,`
	284	+	`user_token: Option<String>,`
	285	+	`tools: HarnessToolRegistry,`
	286	+	`) -> Self {`
102	287		`Self {`
103	288		`lane,`
104	289		`last_grant: None,`
	290	+	`last_model: None,`
	291	+	`last_usage: TurnUsage::default(),`
	292	+	`last_reasoning: String::new(),`
105	293		// `OPENAGENTS_API_BASE` points the session at another host. A test
106	294		`// that has to prove the streaming path end to end needs somewhere`
107	295		`// to point it that is not production, and an operator on staging`
108	296		`// needs the same switch.`
109	297		`api_base: api_base`
110		-	`.or_else(\|\| std::env::var("OPENAGENTS_API_BASE").ok().filter(\|v\| !v.trim().is_empty()))`
	298	+	`.or_else(\|\| {`
	299	+	`std::env::var("OPENAGENTS_API_BASE")`
	300	+	`.ok()`
	301	+	`.filter(\|v\| !v.trim().is_empty())`
	302	+	`})`
111	303		`.unwrap_or_else(\|\| "https://openagents.com/api/v1".to_string()),`
112	304		`user_token,`
	305	+	`ollama_host: std::env::var("OPENAGENTS_OLLAMA_HOST")`
	306	+	`.ok()`
	307	+	`.filter(\|v\| !v.trim().is_empty())`
	308	+	`.unwrap_or_else(\|\| OLLAMA_HOST.to_string()),`
113	309		`http: reqwest::Client::builder()`
114	310		`.timeout(Duration::from_secs(300))`
115	311		`.build()`
116	312		`.unwrap_or_default(),`
117	313		`tools,`
118	314		`messages: Vec::new(),`
	315	+	`thread_id: None,`
119	316		`}`
120	317		`}`
121	318
122	319		`pub fn build_system_prompt(&self, tool_defs: &[ToolDefinition]) -> String {`
	320	+	`let notice = if self.lane.is_local() {`
	321	+	`LOCAL_LANE_NOTICE`
	322	+	`} else {`
	323	+	`THREAD_LANE_NOTICE`
	324	+	`};`
123	325		`let mut lines = vec![`
124		-	format!("You are `openagents coder`, a coding assistant in a terminal. {}", THREAD_LANE_NOTICE),
	326	+	format!("You are `openagents coder`, a coding assistant in a terminal. {notice}"),
125	327		`"".to_string(),`
126	328		`"Answer very concisely unless the reader asks for a longer response.".to_string(),`
127	329		`"".to_string(),`

134	336		`say plainly when something would need a tool you do not have.".to_string()`
135	337		`);`
136	338		`} else {`
137		-	`lines.push(format!("You have {} tools, and no others:", tool_defs.len()));`
	339	+	`lines.push(format!(`
	340	+	`"You have {} tools, and no others:",`
	341	+	`tool_defs.len()`
	342	+	`));`
138	343		`for t in tool_defs {`
139	344		lines.push(format!("- `{}`", t.name));
140	345		`}`

223	605		`tool_call_id: None,`
224	606		`});`
225	607
226		-	`let grant = self.create_thread().await?;`
227		-	`self.last_grant = Some(grant.clone());`
	608	+	`self.last_usage = TurnUsage::default();`
	609	+	`self.last_reasoning.clear();`
228	610
229		-	`let mut max_steps = 30;`
230		-	`let mut final_answer = String::new();`
	611	+	`if self.lane.is_local() {`
	612	+	`self.run_local_turn(&tool_defs, chunk_callback).await`
	613	+	`} else {`
	614	+	`self.run_thread_turn(&tool_defs, chunk_callback).await`
	615	+	`}`
	616	+	`}`
231	617
232		-	`while max_steps > 0 {`
233		-	`max_steps -= 1;`
	618	+	`async fn run_thread_turn<F>(`
	619	+	`&mut self,`
	620	+	`tool_defs: &[ToolDefinition],`
	621	+	`mut chunk_callback: F,`
	622	+	`) -> Result<String, Failure>`
	623	+	`where`
	624	+	`F: FnMut(&str) + Send + 'static,`
	625	+	`{`
	626	+	`if let Lane::Named(id) = self.lane.clone() {`
	627	+	`self.check_named(&id).await?;`
	628	+	`}`
	629	+
	630	+	`// One thread per session, reused across its turns. Opening a fresh one`
	631	+	`// per turn threw away the conversation's own budget and left a trail of`
	632	+	`// open threads nothing ever revoked.`
	633	+	`let grant = match &self.last_grant {`
	634	+	`Some(grant) => grant.clone(),`
	635	+	`None => {`
	636	+	`let grant = self.create_thread().await?;`
	637	+	`self.thread_id = Some(grant.thread_id.clone());`
	638	+	`self.last_grant = Some(grant.clone());`
	639	+	`grant`
	640	+	`}`
	641	+	`};`
	642	+	`self.last_model = Some(grant.model.clone());`
	643	+
	644	+	`let mut final_answer = String::new();`
234	645
	646	+	`for _ in 0..MAX_TOOL_STEPS {`
235	647		`let req_body = serde_json::json!({`
236	648		`"model": grant.model,`
237	649		`"messages": self.messages,`