Python
fix(sdk): integrate shared options and validate transport diagnostics
Rohit P704f4d5788e3
diff --git a/docs-site/pages.json b/docs-site/pages.jsonindex 3ee65d3b..2052c7df 100644--- a/docs-site/pages.json+++ b/docs-site/pages.json@@ -23,6 +23,10 @@"source": "docs/harness/guides/sessions.md","slug": "sessions"},+ {+ "source": "docs/harness/guides/streaming.md",+ "slug": "streaming"+ },{"source": "docs/harness/guides/guardrails.md","slug": "guardrails"diff --git a/docs-site/src/lib/navigation.mjs b/docs-site/src/lib/navigation.mjsindex 73063433..8b06e15d 100644--- a/docs-site/src/lib/navigation.mjs+++ b/docs-site/src/lib/navigation.mjs@@ -1,6 +1,6 @@export const navigation = [{title:'Get started',open:true,links:[['Overview',''],['Desktop app','desktop'],['Web app','server']]},- {title:'Build',links:[['Models and keys','providers'],['Tools and MCP','tools'],['Sessions and teams','sessions']]},+ {title:'Build',links:[['Models and keys','providers'],['Tools and MCP','tools'],['Sessions and teams','sessions'],['Streaming and retries','streaming']]},{title:'Deploy',links:[['Deployment options','deployment'],['Private Kubernetes','private-kubernetes'],['AWS','aws'],['GCP','gcp'],['Azure','azure']]},{title:'Safety & governance',links:[['NVIDIA OpenShell','openshell'],['Guardrails and hooks','guardrails'],['Agent alignment','alignment'],['Compliance and SIEM','compliance']]},{title:'Operate',links:[['Observability','observability'],['Compatibility and upgrades','releases'],['Troubleshooting','troubleshooting']]},diff --git a/harness/harness-sdk/src/agents/session.rs b/harness/harness-sdk/src/agents/session.rsindex 5422ed3d..dddaf7b8 100644--- a/harness/harness-sdk/src/agents/session.rs+++ b/harness/harness-sdk/src/agents/session.rs@@ -153,12 +153,45 @@ impl RunResult {/// Progress while a run is streaming.#[derive(Clone, Debug)]pub enum RunEvent {- AttemptStarted { session_id: String, turn_id: Option<String>, attempt_id: String, attempt: u32 },- AttemptFinished { session_id: String, turn_id: Option<String>, attempt_id: String, status: String, failure: Option<openworker_runtime::provider::Failure> },- TextDelta { session_id: String, turn_id: Option<String>, attempt_id: String, text: String },- ReasoningDelta { session_id: String, turn_id: Option<String>, attempt_id: String, kind: openworker_runtime::provider::ReasoningKind, text: String, block_index: u64 },- ModelActivity { session_id: String, turn_id: Option<String>, attempt_id: String, elapsed_ms: u64 },- ProviderError { session_id: String, turn_id: Option<String>, attempt_id: String, diagnostic: openworker_runtime::provider::Diagnostic },+ AttemptStarted {+ session_id: String,+ turn_id: Option<String>,+ attempt_id: String,+ attempt: u32,+ },+ AttemptFinished {+ session_id: String,+ turn_id: Option<String>,+ attempt_id: String,+ status: String,+ failure: Option<openworker_runtime::provider::Failure>,+ },+ TextDelta {+ session_id: String,+ turn_id: Option<String>,+ attempt_id: String,+ text: String,+ },+ ReasoningDelta {+ session_id: String,+ turn_id: Option<String>,+ attempt_id: String,+ kind: openworker_runtime::provider::ReasoningKind,+ text: String,+ block_index: u64,+ },+ ModelActivity {+ session_id: String,+ turn_id: Option<String>,+ attempt_id: String,+ elapsed_ms: u64,+ },+ ProviderError {+ session_id: String,+ turn_id: Option<String>,+ attempt_id: String,+ diagnostic: openworker_runtime::provider::Diagnostic,+ },/// Named-team events retain both instance and definition identities.TeamActivity {agent_id: String,@@ -213,9 +246,17 @@ impl RunEvent {}let agent = item["agent"].as_str().unwrap_or_default().to_owned();let summary = &item["summary"];- let session_id = item["event"]["session_id"].as_str().unwrap_or_default().to_owned();+ let session_id = item["event"]["session_id"]+ .as_str()+ .unwrap_or_default()+ .to_owned();let turn_id = item["event"]["turn_id"].as_str().map(str::to_owned);- let attempt_id = || summary["attempt_id"].as_str().unwrap_or_default().to_owned();+ let attempt_id = || {+ summary["attempt_id"]+ .as_str()+ .unwrap_or_default()+ .to_owned()+ };let tool = || summary["tool"].as_str().unwrap_or_default().to_owned();// Older hosts omit this from summaries, but retain it in the journal.let call_id = || {@@ -226,12 +267,45 @@ impl RunEvent {.to_owned()};Some(match summary["type"].as_str() {- Some("model_attempt_started") => RunEvent::AttemptStarted { session_id, turn_id, attempt_id:attempt_id(), attempt:summary["attempt"].as_u64()? as u32 },- Some("model_attempt_finished") => RunEvent::AttemptFinished { session_id, turn_id, attempt_id:attempt_id(), status:summary["status"].as_str()?.into(), failure:serde_json::from_value(summary["kind"].clone()).ok() },- Some("assistant_delta") => RunEvent::TextDelta { session_id, turn_id, attempt_id:attempt_id(), text:summary["text"].as_str()?.into() },- Some("reasoning_delta") => RunEvent::ReasoningDelta { session_id, turn_id, attempt_id:attempt_id(), kind:serde_json::from_value(summary["kind"].clone()).ok()?, text:summary["text"].as_str()?.into(), block_index:summary["block_index"].as_u64()? },- Some("model_activity") => RunEvent::ModelActivity { session_id, turn_id, attempt_id:attempt_id(), elapsed_ms:summary["elapsed_ms"].as_u64()? },- Some("provider_error") => RunEvent::ProviderError { session_id, turn_id, attempt_id:attempt_id(), diagnostic:serde_json::from_value(summary["diagnostic"].clone()).ok()? },+ Some("model_attempt_started") => RunEvent::AttemptStarted {+ session_id,+ turn_id,+ attempt_id: attempt_id(),+ attempt: summary["attempt"].as_u64()? as u32,+ },+ Some("model_attempt_finished") => RunEvent::AttemptFinished {+ session_id,+ turn_id,+ attempt_id: attempt_id(),+ status: summary["status"].as_str()?.into(),+ failure: serde_json::from_value(summary["kind"].clone()).ok(),+ },+ Some("assistant_delta") => RunEvent::TextDelta {+ session_id,+ turn_id,+ attempt_id: attempt_id(),+ text: summary["text"].as_str()?.into(),+ },+ Some("reasoning_delta") => RunEvent::ReasoningDelta {+ session_id,+ turn_id,+ attempt_id: attempt_id(),+ kind: serde_json::from_value(summary["kind"].clone()).ok()?,+ text: summary["text"].as_str()?.into(),+ block_index: summary["block_index"].as_u64()?,+ },+ Some("model_activity") => RunEvent::ModelActivity {+ session_id,+ turn_id,+ attempt_id: attempt_id(),+ elapsed_ms: summary["elapsed_ms"].as_u64()?,+ },+ Some("provider_error") => RunEvent::ProviderError {+ session_id,+ turn_id,+ attempt_id: attempt_id(),+ diagnostic: serde_json::from_value(summary["diagnostic"].clone()).ok()?,+ },Some("message") => RunEvent::Message {agent,text: summary["text"].as_str().unwrap_or_default().to_owned(),@@ -863,14 +937,31 @@ mod tests {#[test]fn attempt_reasoning_and_provider_diagnostics_are_typed() {- let event=json!({"session_id":"s","turn_id":"t","data":{}});- let item=|summary:Value|json!({"agent":"a","event":event,"summary":summary});- assert!(matches!(RunEvent::from_wire(&item(json!({"type":"model_attempt_started","attempt_id":"a1","attempt":1}))),Some(RunEvent::AttemptStarted{attempt:1,attempt_id,..}) if attempt_id=="a1"));- assert!(matches!(RunEvent::from_wire(&item(json!({"type":"model_attempt_finished","attempt_id":"a1","status":"failed","kind":"incomplete_stream"}))),Some(RunEvent::AttemptFinished{failure:Some(openworker_runtime::provider::Failure::IncompleteStream),..})));- assert!(matches!(RunEvent::from_wire(&item(json!({"type":"reasoning_delta","attempt_id":"a1","kind":"summary","text":"display","block_index":0}))),Some(RunEvent::ReasoningDelta{kind:openworker_runtime::provider::ReasoningKind::Summary,text,..}) if text=="display"));- let diagnostic=json!({"category":"authentication","retryable":false,"http_status":401,"request_id":"req_fixture","api":"responses","code":"invalid_api_key"});- assert!(matches!(RunEvent::from_wire(&item(json!({"type":"provider_error","attempt_id":"a1","diagnostic":diagnostic}))),Some(RunEvent::ProviderError{diagnostic,..}) if diagnostic.http_status==Some(401)));- let result=RunResult::from_wire(&json!({"status":"failed","provider_error":diagnostic}));- assert_eq!(result.provider_error.unwrap().request_id.as_deref(),Some("req_fixture"));+ let event = json!({"session_id":"s","turn_id":"t","data":{}});+ let item = |summary: Value| json!({"agent":"a","event":event,"summary":summary});+ assert!(+ matches!(RunEvent::from_wire(&item(json!({"type":"model_attempt_started","attempt_id":"a1","attempt":1}))),Some(RunEvent::AttemptStarted{attempt:1,attempt_id,..}) if attempt_id=="a1")+ );+ assert!(matches!(+ RunEvent::from_wire(&item(+ json!({"type":"model_attempt_finished","attempt_id":"a1","status":"failed","kind":"incomplete_stream"})+ )),+ Some(RunEvent::AttemptFinished {+ failure: Some(openworker_runtime::provider::Failure::IncompleteStream),+ ..+ })+ ));+ assert!(+ matches!(RunEvent::from_wire(&item(json!({"type":"reasoning_delta","attempt_id":"a1","kind":"summary","text":"display","block_index":0}))),Some(RunEvent::ReasoningDelta{kind:openworker_runtime::provider::ReasoningKind::Summary,text,..}) if text=="display")+ );+ let diagnostic = json!({"category":"authentication","retryable":false,"http_status":401,"request_id":"req_fixture","api":"responses","code":"invalid_api_key"});+ assert!(+ matches!(RunEvent::from_wire(&item(json!({"type":"provider_error","attempt_id":"a1","diagnostic":diagnostic}))),Some(RunEvent::ProviderError{diagnostic,..}) if diagnostic.http_status==Some(401))+ );+ let result = RunResult::from_wire(&json!({"status":"failed","provider_error":diagnostic}));+ assert_eq!(+ result.provider_error.unwrap().request_id.as_deref(),+ Some("req_fixture")+ );}}diff --git a/harness/harness-sdk/src/host_runs.rs b/harness/harness-sdk/src/host_runs.rsindex b0154657..e123b1a2 100644--- a/harness/harness-sdk/src/host_runs.rs+++ b/harness/harness-sdk/src/host_runs.rs@@ -1085,8 +1085,12 @@ fn final_output(snapshot: &Value) -> Value {/// A journal event plus a small typed summary SDKs can map directly.fn stream_item(agent: &str, e: Event) -> Value {let summary = match e.kind.as_str() {- "model_attempt_started" | "model_attempt_finished" | "assistant_delta"- | "reasoning_delta" | "model_activity" | "provider_error" => {+ "model_attempt_started"+ | "model_attempt_finished"+ | "assistant_delta"+ | "reasoning_delta"+ | "model_activity"+ | "provider_error" => {let mut summary = e.data.clone();summary["type"] = json!(e.kind);Some(summary)diff --git a/harness/harness-sdk/src/lib.rs b/harness/harness-sdk/src/lib.rsindex 383237bd..252cabce 100644--- a/harness/harness-sdk/src/lib.rs+++ b/harness/harness-sdk/src/lib.rs@@ -25,6 +25,10 @@ pub use openworker_runtime::package::BuiltinTools;pub use openworker_runtime::turn_options::OutputOptions;mod transport;pub use host::{CoworkerConfig, HostConfig, HostProcessConfig, Storage};+pub use openworker_runtime::anthropic::Thinking as AnthropicThinking;+pub use openworker_runtime::provider::{+ Diagnostic as ProviderDiagnostic, Failure as ProviderFailure, ReasoningKind,+};pub use openworker_runtime::provider_auth::{AccessToken, Reason as TokenRefreshReason};pub use openworker_runtime::team_service::{Command as TeamCommand, Create as TeamCreate};pub use openworker_runtime::teams::{Member as TeamMember, Role as TeamRole};@@ -36,8 +40,6 @@ pub use openworker_telemetry::otlp::{/// Opt-in prompt/tool content in telemetry (off by default).pub use openworker_telemetry::{Capture, ContentPolicy};pub use providers::{Credentials, Model, ModelApi, ModelProvider};-pub use openworker_runtime::anthropic::Thinking as AnthropicThinking;-pub use openworker_runtime::provider::{Diagnostic as ProviderDiagnostic, Failure as ProviderFailure, ReasoningKind};pub enum EmbeddedConfig {Local(RuntimeConfig),diff --git a/harness/harness-sdk/src/providers.rs b/harness/harness-sdk/src/providers.rsindex cfef6a8b..c3697c67 100644--- a/harness/harness-sdk/src/providers.rs+++ b/harness/harness-sdk/src/providers.rs@@ -136,8 +136,14 @@ impl ModelProvider {));}if let Some(thinking) = &self.thinking {- if self.api != ModelApi::Anthropic { return Err(Error::InvalidInput("thinking is only supported for Anthropic".into())); }- thinking.validate().map_err(|e|Error::InvalidInput(e.to_string()))?;+ if self.api != ModelApi::Anthropic {+ return Err(Error::InvalidInput(+ "thinking is only supported for Anthropic".into(),+ ));+ }+ thinking+ .validate()+ .map_err(|e| Error::InvalidInput(e.to_string()))?;}if self.stream_usage.is_some() && self.api != ModelApi::ChatCompletions {return Err(Error::InvalidInput(@@ -156,7 +162,9 @@ impl ModelProvider {if let Some(enabled) = self.prompt_caching {wire["prompt_caching"] = json!(enabled);}- if let Some(thinking) = self.thinking { wire["thinking"] = json!(thinking); }+ if let Some(thinking) = self.thinking {+ wire["thinking"] = json!(thinking);+ }if self.access_auth {wire["access_token_auth"] = json!(true);}diff --git a/harness/harness-sdk/src/transport.rs b/harness/harness-sdk/src/transport.rsindex 4fcd2da3..3287f34b 100644--- a/harness/harness-sdk/src/transport.rs+++ b/harness/harness-sdk/src/transport.rs@@ -387,7 +387,11 @@ impl Backend {return Err(Error::OutcomeUnknown);}if let Some(message) = v["error"]["message"].as_str() {- if let Ok(diagnostic) = serde_json::from_value::<openworker_runtime::provider::Diagnostic>(v["error"]["provider_error"].clone()) {+ if let Ok(diagnostic) =+ serde_json::from_value::<openworker_runtime::provider::Diagnostic>(+ v["error"]["provider_error"].clone(),+ )+ {return Err(Error::Provider(diagnostic));}return Err(Error::Remote(message.into()));diff --git a/harness/runtime/src/anthropic.rs b/harness/runtime/src/anthropic.rsindex a407ed22..4d30a010 100644--- a/harness/runtime/src/anthropic.rs+++ b/harness/runtime/src/anthropic.rs@@ -10,16 +10,22 @@ use tokio::sync::mpsc;/// Explicit generation configuration; display is controlled separately per turn.#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]-#[serde(tag="type",rename_all="snake_case",deny_unknown_fields)]+#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]pub enum Thinking {Disabled,Adaptive,- Enabled { #[serde(rename="budgetTokens")] budget_tokens: u32 },+ Enabled {+ #[serde(rename = "budgetTokens")]+ budget_tokens: u32,+ },}impl Thinking {pub fn validate(&self) -> anyhow::Result<()> {if let Self::Enabled { budget_tokens } = self {- anyhow::ensure!((1024..=1_000_000).contains(budget_tokens), "Thinking budget must be between 1024 and 1000000 tokens");+ anyhow::ensure!(+ (1024..=1_000_000).contains(budget_tokens),+ "Thinking budget must be between 1024 and 1000000 tokens"+ );}Ok(())}@@ -29,7 +35,9 @@ impl Thinking {Self::Disabled => json!({"type":"disabled"}),Self::Adaptive => json!({"type":"adaptive"}),Self::Enabled { budget_tokens } => {- if *budget_tokens as usize >= max_tokens { return Err(config()); }+ if *budget_tokens as usize >= max_tokens {+ return Err(config());+ }json!({"type":"enabled","budget_tokens":budget_tokens})}})@@ -202,7 +210,9 @@ pub struct Decoder {reasoning: Option<crate::provider::ReasoningDelta>,}impl Decoder {- pub fn take_reasoning(&mut self) -> Option<crate::provider::ReasoningDelta> { self.reasoning.take() }+ pub fn take_reasoning(&mut self) -> Option<crate::provider::ReasoningDelta> {+ self.reasoning.take()+ }fn usage_report(&self) -> Option<crate::telemetry::TokenUsage> {self.input_known.then(|| {let mut u = self.usage.reported();@@ -469,7 +479,14 @@ pub async fn request(if !(200..300).contains(&status) {let mut bytes = vec![];while let Some(chunk) = stream.next().await {- let chunk = chunk.map_err(|_| Error {kind:classify(status,&Value::Null),retry_after,http_status:Some(status),request_id:request_id.clone(),api:Some(crate::model_api::Api::Anthropic),code:Some("http_error_body_unavailable")})?;+ let chunk = chunk.map_err(|_| Error {+ kind: classify(status, &Value::Null),+ retry_after,+ http_status: Some(status),+ request_id: request_id.clone(),+ api: Some(crate::model_api::Api::Anthropic),+ code: Some("http_error_body_unavailable"),+ })?;if bytes.len() + chunk.len() > 16384 {break;}@@ -514,7 +531,9 @@ pub async fn request(}let decoded = decoded?;if let Some(delta) = decoder.take_reasoning() {- tx.send(Progress::Reasoning(delta)).await.map_err(|_| Error::new(Failure::Transport))?;+ tx.send(Progress::Reasoning(delta))+ .await+ .map_err(|_| Error::new(Failure::Transport))?;}if !first_sent && decoder.output_started() {tx.send(Progress::OutputStarted)diff --git a/harness/runtime/src/chat_completions.rs b/harness/runtime/src/chat_completions.rsindex 3e98fcee..c5917e74 100644--- a/harness/runtime/src/chat_completions.rs+++ b/harness/runtime/src/chat_completions.rs@@ -350,7 +350,12 @@ impl Decoder {};let reasoning_content = delta.get("reasoning_content").filter(|v| !v.is_null());let reasoning = delta.get("reasoning").filter(|v| !v.is_null());- if reasoning_content.zip(reasoning).is_some_and(|(a,b)|a != b) { return Err(invalid()); }+ if reasoning_content+ .zip(reasoning)+ .is_some_and(|(a, b)| a != b)+ {+ return Err(invalid());+ }if let Some(text) = reasoning_content.or(reasoning) {self.reasoning = Some(crate::provider::ReasoningDelta {kind: crate::provider::ReasoningKind::Thinking,@@ -389,7 +394,9 @@ impl Decoder {}self.calls.keys().next_back().map_or(0, |index| index + 1)} else {- c["index"].as_u64().ok_or_else(|| invalid().with_code("invalid_tool_call_index"))?+ c["index"]+ .as_u64()+ .ok_or_else(|| invalid().with_code("invalid_tool_call_index"))?};if index >= 64 || c.get("type").is_some_and(|v| v != "function") {return Err(invalid());@@ -440,7 +447,9 @@ impl Decoder {}}impl StreamDecoder for Decoder {- fn take_reasoning(&mut self) -> Option<crate::provider::ReasoningDelta> { self.reasoning.take() }+ fn take_reasoning(&mut self) -> Option<crate::provider::ReasoningDelta> {+ self.reasoning.take()+ }fn usage_report(&self) -> Option<crate::telemetry::TokenUsage> {self.usage.as_ref().map(Usage::reported)}diff --git a/harness/runtime/src/connections.rs b/harness/runtime/src/connections.rsindex 49ce08c0..96e26466 100644--- a/harness/runtime/src/connections.rs+++ b/harness/runtime/src/connections.rs@@ -257,8 +257,17 @@ impl Manager {}if api == "anthropic" {connections.last_mut().unwrap()["prompt_caching"] = json!(prompt_caching);- let thinking: Option<String> = state.db.query_row("SELECT value FROM thinking_options WHERE id=?1", [&id], |r|r.get(0)).optional()?;- if let Some(value) = thinking { connections.last_mut().unwrap()["thinking"] = serde_json::from_str(&value)?; }+ let thinking: Option<String> = state+ .db+ .query_row(+ "SELECT value FROM thinking_options WHERE id=?1",+ [&id],+ |r| r.get(0),+ )+ .optional()?;+ if let Some(value) = thinking {+ connections.last_mut().unwrap()["thinking"] = serde_json::from_str(&value)?;+ }}}Ok(@@ -287,7 +296,10 @@ impl Manager {bail!("prompt_caching is only supported for Anthropic Messages");}if let Some(thinking) = &input.thinking {- anyhow::ensure!(api == crate::model_api::Api::Anthropic, "thinking is only supported for Anthropic");+ anyhow::ensure!(+ api == crate::model_api::Api::Anthropic,+ "thinking is only supported for Anthropic"+ );thinking.validate()?;}let base_url =@@ -422,7 +434,9 @@ impl Manager {state.db.execute("DELETE FROM endpoints WHERE id=?1", [id])?;- state.db.execute("DELETE FROM thinking_options WHERE id=?1", [id])?;+ state+ .db+ .execute("DELETE FROM thinking_options WHERE id=?1", [id])?;Ok(json!({"removed":true}))}pub fn defaults(&self) -> Result<Defaults> {@@ -652,7 +666,9 @@ impl Manager {let value: Option<String> = self.state.lock().unwrap().db.query_row("SELECT t.value FROM connections c LEFT JOIN thinking_options t ON c.id=t.id WHERE c.id=?1 AND c.identity=?2",params![selected.connection, selected.identity], |r|r.get(0))?;- value.map(|v|serde_json::from_str(&v).map_err(Into::into)).transpose()+ value+ .map(|v| serde_json::from_str(&v).map_err(Into::into))+ .transpose()}/// Harness-owned provider registration; never journal this secret-bearing request.pub fn set_provider(&self, value: Value) -> Result<Value> {@@ -688,7 +704,10 @@ impl Manager {bail!("prompt_caching is only supported for Anthropic Messages");}if let Some(thinking) = &input.thinking {- anyhow::ensure!(input.api == crate::model_api::Api::Anthropic, "thinking is only supported for Anthropic");+ anyhow::ensure!(+ input.api == crate::model_api::Api::Anthropic,+ "thinking is only supported for Anthropic"+ );thinking.validate()?;}anyhow::ensure!(diff --git a/harness/runtime/src/model.rs b/harness/runtime/src/model.rsindex 566919ea..6f0151bf 100644--- a/harness/runtime/src/model.rs+++ b/harness/runtime/src/model.rs@@ -401,7 +401,8 @@ impl Model {tx,crate::chat_completions::Decoder::with_binding(binding, google_compat),)- .await.map_err(|e| e.with_api(api))?;+ .await+ .map_err(|e| e.with_api(api))?;return Ok(());}if api == crate::model_api::Api::Anthropic {@@ -420,14 +421,21 @@ impl Model {}// Short probes, reviewers and compactors have separate small// budgets; do not apply the agent's thinking generation budget.- if self.observation.as_ref().is_some_and(|c| c.purpose == crate::telemetry::ModelPurpose::Main) {+ if self+ .observation+ .as_ref()+ .is_some_and(|c| c.purpose == crate::telemetry::ModelPurpose::Main)+ {if let Some((manager, selection)) = &self.connection {if let Some(thinking) = manager.thinking(selection)? {- body["thinking"] = thinking.request(max_tokens).map_err(|e|e.with_api(api))?;+ body["thinking"] =+ thinking.request(max_tokens).map_err(|e| e.with_api(api))?;}}}- crate::anthropic::request(&client, &endpoint, key, body, tx).await.map_err(|e| e.with_api(api))?;+ crate::anthropic::request(&client, &endpoint, key, body, tx)+ .await+ .map_err(|e| e.with_api(api))?;return Ok(());}if history.iter().any(|v| v.get("provider").is_some()) {@@ -445,11 +453,15 @@ impl Model {}).collect::<Vec<_>>();let mut body = json!({"model":self.name,"instructions":instructions,"input":input,"tools":tools,"stream":true,"store":false,"include":["reasoning.encrypted_content"],"parallel_tool_calls":false,"max_output_tokens":max_tokens});- if self.stream_reasoning { body["reasoning"] = json!({"summary":"auto"}); }+ if self.stream_reasoning {+ body["reasoning"] = json!({"summary":"auto"});+ }if let Some(format) = format {body["text"] = json!({"format":format});}- crate::provider::request(&client, &endpoint, key, body, tx).await.map_err(|e| e.with_api(api))?;+ crate::provider::request(&client, &endpoint, key, body, tx)+ .await+ .map_err(|e| e.with_api(api))?;Ok(())}pub async fn summarize(diff --git a/harness/runtime/src/provider.rs b/harness/runtime/src/provider.rsindex a798ddd6..89e5b5de 100644--- a/harness/runtime/src/provider.rs+++ b/harness/runtime/src/provider.rs@@ -72,9 +72,15 @@ pub struct Diagnostic {impl std::fmt::Display for Diagnostic {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {write!(f, "Provider {:?}", self.category)?;- if let Some(status) = self.http_status { write!(f, " (HTTP {status})")?; }- if let Some(id) = &self.request_id { write!(f, "; request {id}")?; }- if let Some(code) = &self.code { write!(f, "; {code}")?; }+ if let Some(status) = self.http_status {+ write!(f, " (HTTP {status})")?;+ }+ if let Some(id) = &self.request_id {+ write!(f, "; request {id}")?;+ }+ if let Some(code) = &self.code {+ write!(f, "; {code}")?;+ }Ok(())}}@@ -83,15 +89,23 @@ impl std::fmt::Display for Diagnostic {pub(crate) fn request_id(headers: &reqwest::header::HeaderMap, key: &str) -> Option<String> {["x-request-id", "request-id"].into_iter().find_map(|name| {let id = headers.get(name)?.to_str().ok()?;- (!id.is_empty() && id.len() <= 128- && id.bytes().all(|b| b.is_ascii_alphanumeric() || b"-_:".contains(&b))- && !id.starts_with("sk-") && (key.is_empty() || !id.contains(key)))- .then(|| id.to_owned())+ (!id.is_empty()+ && id.len() <= 128+ && id+ .bytes()+ .all(|b| b.is_ascii_alphanumeric() || b"-_:".contains(&b))+ && !id.starts_with("sk-")+ && (key.is_empty() || !id.contains(key)))+ .then(|| id.to_owned())})}impl std::fmt::Display for Error {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- write!(f, "{}; no tool actions accepted from this attempt", self.diagnostic())+ write!(+ f,+ "{}; no tool actions accepted from this attempt",+ self.diagnostic()+ )}}impl std::error::Error for Error {}@@ -103,18 +117,31 @@ impl Error {http_status: None,request_id: None,api: None,- code: match kind { Failure::InvalidResponse=>Some("invalid_response"), Failure::IncompleteStream=>Some("incomplete_stream"), _=>None },+ code: match kind {+ Failure::InvalidResponse => Some("invalid_response"),+ Failure::IncompleteStream => Some("incomplete_stream"),+ _ => None,+ },}}pub fn diagnostic(&self) -> Diagnostic {- Diagnostic { category:self.kind, retryable:self.retryable(), http_status:self.http_status,- request_id:self.request_id.clone(), api:self.api, code:self.code.map(str::to_owned) }+ Diagnostic {+ category: self.kind,+ retryable: self.retryable(),+ http_status: self.http_status,+ request_id: self.request_id.clone(),+ api: self.api,+ code: self.code.map(str::to_owned),+ }}pub fn with_api(mut self, api: crate::model_api::Api) -> Self {self.api = Some(api);self}- pub fn with_code(mut self, code: &'static str) -> Self { self.code=Some(code);self }+ pub fn with_code(mut self, code: &'static str) -> Self {+ self.code = Some(code);+ self+ }pub fn retryable(&self) -> bool {matches!(self.kind,@@ -127,13 +154,36 @@ impl Error {}pub(crate) fn upstream_code(value: &Value) -> Option<&'static str> {- const CODES:&[&str]=&["invalid_api_key","authentication_error","permission_error","invalid_request_error","rate_limit_exceeded","rate_limit_error","insufficient_quota","context_length_exceeded","server_error","api_error","overloaded_error","misalignment_policy_violation","RESOURCE_EXHAUSTED","INVALID_ARGUMENT","UNAUTHENTICATED","PERMISSION_DENIED"];- CODES.iter().copied().find(|code| value["code"]==*code || value["type"]==*code || value["status"]==*code)+ const CODES: &[&str] = &[+ "invalid_api_key",+ "authentication_error",+ "permission_error",+ "invalid_request_error",+ "rate_limit_exceeded",+ "rate_limit_error",+ "insufficient_quota",+ "context_length_exceeded",+ "server_error",+ "api_error",+ "overloaded_error",+ "misalignment_policy_violation",+ "RESOURCE_EXHAUSTED",+ "INVALID_ARGUMENT",+ "UNAUTHENTICATED",+ "PERMISSION_DENIED",+ ];+ CODES+ .iter()+ .copied()+ .find(|code| value["code"] == *code || value["type"] == *code || value["status"] == *code)}#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]-#[serde(rename_all="snake_case")]-pub enum ReasoningKind { Summary, Thinking }+#[serde(rename_all = "snake_case")]+pub enum ReasoningKind {+ Summary,+ Thinking,+}/// Provider-designated display text only. Opaque signatures never enter this type.#[derive(Clone, Debug)]@@ -150,27 +200,42 @@ mod diagnostics_tests {#[test]fn safe_diagnostics_exclude_credentials_and_unbounded_header_text() {let mut headers = reqwest::header::HeaderMap::new();- for value in ["sk-secret-token", "Bearer token", "arbitrary\ttext", "credential-sentinel"] {- headers.insert("x-request-id",value.parse().unwrap());- assert!(request_id(&headers,"credential-sentinel").is_none());+ for value in [+ "sk-secret-token",+ "Bearer token",+ "arbitrary\ttext",+ "credential-sentinel",+ ] {+ headers.insert("x-request-id", value.parse().unwrap());+ assert!(request_id(&headers, "credential-sentinel").is_none());}- headers.insert("x-request-id","req_fixture-123".parse().unwrap());- assert_eq!(request_id(&headers,"credential-sentinel").as_deref(),Some("req_fixture-123"));- let mut e=Error::new(Failure::RateLimit).with_api(crate::model_api::Api::Responses);- e.http_status=Some(429);e.request_id=request_id(&headers,"");- assert_eq!(serde_json::to_value(e.diagnostic()).unwrap(),json!({"category":"rate_limit","retryable":true,"http_status":429,"request_id":"req_fixture-123","api":"responses"}));+ headers.insert("x-request-id", "req_fixture-123".parse().unwrap());+ assert_eq!(+ request_id(&headers, "credential-sentinel").as_deref(),+ Some("req_fixture-123")+ );+ let mut e = Error::new(Failure::RateLimit).with_api(crate::model_api::Api::Responses);+ e.http_status = Some(429);+ e.request_id = request_id(&headers, "");+ assert_eq!(+ serde_json::to_value(e.diagnostic()).unwrap(),+ json!({"category":"rate_limit","retryable":true,"http_status":429,"request_id":"req_fixture-123","api":"responses"})+ );}#[test]fn responses_only_exposes_designated_summary_deltas() {- let mut d=Decoder::default();- for event in [json!({"type":"response.reasoning_text.delta","delta":"hidden"}),json!({"type":"response.output_item.added","item":{"type":"reasoning","encrypted_content":"opaque"}})] {+ let mut d = Decoder::default();+ for event in [+ json!({"type":"response.reasoning_text.delta","delta":"hidden"}),+ json!({"type":"response.output_item.added","item":{"type":"reasoning","encrypted_content":"opaque"}}),+ ] {assert!(d.event(&event).unwrap().is_none());assert!(d.take_reasoning().is_none());}d.event(&json!({"type":"response.reasoning_summary_text.delta","delta":"Display summary","output_index":0})).unwrap();- let delta=d.take_reasoning().unwrap();- assert_eq!(delta.kind,ReasoningKind::Summary);- assert_eq!(delta.text,"Display summary");+ let delta = d.take_reasoning().unwrap();+ assert_eq!(delta.kind, ReasoningKind::Summary);+ assert_eq!(delta.text, "Display summary");assert!(d.take_reasoning().is_none());}}@@ -288,8 +353,13 @@ impl Decoder {"response.reasoning_summary_text.delta" => {self.reasoning = Some(ReasoningDelta {kind: ReasoningKind::Summary,- text: event["delta"].as_str().ok_or_else(|| Error::new(Failure::InvalidResponse))?.to_owned(),- block_index: event["output_index"].as_u64().ok_or_else(|| Error::new(Failure::InvalidResponse))?,+ text: event["delta"]+ .as_str()+ .ok_or_else(|| Error::new(Failure::InvalidResponse))?+ .to_owned(),+ block_index: event["output_index"]+ .as_u64()+ .ok_or_else(|| Error::new(Failure::InvalidResponse))?,});Ok(None)}@@ -379,10 +449,14 @@ pub(crate) trait StreamDecoder {fn output_started(&self) -> bool {false}- fn take_reasoning(&mut self) -> Option<ReasoningDelta> { None }+ fn take_reasoning(&mut self) -> Option<ReasoningDelta> {+ None+ }}impl StreamDecoder for Decoder {- fn take_reasoning(&mut self) -> Option<ReasoningDelta> { self.reasoning.take() }+ fn take_reasoning(&mut self) -> Option<ReasoningDelta> {+ self.reasoning.take()+ }fn usage_report(&self) -> Option<crate::telemetry::TokenUsage> {self.reported.as_ref().map(Usage::reported)}@@ -426,7 +500,14 @@ pub(crate) async fn request_decoded<D: StreamDecoder>(let mut stream = response.bytes_stream();let mut bytes = vec![];while let Some(chunk) = stream.next().await {- let chunk = chunk.map_err(|_| Error { kind:classify(status,""),retry_after,http_status:Some(status),request_id:request_id.clone(),api:None,code:Some("http_error_body_unavailable") })?;+ let chunk = chunk.map_err(|_| Error {+ kind: classify(status, ""),+ retry_after,+ http_status: Some(status),+ request_id: request_id.clone(),+ api: None,+ code: Some("http_error_body_unavailable"),+ })?;if bytes.len() + chunk.len() > 16384 {break;}@@ -466,8 +547,9 @@ pub(crate) async fn request_decoded<D: StreamDecoder>(decoder.done()?;continue;}- let event: Value =- serde_json::from_str(data).map_err(|_| Error::new(Failure::InvalidResponse).with_code("invalid_stream_json"))?;+ let event: Value = serde_json::from_str(data).map_err(|_| {+ Error::new(Failure::InvalidResponse).with_code("invalid_stream_json")+ })?;let decoded = decoder.event(&event);if let Some(usage) = decoder.usage_report()@@ -480,7 +562,9 @@ pub(crate) async fn request_decoded<D: StreamDecoder>(}let decoded = decoded?;if let Some(delta) = decoder.take_reasoning() {- tx.send(Progress::Reasoning(delta)).await.map_err(|_| Error::new(Failure::Transport))?;+ tx.send(Progress::Reasoning(delta))+ .await+ .map_err(|_| Error::new(Failure::Transport))?;}if !first_sent && decoder.output_started() {tx.send(Progress::OutputStarted)diff --git a/harness/runtime/src/runtime.rs b/harness/runtime/src/runtime.rsindex 0bf80c13..17deb9b0 100644--- a/harness/runtime/src/runtime.rs+++ b/harness/runtime/src/runtime.rs@@ -865,7 +865,11 @@ impl Runtime {if item["type"] == "message" {for part in item["content"].as_array().into_iter().flatten() {if let Some(text) = part["text"].as_str() {- let e = self.store.lock().unwrap().attempt_delta(sid,&id,text)?;+ let e = self+ .store+ .lock()+ .unwrap()+ .attempt_delta(sid, &id, text)?;self.publish(e);}}@@ -883,7 +887,11 @@ impl Runtime {Err(error) => {let failure = error.downcast_ref::<crate::provider::Error>();if let Some(failure) = failure {- self.progress(sid,"provider_error",json!({"attempt_id":id,"diagnostic":failure.diagnostic()}))?;+ self.progress(+ sid,+ "provider_error",+ json!({"attempt_id":id,"diagnostic":failure.diagnostic()}),+ )?;}let event = self.store.lock().unwrap().finish_attempt(sid,diff --git a/harness/runtime/src/runtime_m2_tests.rs b/harness/runtime/src/runtime_m2_tests.rsindex a32d5c6f..4e0fcec8 100644--- a/harness/runtime/src/runtime_m2_tests.rs+++ b/harness/runtime/src/runtime_m2_tests.rs@@ -4,25 +4,55 @@ use std::sync::atomic::AtomicUsize;#[tokio::test]async fn reasoning_is_opt_in_and_protected_output_never_streams_candidates() {- for (enabled, protected) in [(false,false),(true,false),(true,true)] {+ for (enabled, protected) in [(false, false), (true, false), (true, true)] {let mut model = Model::new("fixture".into(), true);- model.sample_hook = Some(Arc::new(|_,_,tx|Box::pin(async move {- tx.send(Progress::Reasoning(crate::provider::ReasoningDelta { kind:crate::provider::ReasoningKind::Summary,text:"DISPLAY_SENTINEL".into(),block_index:0 })).await.unwrap();- tx.send(Progress::Delta("answer".into())).await.unwrap();- tx.send(Progress::Complete(Completion { output:vec![json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":"answer"}]})],usage:None })).await.unwrap();- Ok(())- })));- let (_tmp,rt,sid) = fixture(model,true).await;- rt.update(&sid,"configure",json!({}),|s| {+ model.sample_hook = Some(Arc::new(|_, _, tx| {+ Box::pin(async move {+ tx.send(Progress::Reasoning(crate::provider::ReasoningDelta {+ kind: crate::provider::ReasoningKind::Summary,+ text: "DISPLAY_SENTINEL".into(),+ block_index: 0,+ }))+ .await+ .unwrap();+ tx.send(Progress::Delta("answer".into())).await.unwrap();+ tx.send(Progress::Complete(Completion { output:vec![json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":"answer"}]})],usage:None })).await.unwrap();+ Ok(())+ })+ }));+ let (_tmp, rt, sid) = fixture(model, true).await;+ rt.update(&sid, "configure", json!({}), |s| {s.turn.as_mut().unwrap().output.reasoning = enabled;- if protected { s.turn.as_mut().unwrap().safety.guardrails.model_output.push(crate::safety::Rule::regex("check","forbidden",crate::safety::Action::Block)); }+ if protected {+ s.turn+ .as_mut()+ .unwrap()+ .safety+ .guardrails+ .model_output+ .push(crate::safety::Rule::regex(+ "check",+ "forbidden",+ crate::safety::Action::Block,+ ));+ }Ok(())- }).unwrap();- rt.sample(&sid,&[],&[]).await.unwrap();- let events = rt.store.lock().unwrap().events(&sid,0).unwrap();- assert_eq!(events.iter().any(|e|e.kind=="reasoning_delta"),enabled && !protected);- if !enabled || protected { assert!(!serde_json::to_string(&events).unwrap().contains("DISPLAY_SENTINEL")); }- if protected { assert!(!events.iter().any(|e|e.kind=="assistant_delta")); }+ })+ .unwrap();+ rt.sample(&sid, &[], &[]).await.unwrap();+ let events = rt.store.lock().unwrap().events(&sid, 0).unwrap();+ assert_eq!(+ events.iter().any(|e| e.kind == "reasoning_delta"),+ enabled && !protected+ );+ if !enabled || protected {+ assert!(!serde_json::to_string(&events)+ .unwrap()+ .contains("DISPLAY_SENTINEL"));+ }+ if protected {+ assert!(!events.iter().any(|e| e.kind == "assistant_delta"));+ }}}@@ -30,49 +60,101 @@ async fn reasoning_is_opt_in_and_protected_output_never_streams_candidates() {async fn buffered_attempts_discard_failed_text_and_reasoning() {let count = Arc::new(AtomicUsize::new(0));let seen = count.clone();- let mut model = Model::new("fixture".into(),true);- model.sample_hook = Some(Arc::new(move |_,_,tx| {- let failed = seen.fetch_add(1,Ordering::SeqCst)==0;+ let mut model = Model::new("fixture".into(), true);+ model.sample_hook = Some(Arc::new(move |_, _, tx| {+ let failed = seen.fetch_add(1, Ordering::SeqCst) == 0;Box::pin(async move {- let text = if failed {"FAILED_CANDIDATE"} else {"accepted"};+ let text = if failed {+ "FAILED_CANDIDATE"+ } else {+ "accepted"+ };tx.send(Progress::Delta(text.into())).await.unwrap();- tx.send(Progress::Reasoning(crate::provider::ReasoningDelta {kind:crate::provider::ReasoningKind::Summary,text:text.into(),block_index:0})).await.unwrap();- if failed { return Err(Error::new(Failure::IncompleteStream).into()); }+ tx.send(Progress::Reasoning(crate::provider::ReasoningDelta {+ kind: crate::provider::ReasoningKind::Summary,+ text: text.into(),+ block_index: 0,+ }))+ .await+ .unwrap();+ if failed {+ return Err(Error::new(Failure::IncompleteStream).into());+ }tx.send(Progress::Complete(Completion {output:vec![json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":text}]})],usage:None})).await.unwrap();Ok(())})}));- let (_tmp,rt,sid)=fixture(model,true).await;- rt.update(&sid,"configure",json!({}),|s| { let o=&mut s.turn.as_mut().unwrap().output;o.reasoning=true;o.buffer_attempts=true;Ok(()) }).unwrap();- rt.sample(&sid,&[],&[]).await.unwrap();- let events=rt.store.lock().unwrap().events(&sid,0).unwrap();- assert!(!serde_json::to_string(&events).unwrap().contains("FAILED_CANDIDATE"));- assert_eq!(events.iter().filter(|e|e.kind=="assistant_delta").count(),1);- assert_eq!(events.iter().filter(|e|e.kind=="reasoning_delta").count(),1);- let finished:Vec<_>=events.iter().filter(|e|e.kind=="model_attempt_finished").collect();- assert_eq!(finished.len(),2);- assert_eq!(finished[0].data["status"],"failed");- assert_eq!(finished[1].data["status"],"completed");- assert_ne!(finished[0].data["attempt_id"],finished[1].data["attempt_id"]);+ let (_tmp, rt, sid) = fixture(model, true).await;+ rt.update(&sid, "configure", json!({}), |s| {+ let o = &mut s.turn.as_mut().unwrap().output;+ o.reasoning = true;+ o.buffer_attempts = true;+ Ok(())+ })+ .unwrap();+ rt.sample(&sid, &[], &[]).await.unwrap();+ let events = rt.store.lock().unwrap().events(&sid, 0).unwrap();+ assert!(!serde_json::to_string(&events)+ .unwrap()+ .contains("FAILED_CANDIDATE"));+ assert_eq!(+ events+ .iter()+ .filter(|e| e.kind == "assistant_delta")+ .count(),+ 1+ );+ assert_eq!(+ events+ .iter()+ .filter(|e| e.kind == "reasoning_delta")+ .count(),+ 1+ );+ let finished: Vec<_> = events+ .iter()+ .filter(|e| e.kind == "model_attempt_finished")+ .collect();+ assert_eq!(finished.len(), 2);+ assert_eq!(finished[0].data["status"], "failed");+ assert_eq!(finished[1].data["status"], "completed");+ assert_ne!(+ finished[0].data["attempt_id"],+ finished[1].data["attempt_id"]+ );}#[tokio::test]async fn long_model_call_emits_bounded_truthful_activity() {- let mut model=Model::new("fixture".into(),true);- model.sample_hook=Some(Arc::new(|_,_,tx|Box::pin(async move {- tokio::time::sleep(std::time::Duration::from_millis(5100)).await;- tx.send(Progress::Complete(Completion {output:vec![json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":"ready"}]})],usage:None})).await.unwrap();- Ok(())- })));- let (_tmp,rt,sid)=fixture(model,true).await;- tokio::time::timeout(std::time::Duration::from_secs(10),rt.sample(&sid,&[],&[])).await.unwrap().unwrap();- let events=rt.store.lock().unwrap().events(&sid,0).unwrap();- let ticks:Vec<_>=events.iter().filter(|e|e.kind=="model_activity").collect();- assert_eq!(ticks.len(),1);- assert_eq!(ticks[0].data["phase"],"waiting_for_model");- assert!(ticks[0].data["elapsed_ms"].as_u64().unwrap()>=5000);- let end=events.iter().find(|e|e.kind=="model_attempt_finished").unwrap();- assert!(ticks[0].event_id<end.event_id);+ let mut model = Model::new("fixture".into(), true);+ model.sample_hook = Some(Arc::new(|_, _, tx| {+ Box::pin(async move {+ tokio::time::sleep(std::time::Duration::from_millis(5100)).await;+ tx.send(Progress::Complete(Completion {output:vec![json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":"ready"}]})],usage:None})).await.unwrap();+ Ok(())+ })+ }));+ let (_tmp, rt, sid) = fixture(model, true).await;+ tokio::time::timeout(+ std::time::Duration::from_secs(10),+ rt.sample(&sid, &[], &[]),+ )+ .await+ .unwrap()+ .unwrap();+ let events = rt.store.lock().unwrap().events(&sid, 0).unwrap();+ let ticks: Vec<_> = events+ .iter()+ .filter(|e| e.kind == "model_activity")+ .collect();+ assert_eq!(ticks.len(), 1);+ assert_eq!(ticks[0].data["phase"], "waiting_for_model");+ assert!(ticks[0].data["elapsed_ms"].as_u64().unwrap() >= 5000);+ let end = events+ .iter()+ .find(|e| e.kind == "model_attempt_finished")+ .unwrap();+ assert!(ticks[0].event_id < end.event_id);}#[tokio::test]@@ -621,9 +703,9 @@ async fn repeated_transient_failure_stops_after_three_attempts() {kind: Failure::Transient,retry_after: Some(0),http_status: None,- request_id: None,- api: None,- code: None,+ request_id: None,+ api: None,+ code: None,}.into())})@@ -656,9 +738,9 @@ async fn retry_backoff_is_cancellable_without_another_request() {kind: Failure::RateLimit,retry_after: Some(30),http_status: None,- request_id: None,- api: None,- code: None,+ request_id: None,+ api: None,+ code: None,}.into())})diff --git a/harness/runtime/tests/anthropic.rs b/harness/runtime/tests/anthropic.rsindex 466f7b94..c3b0ee49 100644--- a/harness/runtime/tests/anthropic.rs+++ b/harness/runtime/tests/anthropic.rs@@ -145,13 +145,16 @@ fn private_thinking_is_retained_but_not_streamed_and_foreign_history_is_rejected#[test]fn display_thinking_is_separate_from_answer_and_never_includes_signatures() {- let mut d=Decoder::default();d.event(&start()).unwrap();+ let mut d = Decoder::default();+ d.event(&start()).unwrap();d.event(&json!({"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}})).unwrap();assert!(d.event(&json!({"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"Display text"}})).unwrap().is_none());- let text=d.take_reasoning().unwrap();assert_eq!(text.text,"Display text");+ let text = d.take_reasoning().unwrap();+ assert_eq!(text.text, "Display text");d.event(&json!({"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"SECRET_SIGNATURE"}})).unwrap();assert!(d.take_reasoning().is_none());- d.event(&json!({"type":"content_block_stop","index":0})).unwrap();+ d.event(&json!({"type":"content_block_stop","index":0}))+ .unwrap();d.event(&json!({"type":"content_block_start","index":1,"content_block":{"type":"redacted_thinking","data":"SECRET_REDACTED"}})).unwrap();assert!(d.take_reasoning().is_none());}@@ -159,10 +162,24 @@ fn display_thinking_is_separate_from_answer_and_never_includes_signatures() {#[test]fn thinking_generation_configuration_is_explicit_and_budgeted() {use openworker_runtime::anthropic::Thinking;- assert_eq!(Thinking::Adaptive.request(4096).unwrap(),json!({"type":"adaptive"}));- assert_eq!(Thinking::Enabled{budget_tokens:1024}.request(4096).unwrap(),json!({"type":"enabled","budget_tokens":1024}));- assert!(Thinking::Enabled{budget_tokens:1024}.request(1024).is_err());- assert!(Thinking::Enabled{budget_tokens:5}.validate().is_err());+ assert_eq!(+ Thinking::Adaptive.request(4096).unwrap(),+ json!({"type":"adaptive"})+ );+ assert_eq!(+ Thinking::Enabled {+ budget_tokens: 1024+ }+ .request(4096)+ .unwrap(),+ json!({"type":"enabled","budget_tokens":1024})+ );+ assert!(Thinking::Enabled {+ budget_tokens: 1024+ }+ .request(1024)+ .is_err());+ assert!(Thinking::Enabled { budget_tokens: 5 }.validate().is_err());}#[test]fn input_pairing_images_denials_and_structured_reviewer_format() {diff --git a/harness/runtime/tests/connections.rs b/harness/runtime/tests/connections.rsindex a6da131a..3d37a1fa 100644--- a/harness/runtime/tests/connections.rs+++ b/harness/runtime/tests/connections.rs@@ -293,23 +293,43 @@ fn chat_stream_usage_defaults_on_and_opt_out_survives_rotation_and_restart() {#[test]fn anthropic_thinking_is_explicit_validated_and_persisted() {use openworker_runtime::anthropic::Thinking;- let root=tempfile::tempdir().unwrap();- let m=Manager::open(root.path()).unwrap();- let config=json!({"name":"Claude","api":"anthropic","base_url":"https://api.anthropic.com/v1"});+ let root = tempfile::tempdir().unwrap();+ let m = Manager::open(root.path()).unwrap();+ let config =+ json!({"name":"Claude","api":"anthropic","base_url":"https://api.anthropic.com/v1"});m.set_provider(config.clone()).unwrap();- let selected=m.resolve(&Choice::new("Claude","fixture")).unwrap();+ let selected = m.resolve(&Choice::new("Claude", "fixture")).unwrap();assert!(m.thinking(&selected).unwrap().is_none());- let mut enabled=config.clone();enabled["thinking"]=json!({"type":"enabled","budgetTokens":2048});- m.set_provider(enabled).unwrap();m.set_provider(config.clone()).unwrap();- assert_eq!(m.thinking(&selected).unwrap(),Some(Thinking::Enabled{budget_tokens:2048}));- let mut invalid=config.clone();invalid["thinking"]=json!({"type":"enabled","budgetTokens":2});+ let mut enabled = config.clone();+ enabled["thinking"] = json!({"type":"enabled","budgetTokens":2048});+ m.set_provider(enabled).unwrap();+ m.set_provider(config.clone()).unwrap();+ assert_eq!(+ m.thinking(&selected).unwrap(),+ Some(Thinking::Enabled {+ budget_tokens: 2048+ })+ );+ let mut invalid = config.clone();+ invalid["thinking"] = json!({"type":"enabled","budgetTokens":2});assert!(m.set_provider(invalid).is_err());- drop(m);let m=Manager::open(root.path()).unwrap();- assert_eq!(m.thinking(&selected).unwrap(),Some(Thinking::Enabled{budget_tokens:2048}));- assert!(m.set_provider(json!({"name":"Wrong","api":"responses","thinking":{"type":"adaptive"}})).is_err());- let mut disabled=config;disabled["thinking"]=json!({"type":"disabled"});m.set_provider(disabled).unwrap();- assert_eq!(m.thinking(&selected).unwrap(),Some(Thinking::Disabled));- m.remove("Claude").unwrap();assert!(m.thinking(&selected).is_err());+ drop(m);+ let m = Manager::open(root.path()).unwrap();+ assert_eq!(+ m.thinking(&selected).unwrap(),+ Some(Thinking::Enabled {+ budget_tokens: 2048+ })+ );+ assert!(m+ .set_provider(json!({"name":"Wrong","api":"responses","thinking":{"type":"adaptive"}}))+ .is_err());+ let mut disabled = config;+ disabled["thinking"] = json!({"type":"disabled"});+ m.set_provider(disabled).unwrap();+ assert_eq!(m.thinking(&selected).unwrap(), Some(Thinking::Disabled));+ m.remove("Claude").unwrap();+ assert!(m.thinking(&selected).is_err());}#[test]diff --git a/harness/runtime/tests/provider.rs b/harness/runtime/tests/provider.rsindex 0ff44726..fcbd3fb2 100644--- a/harness/runtime/tests/provider.rs+++ b/harness/runtime/tests/provider.rs@@ -131,27 +131,35 @@ async fn real_http_parser_handles_rate_limit_and_truncated_stream() {#[tokio::test]async fn http_diagnostics_retain_status_and_request_id_without_upstream_body() {- let body=r#"{"error":{"code":"invalid_api_key","message":"secret=BODY_SENTINEL"}}"#;+ let body = r#"{"error":{"code":"invalid_api_key","message":"secret=BODY_SENTINEL"}}"#;let (url,server)=http_once(&format!("HTTP/1.1 401 Unauthorized\r\nX-Request-ID: req_fixture\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",body.len(),body)).await;- let (tx,_)=mpsc::channel(10);- let e=provider::request(&reqwest::Client::new(),&url,"KEY_SENTINEL",json!({}),tx).await.unwrap_err();+ let (tx, _) = mpsc::channel(10);+ let e = provider::request(&reqwest::Client::new(), &url, "KEY_SENTINEL", json!({}), tx)+ .await+ .unwrap_err();server.await.unwrap();- assert_eq!(e.http_status,Some(401));- assert_eq!(e.request_id.as_deref(),Some("req_fixture"));+ assert_eq!(e.http_status, Some(401));+ assert_eq!(e.request_id.as_deref(), Some("req_fixture"));assert!(!e.retryable());- for text in [e.to_string(),serde_json::to_string(&e.diagnostic()).unwrap()] {- assert!(!text.contains("BODY_SENTINEL"));assert!(!text.contains("KEY_SENTINEL"));+ for text in [+ e.to_string(),+ serde_json::to_string(&e.diagnostic()).unwrap(),+ ] {+ assert!(!text.contains("BODY_SENTINEL"));+ assert!(!text.contains("KEY_SENTINEL"));}}#[tokio::test]async fn broken_http_error_body_keeps_known_status_and_request_id() {let (url,server)=http_once("HTTP/1.1 401 Unauthorized\r\nX-Request-ID: req_broken\r\nContent-Length: 999\r\nConnection: close\r\n\r\npartial").await;- let (tx,_)=mpsc::channel(10);- let error=provider::request(&reqwest::Client::new(),&url,"test-only",json!({}),tx).await.unwrap_err();+ let (tx, _) = mpsc::channel(10);+ let error = provider::request(&reqwest::Client::new(), &url, "test-only", json!({}), tx)+ .await+ .unwrap_err();server.await.unwrap();- assert_eq!(error.http_status,Some(401));- assert_eq!(error.request_id.as_deref(),Some("req_broken"));- assert_eq!(error.code,Some("http_error_body_unavailable"));- assert_eq!(error.kind,Failure::Authentication);+ assert_eq!(error.http_status, Some(401));+ assert_eq!(error.request_id.as_deref(), Some("req_broken"));+ assert_eq!(error.code, Some("http_error_body_unavailable"));+ assert_eq!(error.kind, Failure::Authentication);}diff --git a/harness/typescript-sdk/src/transport.ts b/harness/typescript-sdk/src/transport.tsindex 294ef5c8..c2a089de 100644--- a/harness/typescript-sdk/src/transport.ts+++ b/harness/typescript-sdk/src/transport.ts@@ -323,7 +323,11 @@ export class Transport {clearTimeout(p.timer);if (frame.error) {// Do not reflect untrusted diagnostics, tool arguments or credentials in errors.- const diagnostic = providerDiagnostic(frame.error.provider_error);+ const diagnostic = providerDiagnostic(+ typeof frame.error === "object" && "provider_error" in frame.error+ ? frame.error.provider_error+ : undefined,+ );p.reject(new HarnessError("Remote",