Skip to content
Python

fix(sdk): integrate shared options and validate transport diagnostics

Rohit P704f4d5788e3
diff --git a/docs-site/pages.json b/docs-site/pages.json
index 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.mjs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.ts
index 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",