diff --git a/Cargo.lock b/Cargo.lock
index d85aef283..1de8bc5cd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6806,10 +6806,11 @@ dependencies = [
[[package]]
name = "tinyagents"
-version = "1.8.0"
+version = "1.9.0"
dependencies = [
"async-trait",
"bytes",
+ "chrono",
"futures",
"reqwest 0.12.28",
"rhai",
@@ -6819,6 +6820,7 @@ dependencies = [
"sha2 0.11.0",
"thiserror 2.0.18",
"tokio",
+ "tracing",
]
[[package]]
diff --git a/app/src-tauri/Cargo.lock b/app/src-tauri/Cargo.lock
index 60561c02c..5126fc413 100644
--- a/app/src-tauri/Cargo.lock
+++ b/app/src-tauri/Cargo.lock
@@ -9160,10 +9160,11 @@ dependencies = [
[[package]]
name = "tinyagents"
-version = "1.8.0"
+version = "1.9.0"
dependencies = [
"async-trait",
"bytes",
+ "chrono",
"futures",
"reqwest 0.12.28",
"rhai",
@@ -9173,6 +9174,7 @@ dependencies = [
"sha2 0.11.0",
"thiserror 2.0.18",
"tokio",
+ "tracing",
]
[[package]]
diff --git a/src/bin/inference_probe.rs b/src/bin/inference_probe.rs
index 2f8bb9c42..7cb1bf947 100644
--- a/src/bin/inference_probe.rs
+++ b/src/bin/inference_probe.rs
@@ -32,10 +32,11 @@ use anyhow::{Context, Result};
use clap::Parser;
use openhuman_core::openhuman::agent::Agent;
use openhuman_core::openhuman::config::Config;
-use openhuman_core::openhuman::inference::provider::create_chat_provider;
-use openhuman_core::openhuman::inference::provider::traits::{ChatMessage, ChatRequest};
-use openhuman_core::openhuman::tools::traits::ToolSpec;
+use openhuman_core::openhuman::inference::provider::create_chat_model_with_model_id;
use serde_json::json;
+use tinyagents::harness::message::Message;
+use tinyagents::harness::model::ModelRequest;
+use tinyagents::harness::tool::ToolSchema;
#[derive(Parser, Debug)]
#[command(name = "inference-probe")]
@@ -117,14 +118,16 @@ async fn run_harness(config: &Config, prompt: &str) -> Result<()> {
}
async fn run_raw(config: &Config, role: &str, raw_mode: &str, prompt: &str) -> Result<()> {
- let (provider, model_name) =
- create_chat_provider(role, config).context("create_chat_provider failed")?;
+ let (chat_model, model_name) = create_chat_model_with_model_id(role, config, 0.4)
+ .context("create_chat_model_with_model_id failed")?;
eprintln!("[probe] mode = raw");
eprintln!("[probe] role = {role}");
eprintln!("[probe] resolved model = {model_name}");
eprintln!(
- "[probe] provider.supports_native_tools() = {}",
- provider.supports_native_tools()
+ "[probe] model.profile.tool_calling = {}",
+ chat_model
+ .profile()
+ .is_some_and(|profile| profile.tool_calling)
);
eprintln!("[probe] raw_mode = {raw_mode}");
@@ -149,14 +152,14 @@ Emit tool calls as `name[arg1|arg2]` blocks.
"You are a helpful assistant. Use the provided tools when the user asks something \
a tool can answer.";
- let (system, tools_for_request): (&str, Option>) = match raw_mode {
+ let (system, tools_for_request): (&str, Option>) = match raw_mode {
"native" => (
native_system,
Some(vec![
- ToolSpec {
- name: "get_weather".into(),
- description: "Get the current weather for a city.".into(),
- parameters: json!({
+ ToolSchema::new(
+ "get_weather",
+ "Get the current weather for a city.",
+ json!({
"type": "object",
"properties": {
"city": {"type": "string"},
@@ -164,67 +167,62 @@ Emit tool calls as `name[arg1|arg2]` blocks.
},
"required": ["city"]
}),
- },
- ToolSpec {
- name: "list_files".into(),
- description: "List files in a directory.".into(),
- parameters: json!({
+ ),
+ ToolSchema::new(
+ "list_files",
+ "List files in a directory.",
+ json!({
"type": "object",
"properties": {"path": {"type": "string"}},
"required": ["path"]
}),
- },
+ ),
]),
),
"pformat" => (pformat_system, None),
other => anyhow::bail!("unknown --raw-mode {other:?}"),
};
- let messages = vec![
- ChatMessage::system(system),
- ChatMessage::user(prompt.to_string()),
- ];
+ let mut request = ModelRequest::new(vec![Message::system(system), Message::user(prompt)])
+ .with_model(model_name.clone())
+ .with_temperature(0.4);
+ if let Some(tools) = tools_for_request {
+ request = request.with_tools(tools);
+ }
- let request = ChatRequest {
- messages: &messages,
- tools: tools_for_request.as_deref(),
- stream: None,
- max_tokens: None,
- };
-
- eprintln!("[probe] >>> raw provider.chat()...");
+ eprintln!("[probe] >>> raw ChatModel::invoke()...");
let started = std::time::Instant::now();
- let response = provider
- .chat(request, &model_name, 0.4)
+ let response = chat_model
+ .invoke(&(), request)
.await
- .context("provider.chat() failed")?;
+ .context("ChatModel::invoke() failed")?;
let elapsed = started.elapsed();
eprintln!("[probe] <<< {elapsed:?}");
println!();
println!("=== RAW RESPONSE TEXT ===");
- println!("{}", response.text_or_empty());
+ println!("{}", response.text());
println!("=== /RAW RESPONSE TEXT ===");
- let text = response.text_or_empty();
+ let text = response.text();
let saw_pformat = text.contains("") || text.contains("");
- let saw_native = !response.tool_calls.is_empty();
+ let saw_native = !response.tool_calls().is_empty();
eprintln!(
"[probe] response.tool_calls.len() = {}",
- response.tool_calls.len()
+ response.tool_calls().len()
);
eprintln!(
"[probe] response contains tag = {}",
saw_pformat
);
if saw_native {
- for tc in &response.tool_calls {
+ for tc in response.tool_calls() {
// Print tool name + arg byte-count only — raw arguments may
// contain user content / secrets and must not land in logs.
eprintln!(
"[probe] native tool_call name={} arg_bytes={}",
tc.name,
- tc.arguments.len()
+ tc.arguments.to_string().len()
);
}
}
diff --git a/src/openhuman/agent/harness/graph.rs b/src/openhuman/agent/harness/graph.rs
index 6bfa4331a..30f678e38 100644
--- a/src/openhuman/agent/harness/graph.rs
+++ b/src/openhuman/agent/harness/graph.rs
@@ -77,7 +77,7 @@ pub(crate) async fn run_channel_turn_via_graph(
// Phase 3 / Motion A): the harness graph names crate model types only, and
// reads native-tool / vision capability + telemetry id off the built bundle.
let context_window = source.effective_context_window(model).await;
- let turn_models = source.build(model, temperature, context_window);
+ let turn_models = source.build(model, temperature, context_window)?;
// Native-tool support drives the durable history-suffix dispatcher (native
// envelope vs prompt-guided text) at the end of this turn; capture it before
diff --git a/src/openhuman/agent/harness/session/builder/factory.rs b/src/openhuman/agent/harness/session/builder/factory.rs
index 2e66062e1..176b12222 100644
--- a/src/openhuman/agent/harness/session/builder/factory.rs
+++ b/src/openhuman/agent/harness/session/builder/factory.rs
@@ -14,7 +14,7 @@ use crate::openhuman::agent::host_runtime;
use crate::openhuman::agent_memory::memory_loader::DefaultMemoryLoader;
use crate::openhuman::config::Config;
use crate::openhuman::context::prompt::SystemPromptBuilder;
-use crate::openhuman::inference::provider::{self, Provider};
+use crate::openhuman::inference::provider;
use crate::openhuman::memory::Memory;
use crate::openhuman::memory_store;
use crate::openhuman::memory_tools::ToolMemoryCaptureHook;
@@ -476,14 +476,21 @@ impl Agent {
// double-retry every transient error. Cross-route fallback is likewise
// the crate registry `FallbackPolicy`, so `config.reliability.*` no longer
// layers on the turn path (it still governs the non-seam provider paths).
- let (provider, mut model_name): (Box, String) =
- crate::openhuman::inference::provider::create_chat_provider(provider_role, config)?;
+ let (resolved_chat_model, mut model_name) =
+ crate::openhuman::inference::provider::create_chat_model_with_model_id(
+ provider_role,
+ config,
+ config.default_temperature,
+ )?;
+ let supports_native = resolved_chat_model
+ .profile()
+ .map_or(true, |profile| profile.tool_calling);
log::info!(
"[session-builder] agent_id={} provider_role={} resolved_model={} supports_native_tools={}",
agent_id,
provider_role,
model_name,
- provider.supports_native_tools()
+ supports_native
);
let target_agent_id = target_def
.map(|def| def.id.as_str())
@@ -530,7 +537,6 @@ impl Agent {
// the choice string now so the provider borrow doesn't conflict
// with the later `provider` move into the builder.
let dispatcher_choice = config.agent.tool_dispatcher.clone();
- let supports_native = provider.supports_native_tools();
// Build prompt builder — either the default "orchestrator /
// main agent" layout that bootstraps from workspace identity
@@ -693,23 +699,12 @@ impl Agent {
> = if config.learning.reflection_source
== crate::openhuman::config::ReflectionSource::Cloud
{
- // Reflection always calls with the `hint:reasoning` route +
- // 0.3 temperature (formerly `simple_chat(prompt,
- // "hint:reasoning", 0.3)`), so bake both into the wrapped
- // model. The routed provider still resolves the hint per call.
- let routed = provider::create_routed_provider(
- config.inference_url.as_deref(),
- config.api_url.as_deref(),
- config.api_key.as_deref(),
- &config.reliability,
- &config.model_routes,
- &model_name,
- )?;
- Some(provider::chat_model_from_provider(
- routed,
- "hint:reasoning".to_string(),
- 0.3,
- ))
+ let (model, resolved_model) =
+ provider::create_chat_model_with_model_id("reasoning", config, 0.3)?;
+ log::debug!(
+ "[learning] built crate-native reflection model resolved_model={resolved_model}"
+ );
+ Some(model)
} else {
None
};
@@ -1140,8 +1135,13 @@ impl Agent {
None
};
+ // Crate-native turn models (Phase 3 P3-B): the production main-turn agent
+ // builds crate `ChatModel`s from `(provider_role, config)` without retaining
+ // a host provider. The
+ // `agent_harness_e2e` mock now serves SSE for streaming, so the crate-native
+ // streaming path is exercised end-to-end.
let mut builder = Agent::builder()
- .provider(provider)
+ .crate_native_provider(provider_role, std::sync::Arc::new(config.clone()))
.tools(tools)
.visible_tool_names(visible)
.memory(memory)
diff --git a/src/openhuman/agent/harness/session/builder/setters.rs b/src/openhuman/agent/harness/session/builder/setters.rs
index ca438f998..81bd46b31 100644
--- a/src/openhuman/agent/harness/session/builder/setters.rs
+++ b/src/openhuman/agent/harness/session/builder/setters.rs
@@ -78,6 +78,23 @@ impl AgentBuilder {
self
}
+ /// Sets the AI provider as a **crate-native** turn-model source (Phase 3 P3-B):
+ /// `build`/`build_summarizer` construct crate `ChatModel`s from `(role, config)`
+ /// via `create_turn_chat_model` (managed → `OpenHumanBackendModel`, local/cloud →
+ /// crate `OpenAiModel`) instead of wrapping `provider` in `ProviderModel`s.
+ /// Used by the production session factory; the plain
+ /// [`provider`](Self::provider) setter (Provider path) stays for tests that
+ /// inject a mock they observe.
+ pub fn crate_native_provider(
+ mut self,
+ role: impl Into,
+ config: Arc,
+ ) -> Self {
+ self.turn_model_source =
+ Some(crate::openhuman::tinyagents::TurnModelSource::new_crate_native(role, config));
+ self
+ }
+
/// Sets the available tools for the agent.
pub fn tools(mut self, tools: Vec>) -> Self {
self.tools = Some(tools);
diff --git a/src/openhuman/agent/harness/session/turn/core.rs b/src/openhuman/agent/harness/session/turn/core.rs
index e3e19e2cb..f83ab8e68 100644
--- a/src/openhuman/agent/harness/session/turn/core.rs
+++ b/src/openhuman/agent/harness/session/turn/core.rs
@@ -879,7 +879,7 @@ impl Agent {
.await;
let turn_models =
self.turn_model_source
- .build(effective_model, temperature, context_window);
+ .build(effective_model, temperature, context_window)?;
// Honor custom/BYOK vision models too: they can set `model_vision` even
// when the provider capability bit is false, and must still rehydrate
diff --git a/src/openhuman/agent/harness/session/turn/session_io.rs b/src/openhuman/agent/harness/session/turn/session_io.rs
index e09226b96..cce7b0150 100644
--- a/src/openhuman/agent/harness/session/turn/session_io.rs
+++ b/src/openhuman/agent/harness/session/turn/session_io.rs
@@ -5,9 +5,9 @@ use super::super::types::Agent;
use crate::openhuman::agent::harness;
use crate::openhuman::agent::progress::AgentProgress;
use crate::openhuman::context::ARCHIVIST_EXTRACTION_PROMPT;
-use crate::openhuman::inference::provider::{
- ChatMessage, ChatRequest, ProviderDelta, UsageInfo, AGENT_TURN_MAX_OUTPUT_TOKENS,
-};
+use crate::openhuman::inference::provider::{ChatMessage, UsageInfo, AGENT_TURN_MAX_OUTPUT_TOKENS};
+use futures::StreamExt;
+use tinyagents::harness::model::{ModelRequest, ModelStreamItem};
impl Agent {
// ─────────────────────────────────────────────────────────────────
@@ -92,89 +92,82 @@ impl Agent {
let mut messages = base_messages.to_vec();
messages.push(ChatMessage::user(instruction));
- // Mirror the main loop's streaming sink so the checkpoint renders
- // incrementally. Only text deltas are relevant here (tools are
- // disabled for this call).
- let (delta_tx_opt, delta_forwarder) = if self.on_progress.is_some() {
- let (tx, mut rx) = tokio::sync::mpsc::channel::(128);
- let progress_tx = self.on_progress.clone();
- let forwarder = tokio::spawn(async move {
- while let Some(event) = rx.recv().await {
- let Some(ref sink) = progress_tx else {
- continue;
- };
- if let ProviderDelta::TextDelta { delta } = event {
- if sink
- .send(AgentProgress::TextDelta {
- delta,
- iteration: iteration_for_stream,
- })
- .await
- .is_err()
- {
- break;
- }
- }
- }
- });
- (Some(tx), Some(forwarder))
- } else {
- (None, None)
+ let chat_model = match self
+ .turn_model_source
+ .build_summarizer(effective_model, self.temperature)
+ {
+ Ok(model) => model,
+ Err(error) => {
+ tracing::error!(
+ error = %error,
+ model = effective_model,
+ "[agent::session] failed to build wrap-up model"
+ );
+ return (String::new(), None);
+ }
+ };
+ let request = ModelRequest::new(
+ messages
+ .iter()
+ .map(crate::openhuman::tinyagents::chat_message_to_message)
+ .collect(),
+ )
+ .with_model(effective_model)
+ .with_temperature(self.temperature)
+ .with_max_tokens(AGENT_TURN_MAX_OUTPUT_TOKENS);
+ let mut stream = match chat_model.stream(&(), request).await {
+ Ok(stream) => stream,
+ Err(error) => {
+ tracing::warn!(
+ error = %error,
+ model = effective_model,
+ "[agent::session] wrap-up stream failed to start"
+ );
+ return (String::new(), None);
+ }
};
- // The cap-hit checkpoint summary streams text deltas to the session
- // progress sink (draft updates), which the crate `ChatModel::invoke` path
- // doesn't expose — so this one call resolves the raw provider off the
- // source inline (issue #4249, Phase 3 / Motion A). The `Agent` struct
- // itself holds no `Provider`; this stays a `.provider()` escape hatch until
- // the streaming checkpoint moves onto the crate stream API (Motion B).
- let result = self
- .turn_model_source
- .provider()
- .chat(
- ChatRequest {
- messages: &messages,
- tools: None,
- stream: delta_tx_opt.as_ref(),
- // Reservation-pricing pre-flight budget cap (TAURI-RUST-C62).
- max_tokens: Some(AGENT_TURN_MAX_OUTPUT_TOKENS),
- },
- effective_model,
- self.temperature,
- )
- .await;
- drop(delta_tx_opt);
- if let Some(handle) = delta_forwarder {
- let _ = handle.await;
- }
-
- match result {
- Ok(resp) => {
- let usage = resp.usage.clone();
- // Strip any stray tool-call XML a text-mode model may have
- // emitted; keep only the prose.
- let (text, calls) = self.tool_dispatcher.parse_response(&resp);
- let checkpoint = if !text.trim().is_empty() {
- text
- } else if calls.is_empty() {
- // No tool-call markup was present, so the raw text (if
- // any) is genuine prose — safe to use.
- resp.text.unwrap_or_default()
- } else {
- // `parse_response` stripped tool-call markup and left no
- // prose. Do NOT re-emit `resp.text` here: it would persist
- // the raw `…` markup verbatim as the checkpoint.
- // Return empty so the caller uses the deterministic
- // fallback instead (bug-report-2026-05-26 A1).
- String::new()
- };
- (checkpoint, usage)
- }
- Err(e) => {
- log::warn!("[agent_loop] checkpoint summary call failed: {e:#}");
- (String::new(), None)
+ let mut streamed_text = String::new();
+ let mut completed = None;
+ while let Some(item) = stream.next().await {
+ match item {
+ ModelStreamItem::MessageDelta(delta) if !delta.text.is_empty() => {
+ streamed_text.push_str(&delta.text);
+ if let Some(sink) = &self.on_progress {
+ let _ = sink
+ .send(AgentProgress::TextDelta {
+ delta: delta.text,
+ iteration: iteration_for_stream,
+ })
+ .await;
+ }
+ }
+ ModelStreamItem::Completed(response) => completed = Some(response),
+ ModelStreamItem::Failed(error) => {
+ tracing::warn!(%error, "[agent::session] wrap-up stream failed");
+ return (String::new(), None);
+ }
+ ModelStreamItem::ProviderFailed(error) => {
+ tracing::warn!(error = %error.message, "[agent::session] wrap-up provider failed");
+ return (String::new(), None);
+ }
+ _ => {}
}
}
+ let Some(response) = completed else {
+ tracing::warn!("[agent::session] wrap-up stream ended without completion");
+ return (String::new(), None);
+ };
+ let usage = crate::openhuman::tinyagents::model::usage_info_from_response(&response);
+ let text = response.text();
+ let checkpoint = if !text.trim().is_empty() {
+ text
+ } else if response.tool_calls().is_empty() {
+ streamed_text
+ } else {
+ String::new()
+ };
+ (checkpoint, usage)
}
/// Persist the exact provider messages as a session transcript.
diff --git a/src/openhuman/agent/harness/subagent_runner/extract_tool.rs b/src/openhuman/agent/harness/subagent_runner/extract_tool.rs
index 6abe993fb..7a8f9d992 100644
--- a/src/openhuman/agent/harness/subagent_runner/extract_tool.rs
+++ b/src/openhuman/agent/harness/subagent_runner/extract_tool.rs
@@ -285,7 +285,7 @@ impl Tool for ExtractFromResultTool {
// carries the messages.
let chat = self
.source
- .build_summarizer(&self.model, EXTRACT_TEMPERATURE);
+ .build_summarizer(&self.model, EXTRACT_TEMPERATURE)?;
// Model id for the per-chunk transcript metadata (the chat call itself
// bakes it into `chat`).
let model = self.model.clone();
@@ -415,7 +415,7 @@ impl ExtractFromResultTool {
let call_seq = self.next_call_seq();
let provider_result = self
.source
- .build_summarizer(&self.model, EXTRACT_TEMPERATURE)
+ .build_summarizer(&self.model, EXTRACT_TEMPERATURE)?
.invoke(
&(),
ModelRequest::new(vec![
diff --git a/src/openhuman/agent/harness/subagent_runner/mod.rs b/src/openhuman/agent/harness/subagent_runner/mod.rs
index 50be61cfb..d1b0c8003 100644
--- a/src/openhuman/agent/harness/subagent_runner/mod.rs
+++ b/src/openhuman/agent/harness/subagent_runner/mod.rs
@@ -64,7 +64,7 @@ pub(crate) use tool_prep::build_text_mode_tool_instructions;
// `ResultHandoffCache` with the `extract_from_result` tool.
pub(crate) use handoff::{apply_handoff, ResultHandoffCache};
pub(crate) use ops::run_agent_turn_request_via_default_graph;
-pub(crate) use ops::{append_subagent_role_contract, resolve_subagent_provider};
+pub(crate) use ops::{append_subagent_role_contract, resolve_subagent_source};
// `user_is_signed_in_to_composio` is the mode-aware "can the user call
// composio at all?" probe added in Wave 2 (#1710). Re-exported here so
diff --git a/src/openhuman/agent/harness/subagent_runner/ops/graph.rs b/src/openhuman/agent/harness/subagent_runner/ops/graph.rs
index a357d373d..56c2daecf 100644
--- a/src/openhuman/agent/harness/subagent_runner/ops/graph.rs
+++ b/src/openhuman/agent/harness/subagent_runner/ops/graph.rs
@@ -215,7 +215,7 @@ pub(super) async fn run_subagent_via_graph(
// turn's own model set is consumed by the run). Built off the same source, so
// the checkpoint invokes a crate `ChatModel` without naming `Provider`
// (issue #4249, Phase 3 / Motion A).
- let summary_model = source.build_summarizer(model, temperature);
+ let summary_model = source.build_summarizer(model, temperature)?;
// Resolve the sub-agent model's effective context window so the harness runs
// the context-window summarization step (issue #4249) on sub-agent turns too.
@@ -227,7 +227,7 @@ pub(super) async fn run_subagent_via_graph(
// Build the child turn's crate `ChatModel` set from the source; capability
// reads (vision/native-tools) + telemetry id now come off the built bundle,
// so the sub-agent path names crate model types only.
- let turn_models = source.build(model, temperature, context_window);
+ let turn_models = source.build(model, temperature, context_window)?;
// Vision forwarding (parity with the legacy `run_inner_loop`): rehydrate
// `[IMAGE:…]` placeholders in the sub-agent's history when either the model
diff --git a/src/openhuman/agent/harness/subagent_runner/ops/mod.rs b/src/openhuman/agent/harness/subagent_runner/ops/mod.rs
index 45d37bb92..c8ba6c102 100644
--- a/src/openhuman/agent/harness/subagent_runner/ops/mod.rs
+++ b/src/openhuman/agent/harness/subagent_runner/ops/mod.rs
@@ -39,7 +39,9 @@ pub(crate) use provider::user_is_signed_in_to_composio;
// `super::resolve_subagent_provider`. Keep it accessible at the ops
// module boundary.
pub(crate) use prompt::append_subagent_role_contract;
+#[cfg(test)]
pub(crate) use provider::resolve_subagent_provider;
+pub(crate) use provider::resolve_subagent_source;
// Re-exports for test companion modules that use `use super::*`.
// These provide the same flat namespace the original ops.rs had.
diff --git a/src/openhuman/agent/harness/subagent_runner/ops/provider.rs b/src/openhuman/agent/harness/subagent_runner/ops/provider.rs
index 72e28ecab..acdf56f1e 100644
--- a/src/openhuman/agent/harness/subagent_runner/ops/provider.rs
+++ b/src/openhuman/agent/harness/subagent_runner/ops/provider.rs
@@ -7,6 +7,86 @@ use std::sync::Arc;
use crate::openhuman::inference::provider::Provider;
+pub(crate) fn resolve_subagent_source(
+ spec: &crate::openhuman::agent::harness::definition::ModelSpec,
+ agent_id: &str,
+ config: Option<&crate::openhuman::config::Config>,
+ parent_source: crate::openhuman::tinyagents::TurnModelSource,
+ parent_model: String,
+ is_team_lead: bool,
+ model_override: Option<&str>,
+ temperature: f64,
+) -> (crate::openhuman::tinyagents::TurnModelSource, String) {
+ use crate::openhuman::agent::harness::definition::ModelSpec;
+ if let Some(model) = model_override
+ .map(str::trim)
+ .filter(|model| !model.is_empty())
+ {
+ tracing::debug!(
+ agent_id,
+ model,
+ "[subagent_runner] using inline model override"
+ );
+ return (parent_source, model.to_string());
+ }
+ if let Some(model) = config.and_then(|cfg| cfg.configured_agent_model(agent_id, is_team_lead)) {
+ tracing::debug!(
+ agent_id,
+ model,
+ "[subagent_runner] using config-level model pin"
+ );
+ return (parent_source, model.to_string());
+ }
+ match spec {
+ ModelSpec::Hint(workload) => match config {
+ Some(config) => {
+ match crate::openhuman::inference::provider::create_chat_model_with_model_id(
+ workload,
+ config,
+ temperature,
+ ) {
+ Ok((_model, model_id)) => {
+ tracing::info!(
+ agent_id,
+ role = workload,
+ model = %model_id,
+ "[subagent_runner] resolved crate-native workload source"
+ );
+ (
+ crate::openhuman::tinyagents::TurnModelSource::new_crate_native(
+ workload.clone(),
+ Arc::new(config.clone()),
+ ),
+ model_id,
+ )
+ }
+ Err(error) => {
+ tracing::warn!(
+ agent_id,
+ role = workload,
+ %error,
+ parent_model,
+ "[subagent_runner] workload model build failed; inheriting parent source"
+ );
+ (parent_source, parent_model)
+ }
+ }
+ }
+ None => {
+ tracing::warn!(
+ agent_id,
+ role = workload,
+ parent_model,
+ "[subagent_runner] config unavailable; inheriting parent source"
+ );
+ (parent_source, parent_model)
+ }
+ },
+ ModelSpec::Inherit => (parent_source, parent_model),
+ ModelSpec::Exact(model) => (parent_source, model.clone()),
+ }
+}
+
// ─────────────────────────────────────────────────────────────────────────────
// Provider / model resolution
// ─────────────────────────────────────────────────────────────────────────────
diff --git a/src/openhuman/agent/harness/subagent_runner/ops/runner.rs b/src/openhuman/agent/harness/subagent_runner/ops/runner.rs
index a0cf82672..61ebd8b23 100644
--- a/src/openhuman/agent/harness/subagent_runner/ops/runner.rs
+++ b/src/openhuman/agent/harness/subagent_runner/ops/runner.rs
@@ -42,7 +42,7 @@ use tinyagents::harness::workspace::WorkspaceDescriptor;
use super::prompt::{append_subagent_role_contract, dedup_tool_specs_by_name};
use super::provider::{
- resolve_subagent_provider, user_is_signed_in_to_composio, LazyToolkitResolver,
+ resolve_subagent_source, user_is_signed_in_to_composio, LazyToolkitResolver,
};
/// Runtime spawn-hierarchy gate decision for one delegation hop.
@@ -328,19 +328,20 @@ async fn run_typed_mode(
}
}
- // Resolve provider + model. See `resolve_subagent_provider` for the
+ // Resolve model source + model. See `resolve_subagent_source` for the
// semantics of each ModelSpec variant. `Config::load_or_init()` is
// async so the load is hoisted out of the helper — the helper itself
// is sync and unit-tested.
let config_loaded = crate::openhuman::config::Config::load_or_init().await;
- let (subagent_provider, model) = resolve_subagent_provider(
+ let (mut subagent_source, model) = resolve_subagent_source(
&definition.model,
&definition.id,
config_loaded.as_ref().ok(),
- parent.turn_model_source.provider(),
+ parent.turn_model_source.clone(),
parent.model_name.clone(),
!definition.subagents.is_empty(),
options.model_override.as_deref(),
+ definition.temperature,
);
let temperature = definition.temperature;
let max_output_tokens = definition
@@ -626,36 +627,44 @@ async fn run_typed_mode(
// id rather than dead-ending extraction.
let summarization_tier =
crate::openhuman::inference::provider::factory::summarization_tier_model().to_string();
- let (extract_provider, extract_model): (
- Arc,
- String,
- ) = match crate::openhuman::config::Config::load_or_init().await {
+ // The extract summarizer stays on the resolved `Provider` (the extract's own
+ // summarization resolution, incl. test-injected mocks + the managed-vs-local
+ // decision). It is NOT flipped to a role-resolved crate-native source: that
+ // would re-resolve "summarization" from config and bypass the resolved
+ // provider — production stays managed either way, but a test mock injected on
+ // the parent/extract provider would no longer be observed (issue #4249 P3-B:
+ // the extract flip is deferred; the turn-path flip goes through the primary
+ // producers instead).
+ let (extract_source, extract_model) = match crate::openhuman::config::Config::load_or_init()
+ .await
+ {
Ok(cfg) => {
let route =
crate::openhuman::inference::provider::provider_for_role("summarization", &cfg);
let r = route.trim();
let route_is_managed = r.is_empty() || r == "cloud" || r == "openhuman";
if route_is_managed && !parent.turn_model_source.is_local_provider() {
- (
- parent.turn_model_source.provider(),
- summarization_tier.clone(),
- )
+ (parent.turn_model_source.clone(), summarization_tier.clone())
} else {
- match crate::openhuman::inference::provider::create_chat_provider(
+ match crate::openhuman::inference::provider::create_chat_model_with_model_id(
"summarization",
&cfg,
+ parent.temperature,
) {
- Ok((p, m)) => (Arc::from(p), m),
+ Ok((_model, resolved_model)) => (
+ crate::openhuman::tinyagents::TurnModelSource::new_crate_native(
+ "summarization",
+ Arc::new(cfg.clone()),
+ ),
+ resolved_model,
+ ),
Err(e) => {
tracing::warn!(
agent_id = %definition.id,
error = %e,
"[subagent_runner:typed] extract summarization provider build failed; falling back to parent provider"
);
- (
- parent.turn_model_source.provider(),
- summarization_tier.clone(),
- )
+ (parent.turn_model_source.clone(), summarization_tier.clone())
}
}
}
@@ -666,15 +675,12 @@ async fn run_typed_mode(
error = %e,
"[subagent_runner:typed] config load failed for extract provider; falling back to parent provider + summarization-v1"
);
- (
- parent.turn_model_source.provider(),
- summarization_tier.clone(),
- )
+ (parent.turn_model_source.clone(), summarization_tier.clone())
}
};
dynamic_tools.push(Box::new(ExtractFromResultTool::new(
cache.clone(),
- crate::openhuman::tinyagents::TurnModelSource::new(extract_provider),
+ extract_source,
extract_model,
parent.workspace_dir.clone(),
parent_chain,
@@ -867,22 +873,19 @@ async fn run_typed_mode(
// dropped it, so integrations turns advertised native schemas the backend then
// rejected). Wrapping the provider clears `native_tool_calling`, which makes
// the model adapter skip native advertisement and fall back to XML parsing.
- let subagent_provider: Arc =
- if is_integrations_agent_with_toolkit {
- if let Some(sys) = history.iter_mut().find(|m| m.role == "system") {
- sys.content.push_str("\n\n");
- sys.content.push_str(&build_text_mode_tool_instructions());
- }
- tracing::info!(
- agent_id = %definition.id,
- task_id = %task_id,
- tool_count = filtered_specs.len(),
- "[subagent_runner:text-mode] omitting native tool schemas; injected XML tool protocol into system prompt"
- );
- Arc::new(TextModeProvider::new(subagent_provider))
- } else {
- subagent_provider
- };
+ if is_integrations_agent_with_toolkit {
+ if let Some(sys) = history.iter_mut().find(|m| m.role == "system") {
+ sys.content.push_str("\n\n");
+ sys.content.push_str(&build_text_mode_tool_instructions());
+ }
+ tracing::info!(
+ agent_id = %definition.id,
+ task_id = %task_id,
+ tool_count = filtered_specs.len(),
+ "[subagent_runner:text-mode] omitting native tool schemas; injected XML tool protocol into system prompt"
+ );
+ subagent_source = subagent_source.with_text_mode();
+ }
// ── Run the inner tool-call loop ───────────────────────────────────
// Resolve the sub-agent model's user-configured vision flag; defaults to
@@ -972,7 +975,7 @@ async fn run_typed_mode(
match &definition.graph {
AgentGraph::Default => {
super::graph::run_subagent_via_graph(
- crate::openhuman::tinyagents::TurnModelSource::new(subagent_provider.clone()),
+ subagent_source.clone(),
&model,
temperature,
&mut history,
@@ -1008,9 +1011,7 @@ async fn run_typed_mode(
}
AgentGraph::Custom(run) => {
let req = AgentTurnRequest {
- turn_model_source: crate::openhuman::tinyagents::TurnModelSource::new(
- subagent_provider.clone(),
- ),
+ turn_model_source: subagent_source.clone(),
model: model.clone(),
temperature,
history: std::mem::take(&mut history),
@@ -1184,90 +1185,3 @@ async fn run_typed_mode(
usage,
})
}
-
-/// A [`Provider`] decorator that reports **no native tool calling**, forcing the
-/// tinyagents model adapter to omit native tool schemas and fall back to
-/// prompt-guided (`` XML) parsing. Everything else delegates to the
-/// inner provider. Used to run `integrations_agent` in text mode (its large
-/// toolkit would otherwise blow the provider's native tool-grammar ceiling).
-struct TextModeProvider {
- inner: Arc,
-}
-
-impl TextModeProvider {
- fn new(inner: Arc) -> Self {
- Self { inner }
- }
-}
-
-#[async_trait::async_trait]
-impl crate::openhuman::inference::provider::Provider for TextModeProvider {
- fn capabilities(&self) -> crate::openhuman::inference::provider::traits::ProviderCapabilities {
- let mut caps = self.inner.capabilities();
- // The whole point: hide native tool calling so the adapter advertises none.
- caps.native_tool_calling = false;
- caps
- }
-
- async fn chat_with_system(
- &self,
- system_prompt: Option<&str>,
- message: &str,
- model: &str,
- temperature: f64,
- ) -> anyhow::Result {
- self.inner
- .chat_with_system(system_prompt, message, model, temperature)
- .await
- }
-
- async fn chat(
- &self,
- request: crate::openhuman::inference::provider::ChatRequest<'_>,
- model: &str,
- temperature: f64,
- ) -> anyhow::Result {
- self.inner.chat(request, model, temperature).await
- }
-
- fn supports_vision(&self) -> bool {
- self.inner.supports_vision()
- }
-
- fn supports_streaming(&self) -> bool {
- self.inner.supports_streaming()
- }
-
- async fn effective_context_window(&self, model: &str) -> Option {
- self.inner.effective_context_window(model).await
- }
-
- // #4469 item 2: forward the local-provider identity + cache passthroughs. This
- // decorator only masks native tool calling (above); everything about *where*
- // and *how* the inner provider runs must pass through unchanged. Without these
- // the default trait impls report the inner as a remote, non-caching provider,
- // so a local runtime behind text mode loses its `n_keep >= n_ctx` un-evictable
- // prefix guard (`is_local_provider*` / `loaded_context_window`, #3550) and its
- // KV-cache pricing/strategy (`prompt_cache_capabilities`, #3939).
- fn is_local_provider(&self) -> bool {
- self.inner.is_local_provider()
- }
-
- fn is_local_provider_for_model(&self, model: &str) -> bool {
- self.inner.is_local_provider_for_model(model)
- }
-
- async fn loaded_context_window(&self, model: &str) -> Option {
- self.inner.loaded_context_window(model).await
- }
-
- fn prompt_cache_capabilities(
- &self,
- ) -> crate::openhuman::inference::provider::traits::PromptCacheCapabilities {
- self.inner.prompt_cache_capabilities()
- }
-
- async fn warmup(&self) -> anyhow::Result<()> {
- self.inner.warmup().await
- }
-}
diff --git a/src/openhuman/agent/tools/delegate.rs b/src/openhuman/agent/tools/delegate.rs
index dd43b6479..a56e0dc15 100644
--- a/src/openhuman/agent/tools/delegate.rs
+++ b/src/openhuman/agent/tools/delegate.rs
@@ -1,6 +1,6 @@
use crate::openhuman::config::DelegateAgentConfig;
use crate::openhuman::inference::provider::{
- create_backend_inference_provider, Provider, ProviderRuntimeOptions, INFERENCE_BACKEND_ID,
+ OpenHumanBackendModel, OpenHumanBackendProvider, ProviderRuntimeOptions, INFERENCE_BACKEND_ID,
};
use crate::openhuman::security::policy::ToolOperation;
use crate::openhuman::security::SecurityPolicy;
@@ -11,6 +11,8 @@ use serde_json::json;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
+use tinyagents::harness::message::Message;
+use tinyagents::harness::model::{ChatModel, ModelRequest};
/// Tool that delegates a subtask to a named agent with a different
/// provider/model configuration. Enables multi-agent workflows where
@@ -177,19 +179,10 @@ impl Tool for DelegateTool {
return Ok(ToolResult::error(error));
}
- let provider: Box = match create_backend_inference_provider(
- None,
- None,
- None,
- &self.provider_runtime_options,
- ) {
- Ok(p) => p,
- Err(e) => {
- return Ok(ToolResult::error(format!(
- "Failed to create inference client for delegate agent '{agent_name}': {e}"
- )));
- }
- };
+ let model = OpenHumanBackendModel::new(
+ OpenHumanBackendProvider::new(None, &self.provider_runtime_options),
+ agent_config.model.clone(),
+ );
// Build the message
let full_prompt = if context.is_empty() {
@@ -204,11 +197,19 @@ impl Tool for DelegateTool {
// Wrap the provider call in a timeout to prevent indefinite blocking
let result = tokio::time::timeout(
Duration::from_secs(delegate_timeout_secs),
- provider.chat_with_system(
- agent_config.system_prompt.as_deref(),
- &full_prompt,
- &agent_config.model,
- temperature,
+ model.invoke(
+ &(),
+ ModelRequest::new(
+ agent_config
+ .system_prompt
+ .as_deref()
+ .map(Message::system)
+ .into_iter()
+ .chain(std::iter::once(Message::user(full_prompt)))
+ .collect(),
+ )
+ .with_model(agent_config.model.clone())
+ .with_temperature(temperature),
),
)
.await;
@@ -224,7 +225,7 @@ impl Tool for DelegateTool {
match result {
Ok(response) => {
- let mut rendered = response;
+ let mut rendered = response.text();
if rendered.trim().is_empty() {
rendered = "[Empty response]".to_string();
}
diff --git a/src/openhuman/agent/triage/evaluator.rs b/src/openhuman/agent/triage/evaluator.rs
index 096d22a32..351e95e89 100644
--- a/src/openhuman/agent/triage/evaluator.rs
+++ b/src/openhuman/agent/triage/evaluator.rs
@@ -464,9 +464,7 @@ async fn try_arm(
];
let request = AgentTurnRequest {
- turn_model_source: crate::openhuman::tinyagents::TurnModelSource::new(Arc::clone(
- &resolved.provider,
- )),
+ turn_model_source: resolved.turn_model_source.clone(),
history,
tools_registry: Arc::new(Vec::new()),
provider_name: resolved.provider_name.clone(),
diff --git a/src/openhuman/agent/triage/evaluator_tests.rs b/src/openhuman/agent/triage/evaluator_tests.rs
index a42289424..bfd9ea58e 100644
--- a/src/openhuman/agent/triage/evaluator_tests.rs
+++ b/src/openhuman/agent/triage/evaluator_tests.rs
@@ -252,7 +252,10 @@ impl Provider for NoopProvider {
fn cloud_arm() -> ResolvedProvider {
ResolvedProvider {
- provider: StdArc::new(NoopProvider) as StdArc,
+ turn_model_source: crate::openhuman::tinyagents::TurnModelSource::new(StdArc::new(
+ NoopProvider,
+ )
+ as StdArc),
provider_name: "stub-cloud".to_string(),
model: "stub-cloud-model".to_string(),
used_local: false,
@@ -261,7 +264,10 @@ fn cloud_arm() -> ResolvedProvider {
fn local_arm() -> ResolvedProvider {
ResolvedProvider {
- provider: StdArc::new(NoopProvider) as StdArc,
+ turn_model_source: crate::openhuman::tinyagents::TurnModelSource::new(StdArc::new(
+ NoopProvider,
+ )
+ as StdArc),
provider_name: "stub-local".to_string(),
model: "stub-local-model".to_string(),
used_local: true,
diff --git a/src/openhuman/agent/triage/routing.rs b/src/openhuman/agent/triage/routing.rs
index 9ba17a03c..db6ed9466 100644
--- a/src/openhuman/agent/triage/routing.rs
+++ b/src/openhuman/agent/triage/routing.rs
@@ -14,13 +14,13 @@ use std::sync::Arc;
use anyhow::Context;
use crate::openhuman::config::Config;
-use crate::openhuman::inference::provider::{self, Provider, INFERENCE_BACKEND_ID};
+use crate::openhuman::inference::provider::{self, INFERENCE_BACKEND_ID};
/// The concrete provider + metadata that [`crate::openhuman::agent::triage::evaluator::run_triage`]
/// should use for this particular triage turn.
pub struct ResolvedProvider {
- /// Ready-to-use provider, already constructed.
- pub provider: Arc,
+ /// Model source for this arm. Production sources are crate-native.
+ pub turn_model_source: crate::openhuman::tinyagents::TurnModelSource,
/// Provider name token — always `"openhuman"` (remote backend).
/// Kept for telemetry / observability compat with the previous two-path design.
pub provider_name: String,
@@ -59,15 +59,10 @@ pub async fn resolve_provider_with_config(config: &Config) -> anyhow::Result Option {
- use crate::openhuman::inference::provider::compatible::{AuthStyle, OpenAiCompatibleProvider};
-
let local_cfg = &config.local_ai;
if !local_cfg.runtime_enabled {
tracing::debug!("[triage::routing] local arm disabled (runtime_enabled=false)");
@@ -89,44 +84,28 @@ pub fn build_local_provider_with_config(config: &Config) -> Option = Arc::new(OpenAiCompatibleProvider::new(
- label,
- &base,
- local_api_key,
- auth_style,
- ));
tracing::debug!(
provider = %label,
model = %local_cfg.chat_model_id,
"[triage::routing] resolved local fallback provider"
);
Some(ResolvedProvider {
- provider,
+ turn_model_source:
+ crate::openhuman::tinyagents::TurnModelSource::new_crate_native_from_string(
+ "subconscious",
+ provider_string,
+ Arc::new(config.clone()),
+ ),
provider_name: label.to_string(),
model: local_cfg.chat_model_id.clone(),
used_local: true,
@@ -169,7 +148,7 @@ fn is_local_cli_route(provider_string: &str) -> bool {
fn build_remote_provider(config: &Config) -> anyhow::Result {
use crate::openhuman::inference::local::profile::is_local_provider_string;
use crate::openhuman::inference::provider::factory::{
- create_chat_provider_from_string, PROVIDER_OPENHUMAN,
+ create_chat_model_from_string_with_model_id, PROVIDER_OPENHUMAN,
};
let resolved = provider::provider_for_role("subconscious", config);
@@ -198,9 +177,12 @@ fn build_remote_provider(config: &Config) -> anyhow::Result {
// id via `make_openhuman_backend` → `managed_tier_for_role`, BYOK cloud routes
// via the slug's configured model.
let build = |provider_string: &str| -> anyhow::Result {
- let (provider_box, model) =
- create_chat_provider_from_string("subconscious", provider_string, config)?;
- let provider: Arc = Arc::from(provider_box);
+ let (_chat_model, model) = create_chat_model_from_string_with_model_id(
+ "subconscious",
+ provider_string,
+ config,
+ config.default_temperature,
+ )?;
let provider_name = if provider_string == PROVIDER_OPENHUMAN {
INFERENCE_BACKEND_ID.to_string()
} else {
@@ -211,7 +193,12 @@ fn build_remote_provider(config: &Config) -> anyhow::Result {
.to_string()
};
Ok(ResolvedProvider {
- provider,
+ turn_model_source:
+ crate::openhuman::tinyagents::TurnModelSource::new_crate_native_from_string(
+ "subconscious",
+ provider_string,
+ Arc::new(config.clone()),
+ ),
provider_name,
model,
used_local: false,
diff --git a/src/openhuman/channels/context.rs b/src/openhuman/channels/context.rs
index 3fbc2d41d..fef693361 100644
--- a/src/openhuman/channels/context.rs
+++ b/src/openhuman/channels/context.rs
@@ -29,7 +29,7 @@ pub(crate) type RouteSelectionMap = Arc>>,
- pub(crate) provider: Arc,
+ pub(crate) provider: Option>,
pub(crate) default_provider: Arc,
pub(crate) memory: Arc,
pub(crate) tools_registry: Arc>>,
@@ -51,6 +51,9 @@ pub(crate) struct ChannelRuntimeContext {
pub(crate) message_timeout_secs: u64,
pub(crate) multimodal: crate::openhuman::config::MultimodalConfig,
pub(crate) multimodal_files: crate::openhuman::config::MultimodalFileConfig,
+ /// Full config for building crate-native turn models (Phase 3 P3-B). `Some` in
+ /// production; `None` in tests keeps the channel turn on the `Provider` path.
+ pub(crate) config: Option>,
}
pub(crate) fn conversation_memory_key(msg: &super::traits::ChannelMessage) -> String {
@@ -281,7 +284,7 @@ mod tests {
fn runtime_context() -> ChannelRuntimeContext {
ChannelRuntimeContext {
channels_by_name: Arc::new(HashMap::new()),
- provider: Arc::new(DummyProvider),
+ provider: Some(Arc::new(DummyProvider)),
default_provider: Arc::new("default".into()),
memory: Arc::new(MockMemory {
entries: Vec::new(),
@@ -305,6 +308,7 @@ mod tests {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
}
}
diff --git a/src/openhuman/channels/routes.rs b/src/openhuman/channels/routes.rs
index 8e26a06aa..62e10ff89 100644
--- a/src/openhuman/channels/routes.rs
+++ b/src/openhuman/channels/routes.rs
@@ -171,7 +171,11 @@ pub(crate) async fn get_or_create_provider(
provider_name: &str,
) -> anyhow::Result> {
if provider_name == ctx.default_provider.as_str() {
- return Ok(Arc::clone(&ctx.provider));
+ return ctx
+ .provider
+ .as_ref()
+ .map(Arc::clone)
+ .ok_or_else(|| anyhow::anyhow!("no injected channel provider for '{provider_name}'"));
}
if let Some(existing) = ctx
@@ -184,30 +188,9 @@ pub(crate) async fn get_or_create_provider(
return Ok(existing);
}
- let (inference_url, backend_url) = if provider_name == ctx.default_provider.as_str() {
- (ctx.inference_url.as_deref(), ctx.api_url.as_deref())
- } else {
- (None, None)
- };
-
- let provider = provider::create_resilient_provider_with_options(
- inference_url,
- backend_url,
- None,
- &ctx.reliability,
- &ctx.provider_runtime_options,
- )?;
- let provider: Arc = Arc::from(provider);
-
- if let Err(err) = provider.warmup().await {
- tracing::warn!(provider = provider_name, "Provider warmup failed: {err}");
- }
-
- let mut cache = ctx.provider_cache.lock().unwrap_or_else(|e| e.into_inner());
- let cached = cache
- .entry(provider_name.to_string())
- .or_insert_with(|| Arc::clone(&provider));
- Ok(Arc::clone(cached))
+ anyhow::bail!(
+ "no injected channel provider for '{provider_name}'; production routes use crate-native model sources"
+ )
}
fn build_models_help_response(current: &ChannelRouteSelection, workspace_dir: &Path) -> String {
@@ -291,26 +274,21 @@ pub(crate) async fn handle_runtime_command_if_needed(
ChannelRuntimeCommand::ShowProviders => build_providers_help_response(¤t),
ChannelRuntimeCommand::SetProvider(raw_provider) => {
match resolve_provider_alias(&raw_provider) {
- Some(provider_name) => match get_or_create_provider(ctx, &provider_name).await {
- Ok(_) => {
- if provider_name != current.provider {
- current.provider = provider_name.clone();
- set_route_selection(ctx, &sender_key, current.clone());
- clear_sender_history(ctx, &sender_key);
- }
-
- format!(
- "Provider switched to `{provider_name}` for this sender session. Current model is `{}`.\nUse `/model ` to set a provider-compatible model.",
- current.model
- )
+ Some(provider_name) => {
+ tracing::debug!(
+ provider = %provider_name,
+ "[channels] validated crate-native provider route from catalog"
+ );
+ if provider_name != current.provider {
+ current.provider = provider_name.clone();
+ set_route_selection(ctx, &sender_key, current.clone());
+ clear_sender_history(ctx, &sender_key);
}
- Err(err) => {
- let safe_err = provider::sanitize_api_error(&err.to_string());
- format!(
- "Failed to initialize provider `{provider_name}`. Route unchanged.\nDetails: {safe_err}"
- )
- }
- },
+ format!(
+ "Provider switched to `{provider_name}` for this sender session. Current model is `{}`.\nUse `/model ` to set a provider-compatible model.",
+ current.model
+ )
+ }
None => format!(
"Unknown provider `{raw_provider}`. Use `/models` to list valid providers."
),
diff --git a/src/openhuman/channels/routes_tests.rs b/src/openhuman/channels/routes_tests.rs
index 3d1c651a1..76065c518 100644
--- a/src/openhuman/channels/routes_tests.rs
+++ b/src/openhuman/channels/routes_tests.rs
@@ -133,7 +133,7 @@ impl Channel for RecordingChannel {
fn runtime_context(workspace_dir: PathBuf) -> ChannelRuntimeContext {
ChannelRuntimeContext {
channels_by_name: Arc::new(HashMap::new()),
- provider: Arc::new(DummyProvider),
+ provider: Some(Arc::new(DummyProvider)),
default_provider: Arc::new("openai".into()),
memory: Arc::new(DummyMemory),
tools_registry: Arc::new(vec![Box::new(DummyTool) as Box]),
@@ -155,6 +155,7 @@ fn runtime_context(workspace_dir: PathBuf) -> ChannelRuntimeContext {
message_timeout_secs: 60,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
}
}
diff --git a/src/openhuman/channels/runtime/dispatch/processor.rs b/src/openhuman/channels/runtime/dispatch/processor.rs
index 109a49d66..d393109ed 100644
--- a/src/openhuman/channels/runtime/dispatch/processor.rs
+++ b/src/openhuman/channels/runtime/dispatch/processor.rs
@@ -229,33 +229,37 @@ pub(crate) async fn process_channel_runtime_message(
let history_key = conversation_history_key(&msg);
let route = get_route_selection(ctx.as_ref(), &history_key);
- let active_provider = match get_or_create_provider(ctx.as_ref(), &route.provider).await {
- Ok(provider) => provider,
- Err(err) => {
- crate::core::observability::report_error(
- &err,
- "channels",
- "provider_init",
- &[
- ("channel", msg.channel.as_str()),
- ("provider", route.provider.as_str()),
- ],
- );
- let safe_err = provider::sanitize_api_error(&err.to_string());
- let message = format!(
+ let active_provider = if ctx.config.is_none() {
+ match get_or_create_provider(ctx.as_ref(), &route.provider).await {
+ Ok(provider) => Some(provider),
+ Err(err) => {
+ crate::core::observability::report_error(
+ &err,
+ "channels",
+ "provider_init",
+ &[
+ ("channel", msg.channel.as_str()),
+ ("provider", route.provider.as_str()),
+ ],
+ );
+ let safe_err = provider::sanitize_api_error(&err.to_string());
+ let message = format!(
"⚠️ Failed to initialize provider `{}`. Please run `/models` to choose another provider.\nDetails: {safe_err}",
route.provider
);
- if let Some(channel) = target_channel.as_ref() {
- let _ = channel
- .send_with_outbound_intent(
- &SendMessage::new(message, &msg.reply_target)
- .in_thread(msg.thread_ts.clone()),
- )
- .await;
+ if let Some(channel) = target_channel.as_ref() {
+ let _ = channel
+ .send_with_outbound_intent(
+ &SendMessage::new(message, &msg.reply_target)
+ .in_thread(msg.thread_ts.clone()),
+ )
+ .await;
+ }
+ return;
}
- return;
}
+ } else {
+ None
};
let memory_context =
@@ -459,13 +463,24 @@ pub(crate) async fn process_channel_runtime_message(
};
let turn_request = AgentTurnRequest {
- // Wrap the channel's cached provider into the seam turn-model source at
- // the bus boundary (issue #4249, Phase 3 / Motion A) so the harness holds
- // crate model types only. The channel provider cache stays provider-typed
- // (a producer concern) until Motion B swaps in crate-native clients.
- turn_model_source: crate::openhuman::tinyagents::TurnModelSource::new(Arc::clone(
- &active_provider,
- )),
+ // Crate-native channel turn models (Phase 3 P3-B): when the runtime carries
+ // the full config, build crate `ChatModel`s from `("chat", route.provider,
+ // config)` — `route.provider` is the effective provider string. Tests (no
+ // `config`) stay on the injected `Provider` path.
+ turn_model_source: match &ctx.config {
+ Some(cfg) => {
+ crate::openhuman::tinyagents::TurnModelSource::new_crate_native_from_string(
+ "chat",
+ route.provider.clone(),
+ cfg.clone(),
+ )
+ }
+ None => crate::openhuman::tinyagents::TurnModelSource::new(Arc::clone(
+ active_provider
+ .as_ref()
+ .expect("test channel context must inject a provider"),
+ )),
+ },
history: std::mem::take(&mut history),
tools_registry: Arc::clone(&ctx.tools_registry),
provider_name: route.provider.clone(),
diff --git a/src/openhuman/channels/runtime/startup.rs b/src/openhuman/channels/runtime/startup.rs
index d30d79143..751493b81 100644
--- a/src/openhuman/channels/runtime/startup.rs
+++ b/src/openhuman/channels/runtime/startup.rs
@@ -30,7 +30,7 @@ use crate::openhuman::channels::yuanbao::YuanbaoChannel;
use crate::openhuman::channels::Channel;
use crate::openhuman::config::Config;
use crate::openhuman::context::channels_prompt::build_system_prompt;
-use crate::openhuman::inference::provider::{self, Provider};
+use crate::openhuman::inference::provider;
use crate::openhuman::memory::Memory;
use crate::openhuman::memory_store;
use crate::openhuman::security::SecurityPolicy;
@@ -289,42 +289,32 @@ pub async fn start_channels(mut config: Config) -> Result<()> {
secrets_encrypt: config.secrets.encrypt,
reasoning_enabled: config.runtime.reasoning_enabled,
};
- let (provider, model, provider_name): (Arc, String, String) =
- match resolve_chat_workload(&config) {
- ChatWorkloadResolution::Cloud => {
- let p: Arc =
- Arc::from(provider::create_intelligent_routing_provider(
- config.inference_url.as_deref(),
- config.api_url.as_deref(),
- config.api_key.as_deref(),
- &config,
- &provider_runtime_options,
- )?);
- let m = config
- .default_model
- .clone()
- .unwrap_or_else(|| crate::openhuman::config::DEFAULT_MODEL.into());
- (p, m, provider::INFERENCE_BACKEND_ID.to_string())
- }
- ChatWorkloadResolution::Workload {
- provider_string,
- slug,
- } => {
- tracing::info!(
- chat_provider = %provider_string,
- slug = %slug,
- "[channels][startup] chat workload routed to per-workload provider — building dedicated channel provider"
- );
- let (boxed, model_id) = provider::create_chat_provider("chat", &config)?;
- (Arc::from(boxed), model_id, slug)
- }
- };
-
- // Warm up the provider connection pool (TLS handshake, DNS, HTTP/2 setup)
- // so the first real message doesn't hit a cold-start timeout.
- if let Err(e) = provider.warmup().await {
- tracing::warn!("Provider warmup failed (non-fatal): {e}");
- }
+ let (model, provider_name) = match resolve_chat_workload(&config) {
+ ChatWorkloadResolution::Cloud => {
+ let (_chat, model) = provider::create_chat_model_with_model_id(
+ "chat",
+ &config,
+ config.default_temperature,
+ )?;
+ (model, provider::INFERENCE_BACKEND_ID.to_string())
+ }
+ ChatWorkloadResolution::Workload {
+ provider_string,
+ slug,
+ } => {
+ tracing::info!(
+ chat_provider = %provider_string,
+ slug = %slug,
+ "[channels][startup] chat workload routed to per-workload provider — building dedicated channel provider"
+ );
+ let (_chat, model_id) = provider::create_chat_model_with_model_id(
+ "chat",
+ &config,
+ config.default_temperature,
+ )?;
+ (model_id, slug)
+ }
+ };
let runtime: Arc = Arc::from(host_runtime::create_runtime(
&config.runtime,
@@ -905,14 +895,12 @@ pub async fn start_channels(mut config: Config) -> Result<()> {
println!(" 🚦 In-flight message limit: {max_in_flight_messages}");
- let mut provider_cache_seed: HashMap> = HashMap::new();
- provider_cache_seed.insert(provider_name.clone(), Arc::clone(&provider));
let message_timeout_secs =
effective_channel_message_timeout_secs(config.channels_config.message_timeout_secs);
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name,
- provider: Arc::clone(&provider),
+ provider: None,
default_provider: Arc::new(provider_name),
memory: Arc::clone(&mem),
tools_registry: Arc::clone(&tools_registry),
@@ -923,7 +911,7 @@ pub async fn start_channels(mut config: Config) -> Result<()> {
max_tool_iterations: config.agent.max_tool_iterations,
min_relevance_score: config.memory.min_relevance_score,
conversation_histories: Arc::new(Mutex::new(HashMap::new())),
- provider_cache: Arc::new(Mutex::new(provider_cache_seed)),
+ provider_cache: Arc::new(Mutex::new(HashMap::new())),
route_overrides: Arc::new(Mutex::new(HashMap::new())),
api_url: config.api_url.clone(),
inference_url: config.inference_url.clone(),
@@ -933,6 +921,8 @@ pub async fn start_channels(mut config: Config) -> Result<()> {
message_timeout_secs,
multimodal: config.multimodal.clone(),
multimodal_files: config.multimodal_files.clone(),
+ // Crate-native turn models for the channel turn (Phase 3 P3-B).
+ config: Some(std::sync::Arc::new(config.clone())),
});
run_message_dispatch_loop(rx, runtime_ctx, max_in_flight_messages).await;
diff --git a/src/openhuman/channels/runtime/test_support.rs b/src/openhuman/channels/runtime/test_support.rs
index d14975d49..1da2c4a9a 100644
--- a/src/openhuman/channels/runtime/test_support.rs
+++ b/src/openhuman/channels/runtime/test_support.rs
@@ -420,7 +420,7 @@ pub async fn run_dispatch_harness(options: DispatchHarnessOptions) -> DispatchHa
let ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider,
+ provider: Some(provider),
default_provider: Arc::new("harness-provider".to_string()),
memory: Arc::new(HarnessMemory {
entries: options
@@ -447,6 +447,7 @@ pub async fn run_dispatch_harness(options: DispatchHarnessOptions) -> DispatchHa
message_timeout_secs: options.timeout_secs,
multimodal: MultimodalConfig::default(),
multimodal_files: MultimodalFileConfig::default(),
+ config: None,
});
let expected_event_channel = options.channel_name.clone();
diff --git a/src/openhuman/channels/tests/context.rs b/src/openhuman/channels/tests/context.rs
index 67ab5517c..3543c4e42 100644
--- a/src/openhuman/channels/tests/context.rs
+++ b/src/openhuman/channels/tests/context.rs
@@ -1,4 +1,3 @@
-use super::common::DummyProvider;
use super::super::context::{
compact_sender_history, conversation_history_key, effective_channel_message_timeout_secs,
is_context_window_overflow_error, should_skip_memory_context_entry, ChannelRuntimeContext,
@@ -6,6 +5,7 @@ use super::super::context::{
CHANNEL_MESSAGE_TIMEOUT_SECS, MIN_CHANNEL_MESSAGE_TIMEOUT_SECS,
};
use super::super::traits;
+use super::common::DummyProvider;
use crate::openhuman::inference::provider::ChatMessage;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
@@ -30,8 +30,7 @@ fn context_window_overflow_error_detector_matches_known_messages() {
);
assert!(is_context_window_overflow_error(&overflow_err));
- let other_err =
- anyhow::anyhow!("OpenAI Codex API error (502 Bad Gateway): error code: 502");
+ let other_err = anyhow::anyhow!("OpenAI Codex API error (502 Bad Gateway): error code: 502");
assert!(!is_context_window_overflow_error(&other_err));
}
@@ -64,7 +63,7 @@ fn compact_sender_history_keeps_recent_truncated_messages() {
let ctx = ChannelRuntimeContext {
channels_by_name: Arc::new(HashMap::new()),
- provider: Arc::new(DummyProvider),
+ provider: Some(Arc::new(DummyProvider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(super::common::NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -82,7 +81,9 @@ fn compact_sender_history_keeps_recent_truncated_messages() {
reliability: Arc::new(crate::openhuman::config::ReliabilityConfig::default()),
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
- provider_runtime_options: crate::openhuman::inference::provider::ProviderRuntimeOptions::default(),
+ config: None,
+ provider_runtime_options:
+ crate::openhuman::inference::provider::ProviderRuntimeOptions::default(),
workspace_dir: Arc::new(std::env::temp_dir()),
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
};
@@ -129,8 +130,14 @@ fn telegram_history_key_is_thread_ts_agnostic() {
let key_a = conversation_history_key(&with_thread);
let key_b = conversation_history_key(&other_thread);
- assert_eq!(key_base, key_a, "telegram: thread_ts must not change history key");
- assert_eq!(key_a, key_b, "telegram: different thread_ts must share history key");
+ assert_eq!(
+ key_base, key_a,
+ "telegram: thread_ts must not change history key"
+ );
+ assert_eq!(
+ key_a, key_b,
+ "telegram: different thread_ts must share history key"
+ );
}
/// For every other channel (e.g. Slack, Discord), thread_ts splits conversation
diff --git a/src/openhuman/channels/tests/discord_integration.rs b/src/openhuman/channels/tests/discord_integration.rs
index f8ce7050d..98d2e2e54 100644
--- a/src/openhuman/channels/tests/discord_integration.rs
+++ b/src/openhuman/channels/tests/discord_integration.rs
@@ -118,7 +118,7 @@ fn make_discord_ctx(
Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels),
- provider,
+ provider: Some(provider),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -140,6 +140,7 @@ fn make_discord_ctx(
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
})
}
diff --git a/src/openhuman/channels/tests/memory.rs b/src/openhuman/channels/tests/memory.rs
index f255c6d9e..7f0b14426 100644
--- a/src/openhuman/channels/tests/memory.rs
+++ b/src/openhuman/channels/tests/memory.rs
@@ -138,7 +138,7 @@ async fn process_channel_message_restores_per_sender_history_on_follow_ups() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: provider_impl.clone(),
+ provider: Some(provider_impl.clone()),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -159,6 +159,7 @@ async fn process_channel_message_restores_per_sender_history_on_follow_ups() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
@@ -222,7 +223,7 @@ async fn process_channel_message_uses_autosaved_memory_after_history_is_cleared(
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: provider_impl.clone(),
+ provider: Some(provider_impl.clone()),
default_provider: Arc::new("test-provider".to_string()),
memory,
tools_registry: Arc::new(vec![]),
@@ -243,6 +244,7 @@ async fn process_channel_message_uses_autosaved_memory_after_history_is_cleared(
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
let first = traits::ChannelMessage {
diff --git a/src/openhuman/channels/tests/runtime_dispatch.rs b/src/openhuman/channels/tests/runtime_dispatch.rs
index 25051f203..d2811923d 100644
--- a/src/openhuman/channels/tests/runtime_dispatch.rs
+++ b/src/openhuman/channels/tests/runtime_dispatch.rs
@@ -116,9 +116,9 @@ async fn message_dispatch_processes_messages_in_parallel() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(SlowProvider {
+ provider: Some(Arc::new(SlowProvider {
delay: Duration::from_millis(5),
- }),
+ })),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -139,6 +139,7 @@ async fn message_dispatch_processes_messages_in_parallel() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
(channel_impl, runtime_ctx)
@@ -188,9 +189,9 @@ async fn process_channel_message_cancels_scoped_typing_task() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(SlowProvider {
+ provider: Some(Arc::new(SlowProvider {
delay: Duration::from_millis(20),
- }),
+ })),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -211,6 +212,7 @@ async fn process_channel_message_cancels_scoped_typing_task() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
@@ -277,7 +279,7 @@ async fn dispatch_routes_through_agent_run_turn_bus_handler() {
channels_by_name: Arc::new(channels_by_name),
// Still need a Provider for the Arc field, but the stubbed bus
// handler never invokes it — so a minimal no-op is fine.
- provider: Arc::new(super::common::DummyProvider),
+ provider: Some(Arc::new(super::common::DummyProvider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -298,6 +300,7 @@ async fn dispatch_routes_through_agent_run_turn_bus_handler() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
@@ -359,7 +362,7 @@ async fn channel_processed_event_records_resolved_agent_route() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(super::common::DummyProvider),
+ provider: Some(Arc::new(super::common::DummyProvider)),
default_provider: Arc::new("requested-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -380,6 +383,7 @@ async fn channel_processed_event_records_resolved_agent_route() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
@@ -470,7 +474,7 @@ async fn process_channel_message_hardens_multimodal_files_against_smuggled_marke
};
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(super::common::DummyProvider),
+ provider: Some(Arc::new(super::common::DummyProvider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -491,6 +495,7 @@ async fn process_channel_message_hardens_multimodal_files_against_smuggled_marke
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: permissive_operator_default,
+ config: None,
});
// Attacker-shaped message: an absolute-path FILE marker dropped
@@ -552,7 +557,7 @@ async fn process_channel_message_hardens_against_relative_path_markers() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(super::common::DummyProvider),
+ provider: Some(Arc::new(super::common::DummyProvider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -573,6 +578,7 @@ async fn process_channel_message_hardens_against_relative_path_markers() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
diff --git a/src/openhuman/channels/tests/runtime_tool_calls.rs b/src/openhuman/channels/tests/runtime_tool_calls.rs
index 257eda678..eb380cc1c 100644
--- a/src/openhuman/channels/tests/runtime_tool_calls.rs
+++ b/src/openhuman/channels/tests/runtime_tool_calls.rs
@@ -23,7 +23,7 @@ async fn process_channel_message_executes_tool_calls_instead_of_sending_raw_json
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(ToolCallingProvider),
+ provider: Some(Arc::new(ToolCallingProvider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![Box::new(MockPriceTool)]),
@@ -44,6 +44,7 @@ async fn process_channel_message_executes_tool_calls_instead_of_sending_raw_json
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
@@ -79,7 +80,7 @@ async fn process_channel_message_executes_tool_calls_with_alias_tags() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(ToolCallingAliasProvider),
+ provider: Some(Arc::new(ToolCallingAliasProvider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![Box::new(MockPriceTool)]),
@@ -100,6 +101,7 @@ async fn process_channel_message_executes_tool_calls_with_alias_tags() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
@@ -144,7 +146,7 @@ async fn process_channel_message_handles_models_command_without_llm_call() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::clone(&default_provider),
+ provider: Some(Arc::clone(&default_provider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -165,6 +167,7 @@ async fn process_channel_message_handles_models_command_without_llm_call() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
let cmd_msg = traits::ChannelMessage {
@@ -236,7 +239,7 @@ async fn process_channel_message_uses_route_override_provider_and_model() {
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::clone(&default_provider),
+ provider: Some(Arc::clone(&default_provider)),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -257,6 +260,7 @@ async fn process_channel_message_uses_route_override_provider_and_model() {
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(runtime_ctx, routed_msg).await;
@@ -284,9 +288,9 @@ async fn process_channel_message_respects_configured_max_tool_iterations_above_d
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(IterativeToolProvider {
+ provider: Some(Arc::new(IterativeToolProvider {
required_tool_iterations: 11,
- }),
+ })),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![Box::new(MockPriceTool)]),
@@ -307,6 +311,7 @@ async fn process_channel_message_respects_configured_max_tool_iterations_above_d
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
@@ -341,9 +346,9 @@ async fn process_channel_message_reports_configured_max_tool_iterations_limit()
let runtime_ctx = Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels_by_name),
- provider: Arc::new(IterativeToolProvider {
+ provider: Some(Arc::new(IterativeToolProvider {
required_tool_iterations: 20,
- }),
+ })),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![Box::new(MockPriceTool)]),
@@ -364,6 +369,7 @@ async fn process_channel_message_reports_configured_max_tool_iterations_limit()
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
});
process_channel_message(
diff --git a/src/openhuman/channels/tests/telegram_integration.rs b/src/openhuman/channels/tests/telegram_integration.rs
index 11811cffb..c78bf2fd0 100644
--- a/src/openhuman/channels/tests/telegram_integration.rs
+++ b/src/openhuman/channels/tests/telegram_integration.rs
@@ -94,7 +94,7 @@ fn make_test_context(
Arc::new(ChannelRuntimeContext {
channels_by_name: Arc::new(channels),
- provider,
+ provider: Some(provider),
default_provider: Arc::new("test-provider".to_string()),
memory: Arc::new(NoopMemory),
tools_registry: Arc::new(vec![]),
@@ -116,6 +116,7 @@ fn make_test_context(
message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,
multimodal: crate::openhuman::config::MultimodalConfig::default(),
multimodal_files: crate::openhuman::config::MultimodalFileConfig::default(),
+ config: None,
})
}
diff --git a/src/openhuman/inference/http/server.rs b/src/openhuman/inference/http/server.rs
index 592384492..c9bbac49b 100644
--- a/src/openhuman/inference/http/server.rs
+++ b/src/openhuman/inference/http/server.rs
@@ -31,11 +31,13 @@ use axum::{extract::State, Json, Router};
use futures_util::stream::{self, StreamExt};
use serde_json::json;
use std::collections::HashSet;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use tinyagents::harness::model::{ModelRequest, ModelStreamItem};
use tracing::{debug, error};
use crate::core::types::AppState;
use crate::openhuman::config::Config;
-use crate::openhuman::inference::provider;
use crate::openhuman::inference::provider::traits::ChatMessage;
use super::types::{
@@ -93,21 +95,23 @@ async fn chat_completions_handler(
format!("ollama:{}", req.model)
};
- let (provider_box, model_id) = match provider::factory::create_chat_provider_from_string(
- "agentic",
- &provider_string,
- &config,
- ) {
- Ok(pair) => pair,
- Err(e) => {
- error!("{LOG_PREFIX} chat_completions: provider build failed: {e}");
- return (
+ let (chat_model, model_id) =
+ match crate::openhuman::inference::provider::create_chat_model_from_string_with_model_id(
+ "agentic",
+ &provider_string,
+ &config,
+ req.temperature.unwrap_or(config.default_temperature),
+ ) {
+ Ok(pair) => pair,
+ Err(e) => {
+ error!("{LOG_PREFIX} chat_completions: provider build failed: {e}");
+ return (
StatusCode::BAD_REQUEST,
Json(json!({ "error": { "message": format!("provider error: {e}"), "type": "invalid_request_error" }})),
)
.into_response();
- }
- };
+ }
+ };
// Map request messages to provider ChatMessage type.
let messages: Vec = req
@@ -142,28 +146,59 @@ async fn chat_completions_handler(
let completion_id = format!("chatcmpl-{}", uuid::Uuid::new_v4());
let created = chrono::Utc::now().timestamp();
let model_name = req.model.clone();
+ let model_request = ModelRequest::new(
+ messages
+ .iter()
+ .map(crate::openhuman::tinyagents::chat_message_to_message)
+ .collect(),
+ )
+ .with_model(model_id.clone())
+ .with_temperature(temperature);
if req.stream {
- // Streaming response via SSE
- let options = provider::traits::StreamOptions::new(true);
- let stream =
- provider_box.stream_chat_with_history(&messages, &model_id, temperature, options);
+ let model_stream = match chat_model.stream(&(), model_request).await {
+ Ok(stream) => stream,
+ Err(e) => {
+ error!(error = %e, model = %model_id, "{LOG_PREFIX} chat_completions: stream start failed");
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(json!({ "error": { "message": format!("inference error: {e}"), "type": "internal_error" }})),
+ )
+ .into_response();
+ }
+ };
let cid = completion_id.clone();
let model_clone = model_name.clone();
- let event_stream = stream
- .enumerate()
- .map(move |(i, chunk_result)| {
+ let first_delta = Arc::new(AtomicBool::new(true));
+ let event_stream = model_stream
+ .filter_map(move |item| {
let cid = cid.clone();
let model_clone = model_clone.clone();
- match chunk_result {
- Ok(chunk) => {
- let finish_reason = if chunk.is_final { Some("stop") } else { None };
- let content = if chunk.delta.is_empty() && chunk.is_final {
- None
- } else {
- Some(chunk.delta)
- };
+ let first_delta = Arc::clone(&first_delta);
+ async move {
+ let (content, finish_reason) = match item {
+ ModelStreamItem::MessageDelta(delta) if !delta.text.is_empty() => {
+ (Some(delta.text), None)
+ }
+ ModelStreamItem::Completed(_) => (None, Some("stop")),
+ ModelStreamItem::Failed(message) => {
+ let body = json!({"error": {"message": message, "type": "stream_error"}});
+ return Some(Ok::(
+ Event::default().data(body.to_string()),
+ ));
+ }
+ ModelStreamItem::ProviderFailed(error) => {
+ let body = json!({"error": {"message": error.message, "type": "stream_error"}});
+ return Some(Ok::(
+ Event::default().data(body.to_string()),
+ ));
+ }
+ _ => return None,
+ };
+ let role = first_delta
+ .swap(false, Ordering::Relaxed)
+ .then(|| "assistant".to_string());
let sse_chunk = ChatCompletionChunk {
id: cid,
object: "chat.completion.chunk",
@@ -172,11 +207,7 @@ async fn chat_completions_handler(
choices: vec![ChatCompletionChunkChoice {
index: 0,
delta: ChatCompletionDelta {
- role: if i == 0 {
- Some("assistant".to_string())
- } else {
- None
- },
+ role,
content,
},
finish_reason,
@@ -184,15 +215,9 @@ async fn chat_completions_handler(
};
let data =
serde_json::to_string(&sse_chunk).unwrap_or_else(|_| "{}".to_string());
- Ok::(Event::default().data(data))
- }
- Err(e) => {
- let err_event = json!({
- "error": { "message": e.to_string(), "type": "stream_error" }
- });
- Ok(Event::default()
- .data(serde_json::to_string(&err_event).unwrap_or_default()))
- }
+ Some(Ok::(
+ Event::default().data(data),
+ ))
}
})
.chain(stream::once(async {
@@ -205,13 +230,10 @@ async fn chat_completions_handler(
.into_response();
}
- // Non-streaming: call chat_with_history
- match provider_box
- .chat_with_history(&messages, &model_id, temperature)
- .await
- {
- Ok(content) => {
+ match chat_model.invoke(&(), model_request).await {
+ Ok(model_response) => {
debug!("{LOG_PREFIX} chat_completions: non-streaming ok");
+ let usage = model_response.usage.unwrap_or_default();
let response = ChatCompletionResponse {
id: completion_id,
object: "chat.completion",
@@ -221,14 +243,14 @@ async fn chat_completions_handler(
index: 0,
message: ChatCompletionMessage {
role: "assistant".to_string(),
- content,
+ content: model_response.text(),
},
finish_reason: "stop",
}],
usage: ChatCompletionUsage {
- prompt_tokens: 0,
- completion_tokens: 0,
- total_tokens: 0,
+ prompt_tokens: usage.input_tokens,
+ completion_tokens: usage.output_tokens,
+ total_tokens: usage.total_tokens,
},
};
(StatusCode::OK, Json(response)).into_response()
diff --git a/src/openhuman/inference/local/lm_studio.rs b/src/openhuman/inference/local/lm_studio.rs
index 511616d1f..cf5317402 100644
--- a/src/openhuman/inference/local/lm_studio.rs
+++ b/src/openhuman/inference/local/lm_studio.rs
@@ -7,6 +7,23 @@
use crate::openhuman::config::{Config, LocalAiConfig};
use serde::{Deserialize, Serialize};
+fn strip_think_tags(input: &str) -> String {
+ let mut result = String::with_capacity(input.len());
+ let mut rest = input;
+ loop {
+ let Some(start) = rest.find("") else {
+ result.push_str(rest);
+ break;
+ };
+ result.push_str(&rest[..start]);
+ let Some(end) = rest[start..].find("") else {
+ break;
+ };
+ rest = &rest[start + end + "".len()..];
+ }
+ result.trim().to_string()
+}
+
pub(crate) const DEFAULT_LM_STUDIO_BASE_URL: &str = "http://localhost:1234/v1";
pub(crate) fn lm_studio_base_url(config: &Config) -> String {
@@ -198,7 +215,7 @@ impl LmStudioChatResponseMessage {
let content = self
.content
.as_deref()
- .map(crate::openhuman::inference::provider::compatible_parse::strip_think_tags)
+ .map(strip_think_tags)
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
.unwrap_or_default();
@@ -214,7 +231,7 @@ impl LmStudioChatResponseMessage {
let reasoning = self
.reasoning_content
.as_deref()
- .map(crate::openhuman::inference::provider::compatible_parse::strip_think_tags)
+ .map(strip_think_tags)
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
.unwrap_or_default();
diff --git a/src/openhuman/inference/local/mod.rs b/src/openhuman/inference/local/mod.rs
index 2943c2fc4..a64370069 100644
--- a/src/openhuman/inference/local/mod.rs
+++ b/src/openhuman/inference/local/mod.rs
@@ -41,9 +41,7 @@ mod ollama;
pub(crate) mod process_util;
pub mod profile;
pub(crate) mod provider;
-pub(crate) use ollama::{
- ollama_base_url, ollama_base_url_from_config, validate_ollama_url, OLLAMA_BASE_URL,
-};
+pub(crate) use ollama::{ollama_base_url, ollama_base_url_from_config, validate_ollama_url};
pub mod service;
pub(crate) mod voice_install_common;
diff --git a/src/openhuman/inference/local/ollama.rs b/src/openhuman/inference/local/ollama.rs
index 799c6645e..e2d8462ab 100644
--- a/src/openhuman/inference/local/ollama.rs
+++ b/src/openhuman/inference/local/ollama.rs
@@ -218,10 +218,6 @@ pub(crate) fn redact_ollama_base_url(raw: &str) -> String {
.unwrap_or_else(|_| "".to_string())
}
-/// Back-compat constant kept at its original value for callers that
-/// reference it directly. New callers should use [`ollama_base_url`].
-pub(crate) const OLLAMA_BASE_URL: &str = DEFAULT_OLLAMA_BASE_URL;
-
#[derive(Debug, Serialize)]
pub(crate) struct OllamaPullRequest {
pub name: String,
diff --git a/src/openhuman/inference/local/ops.rs b/src/openhuman/inference/local/ops.rs
index 8a5f62f40..8315fc3be 100644
--- a/src/openhuman/inference/local/ops.rs
+++ b/src/openhuman/inference/local/ops.rs
@@ -10,7 +10,6 @@ use crate::openhuman::agent::Agent;
use crate::openhuman::config::Config;
use crate::openhuman::inference::local as local_ai;
use crate::openhuman::inference::provider as providers;
-use crate::openhuman::inference::provider::ops::ProviderRuntimeOptions;
use crate::openhuman::inference::{
LocalAiAssetsStatus, LocalAiDownloadsProgress, LocalAiEmbeddingResult, LocalAiSpeechResult,
LocalAiStatus, LocalAiTtsResult,
@@ -148,29 +147,25 @@ pub async fn agent_chat_simple(
.clone()
.unwrap_or_else(|| crate::openhuman::config::DEFAULT_MODEL.to_string());
- let options = ProviderRuntimeOptions {
- auth_profile_override: None,
- openhuman_dir: effective.config_path.parent().map(std::path::PathBuf::from),
- secrets_encrypt: effective.secrets.encrypt,
- reasoning_enabled: effective.runtime.reasoning_enabled,
- };
-
- let provider = providers::create_routed_provider_with_options(
- config.inference_url.as_deref(),
- config.api_url.as_deref(),
- config.api_key.as_deref(),
- &effective.reliability,
- &effective.model_routes,
- default_model.as_str(),
- &options,
+ let (model, resolved_model) = providers::create_chat_model_with_model_id(
+ "chat",
+ &effective,
+ effective.default_temperature,
)
.map_err(|e| e.to_string())?;
-
- let run = provider.chat_with_system(
- None,
- message,
- default_model.as_str(),
- effective.default_temperature,
+ tracing::debug!(
+ requested_model = %default_model,
+ resolved_model = %resolved_model,
+ temperature = effective.default_temperature,
+ "[inference] agent_chat_simple invoking crate-native chat model"
+ );
+ let run = model.invoke(
+ &(),
+ tinyagents::harness::model::ModelRequest::new(vec![
+ tinyagents::harness::message::Message::user(message.to_string()),
+ ])
+ .with_model(default_model.clone())
+ .with_temperature(effective.default_temperature),
);
let response = match thread_id.as_deref() {
Some(id) if !id.trim().is_empty() => {
@@ -182,7 +177,8 @@ pub async fn agent_chat_simple(
run.await
}
}
- .map_err(|e| e.to_string())?;
+ .map_err(|e| e.to_string())?
+ .text();
Ok(RpcOutcome::single_log(
response,
diff --git a/src/openhuman/inference/ops.rs b/src/openhuman/inference/ops.rs
index 708801cc8..852a9d342 100644
--- a/src/openhuman/inference/ops.rs
+++ b/src/openhuman/inference/ops.rs
@@ -9,6 +9,8 @@ use crate::openhuman::inference::{device, presets, sentiment, SentimentResult};
use crate::openhuman::inference::{LocalAiEmbeddingResult, LocalAiStatus};
use crate::rpc::RpcOutcome;
use serde_json::{json, Value};
+use tinyagents::harness::message::Message;
+use tinyagents::harness::model::ModelRequest;
use tracing::{debug, error, warn};
const LOG_PREFIX: &str = "[inference::ops]";
@@ -144,42 +146,47 @@ pub async fn inference_test_provider_model(
prompt_len = prompt.len(),
"{LOG_PREFIX} test_provider_model:start"
);
- let result =
- if provider.trim().starts_with("lmstudio:") || provider.trim().starts_with("ollama:") {
- log::debug!("{LOG_PREFIX} test_provider_model: routing to local provider={provider}");
- let (chat_provider, model) =
- crate::openhuman::inference::provider::factory::create_local_chat_provider_from_string(
- provider, config,
+ let local = provider.trim().starts_with("lmstudio:")
+ || provider.trim().starts_with("ollama:")
+ || provider.trim().starts_with("mlx:")
+ || provider.trim().starts_with("omlx:")
+ || provider.trim().starts_with("local-openai:");
+ let (chat_model, model) = if local {
+ debug!(
+ provider,
+ "{LOG_PREFIX} test_provider_model:build_local_model"
+ );
+ crate::openhuman::inference::provider::factory::create_local_chat_model_from_string(
+ provider, config,
+ )
+ } else {
+ debug!(provider, "{LOG_PREFIX} test_provider_model:build_model");
+ crate::openhuman::inference::provider::create_chat_model_from_string_with_model_id(
+ workload,
+ provider,
+ config,
+ config.default_temperature,
+ )
+ }
+ .map_err(|e| e.to_string())?;
+ debug!(%model, local, "{LOG_PREFIX} test_provider_model:invoke");
+ let result = chat_model
+ .invoke(
+ &(),
+ ModelRequest::new(vec![Message::user(prompt)])
+ .with_model(model)
+ .with_temperature(config.default_temperature),
+ )
+ .await
+ .map_err(|e| e.to_string())
+ .map(|response| {
+ RpcOutcome::single_log(
+ InferenceTestProviderModelResult {
+ reply: response.text(),
+ },
+ "provider model test completed",
)
- .map_err(|e| e.to_string())?;
- log::debug!("{LOG_PREFIX} test_provider_model: invoking local model={model}");
- chat_provider
- .simple_chat(prompt, &model, config.default_temperature)
- .await
- .map_err(|e| e.to_string())
- .map(|reply| {
- RpcOutcome::single_log(
- InferenceTestProviderModelResult { reply },
- "provider model test completed",
- )
- })
- } else {
- let (chat_provider, model) =
- crate::openhuman::inference::provider::factory::create_chat_provider_from_string(
- workload, provider, config,
- )
- .map_err(|e| e.to_string())?;
- chat_provider
- .simple_chat(prompt, &model, config.default_temperature)
- .await
- .map_err(|e| e.to_string())
- .map(|reply| {
- RpcOutcome::single_log(
- InferenceTestProviderModelResult { reply },
- "provider model test completed",
- )
- })
- };
+ });
match &result {
Ok(outcome) => debug!(
output_len = outcome.value.reply.len(),
diff --git a/src/openhuman/inference/provider/auth.rs b/src/openhuman/inference/provider/auth.rs
new file mode 100644
index 000000000..5f3ff49cf
--- /dev/null
+++ b/src/openhuman/inference/provider/auth.rs
@@ -0,0 +1,10 @@
+//! Wire authentication styles shared by crate-native provider builders.
+
+#[derive(Debug, Clone)]
+pub enum AuthStyle {
+ None,
+ Bearer,
+ XApiKey,
+ Anthropic,
+ Custom(String),
+}
diff --git a/src/openhuman/inference/provider/compatible.rs b/src/openhuman/inference/provider/compatible.rs
deleted file mode 100644
index 1ba0a1a15..000000000
--- a/src/openhuman/inference/provider/compatible.rs
+++ /dev/null
@@ -1,422 +0,0 @@
-//! Generic OpenAI-compatible provider.
-//! Most LLM APIs follow the same `/v1/chat/completions` format.
-//! This module provides a single implementation that works for all of them.
-
-#[path = "compatible_dump.rs"]
-mod compatible_dump;
-#[path = "compatible_helpers.rs"]
-mod compatible_helpers;
-#[path = "compatible_parse.rs"]
-mod compatible_parse;
-#[path = "compatible_provider_impl.rs"]
-mod compatible_provider_impl;
-#[path = "compatible_repeat.rs"]
-mod compatible_repeat;
-#[path = "compatible_request.rs"]
-mod compatible_request;
-#[path = "compatible_stream.rs"]
-mod compatible_stream;
-#[path = "compatible_stream_native.rs"]
-mod compatible_stream_native;
-#[path = "compatible_timeout.rs"]
-mod compatible_timeout;
-#[path = "compatible_types.rs"]
-mod compatible_types;
-
-#[cfg(test)]
-pub(crate) use super::traits::{ChatMessage, ConversationMessage, Provider};
-#[cfg(test)]
-pub(crate) use compatible_parse::normalize_function_arguments;
-#[cfg(test)]
-pub(crate) use compatible_parse::{
- build_responses_prompt, extract_responses_text, parse_chat_response_body,
- parse_provider_tool_call_from_value, parse_responses_response_body, parse_sse_line,
- strip_think_tags,
-};
-#[cfg(test)]
-pub(crate) use compatible_repeat::{StreamRepeatDetector, STREAM_REPEAT_THRESHOLD};
-#[cfg(test)]
-pub(crate) use compatible_types::StreamChunkResponse;
-#[cfg(test)]
-pub(crate) use compatible_types::{
- ApiChatRequest, ApiChatResponse, Choice, Function, Message, MessageContent, NativeChatRequest,
- NativeMessage, ResponseMessage, ResponsesResponse, ToolCall,
-};
-
-/// A provider that speaks the OpenAI-compatible chat completions API.
-/// Used by: Venice, Vercel AI Gateway, Cloudflare AI Gateway, Moonshot,
-/// Synthetic, `OpenCode` Zen, `Z.AI`, `GLM`, `MiniMax`, Bedrock, Qianfan, Groq, Mistral, `xAI`, etc.
-pub struct OpenAiCompatibleProvider {
- pub(crate) name: String,
- pub(crate) base_url: String,
- pub(crate) credential: Option,
- pub(crate) auth_header: AuthStyle,
- /// When false, do not fall back to /v1/responses on chat completions 404.
- /// GLM/Zhipu does not support the responses API.
- supports_responses_fallback: bool,
- /// When true, call the Responses API directly instead of first trying
- /// chat completions. Required for ChatGPT-account Codex OAuth.
- responses_api_primary: bool,
- user_agent: Option,
- extra_headers: Vec<(String, String)>,
- extra_query_params: Vec<(String, String)>,
- /// When true, collect all `system` messages and prepend their content
- /// to the first `user` message, then drop the system messages.
- /// Required for providers that reject `role: system` (e.g. MiniMax).
- merge_system_into_user: bool,
- /// When true, forward the OpenHuman backend extension `thread_id`
- /// (read from `thread_context::current_thread_id`) on outbound
- /// chat completions bodies. Off by default — only the
- /// `OpenHumanBackendProvider` opts in, so third-party
- /// OpenAI-compatible endpoints (Venice, Moonshot, Groq, GLM, …)
- /// never see an unrecognized field that could trip strict input
- /// validation.
- emit_openhuman_thread_id: bool,
- /// Shell-style glob patterns (`*` only) for model IDs that MUST NOT
- /// receive a `temperature` field. Matches are done by
- /// `temperature::glob_match`. Defaults to empty (all models support
- /// temperature); populated by the factory when the config has entries.
- pub(crate) temperature_unsupported_models: Vec,
- /// Per-workload temperature override. When `Some`, replaces the
- /// caller-supplied `temperature` for every chat call on this provider
- /// instance — set by the factory when the workload's provider string
- /// carries an `@` suffix (e.g. `"openai:gpt-4o@0.2"`). The
- /// `temperature_unsupported_models` glob filter still applies after.
- pub(crate) temperature_override: Option,
- /// Value reported by `capabilities().native_tool_calling`. Defaults to
- /// `true` because most OpenAI-compatible providers implement the
- /// `tools` parameter correctly. The factory flips this to `false` for
- /// Ollama, whose OpenAI-compat endpoint returns HTTP 400 on `tools`
- /// for many models.
- native_tool_calling: bool,
- /// Value reported by `capabilities().vision`. Defaults to `true` because
- /// OpenAI-compatible cloud endpoints accept the `image_url` message
- /// content shape. Local compatibility shims opt out unless they can prove
- /// the configured model supports vision.
- vision: bool,
- /// Ollama-specific `options.num_ctx` override. When set, every request
- /// to this provider includes `"options": {"num_ctx": }` in the
- /// body so Ollama allocates the requested KV-cache size.
- pub(crate) ollama_num_ctx: Option,
- /// The local provider kind, if this is a local provider.
- /// Used for profile-aware context window resolution and diagnostics.
- pub(crate) local_provider_kind:
- Option,
- /// Per-chunk stream inactivity window for the native streaming path
- /// (`stream_native_chat`, #4269). Defaults to
- /// [`compatible_timeout::stream_idle_timeout`]; tests inject a small value
- /// via [`OpenAiCompatibleProvider::with_stream_idle_timeout`].
- stream_idle_timeout: std::time::Duration,
-}
-
-/// How the provider expects the API key to be sent.
-#[derive(Debug, Clone)]
-pub enum AuthStyle {
- /// No authentication header.
- None,
- /// `Authorization: Bearer `
- Bearer,
- /// `x-api-key: ` (used by some Chinese providers)
- XApiKey,
- /// Anthropic-specific: `x-api-key: ` + `anthropic-version: 2023-06-01`
- Anthropic,
- /// Custom header name
- Custom(String),
-}
-
-impl OpenAiCompatibleProvider {
- pub fn new(
- name: &str,
- base_url: &str,
- credential: Option<&str>,
- auth_style: AuthStyle,
- ) -> Self {
- Self::new_with_options(name, base_url, credential, auth_style, true, None, false)
- }
-
- /// Same as `new` but skips the /v1/responses fallback on 404.
- /// Use for providers (e.g. GLM) that only support chat completions.
- pub fn new_no_responses_fallback(
- name: &str,
- base_url: &str,
- credential: Option<&str>,
- auth_style: AuthStyle,
- ) -> Self {
- Self::new_with_options(name, base_url, credential, auth_style, false, None, false)
- }
-
- /// Create a provider with a custom User-Agent header.
- ///
- /// Some providers (for example Kimi Code) require a specific User-Agent
- /// for request routing and policy enforcement.
- pub fn new_with_user_agent(
- name: &str,
- base_url: &str,
- credential: Option<&str>,
- auth_style: AuthStyle,
- user_agent: &str,
- ) -> Self {
- Self::new_with_options(
- name,
- base_url,
- credential,
- auth_style,
- true,
- Some(user_agent),
- false,
- )
- }
-
- /// For providers that do not support `role: system` (e.g. MiniMax).
- /// System prompt content is prepended to the first user message instead.
- pub fn new_merge_system_into_user(
- name: &str,
- base_url: &str,
- credential: Option<&str>,
- auth_style: AuthStyle,
- ) -> Self {
- Self::new_with_options(name, base_url, credential, auth_style, false, None, true)
- }
-
- /// Opt this provider into emitting the OpenHuman backend extension
- /// `thread_id` on outbound chat completions bodies. Only the
- /// `OpenHumanBackendProvider` should call this — third-party
- /// OpenAI-compatible providers must leave it off so they don't
- /// receive an unknown field.
- pub fn with_openhuman_thread_id(mut self) -> Self {
- self.emit_openhuman_thread_id = true;
- self
- }
-
- fn new_with_options(
- name: &str,
- base_url: &str,
- credential: Option<&str>,
- auth_style: AuthStyle,
- supports_responses_fallback: bool,
- user_agent: Option<&str>,
- merge_system_into_user: bool,
- ) -> Self {
- Self {
- name: name.to_string(),
- base_url: base_url.trim_end_matches('/').to_string(),
- credential: credential.map(ToString::to_string),
- auth_header: auth_style,
- supports_responses_fallback,
- responses_api_primary: false,
- user_agent: user_agent.map(ToString::to_string),
- extra_headers: Vec::new(),
- extra_query_params: Vec::new(),
- merge_system_into_user,
- emit_openhuman_thread_id: false,
- temperature_unsupported_models: Vec::new(),
- temperature_override: None,
- native_tool_calling: true,
- vision: true,
- ollama_num_ctx: None,
- local_provider_kind: None,
- stream_idle_timeout: compatible_timeout::stream_idle_timeout(),
- }
- }
-
- /// Toggle whether this provider advertises native (OpenAI-style) tool
- /// calling to the agent harness. The default is `true`; set to `false`
- /// for providers whose `/v1/chat/completions` endpoint rejects the
- /// `tools` parameter.
- pub fn with_native_tool_calling(mut self, enabled: bool) -> Self {
- self.native_tool_calling = enabled;
- self
- }
-
- /// Test-only: shrink the stream inactivity watchdog window (#4269) so
- /// stalled-stream and wedged-consumer behaviour can be exercised without
- /// waiting the production default (90s).
- #[cfg(test)]
- pub(crate) fn with_stream_idle_timeout(mut self, window: std::time::Duration) -> Self {
- self.stream_idle_timeout = window;
- self
- }
-
- /// Toggle whether this provider advertises OpenAI-compatible vision input.
- /// Cloud providers default to enabled; local OpenAI-compatible shims use
- /// this to stay fail-closed for text-only local models.
- pub fn with_vision(mut self, enabled: bool) -> Self {
- self.vision = enabled;
- self
- }
-
- /// Set the list of model glob patterns for which temperature must be
- /// omitted from request bodies.
- pub fn with_temperature_unsupported_models(mut self, patterns: Vec) -> Self {
- self.temperature_unsupported_models = patterns;
- self
- }
-
- /// Pin a per-workload temperature, overriding whatever the caller passes.
- pub fn with_temperature_override(mut self, temperature: Option) -> Self {
- self.temperature_override = temperature;
- self
- }
-
- /// Set the Ollama `options.num_ctx` override.
- pub fn with_ollama_num_ctx(mut self, num_ctx: Option) -> Self {
- self.ollama_num_ctx = num_ctx;
- self
- }
-
- /// Tag this provider with its local provider kind for profile-aware
- /// context window resolution and diagnostics.
- pub fn with_local_provider_kind(
- mut self,
- kind: crate::openhuman::inference::local::profile::LocalProviderKind,
- ) -> Self {
- self.local_provider_kind = Some(kind);
- self
- }
-
- pub fn with_extra_header(mut self, name: impl Into, value: impl Into) -> Self {
- let name = name.into();
- let value = value.into();
- if !name.trim().is_empty() && !value.trim().is_empty() {
- self.extra_headers
- .push((name.trim().to_string(), value.trim().to_string()));
- }
- self
- }
-
- pub fn with_user_agent(mut self, value: impl Into) -> Self {
- let value = value.into();
- if !value.trim().is_empty() {
- self.user_agent = Some(value.trim().to_string());
- }
- self
- }
-
- pub fn with_responses_api_primary(mut self) -> Self {
- self.responses_api_primary = true;
- self
- }
-
- /// Whether the chat-completions-404 → `/v1/responses` fallback should fire
- /// for this provider on the current call.
- ///
- /// `supports_responses_fallback` is the static (factory-decided) capability,
- /// but a custom / unknown slug whose endpoint does not actually implement
- /// the Responses API only reveals that at runtime — the `/responses` route
- /// returns its own 404. Once we have seen that, [`responses_api_known_unsupported`]
- /// reports the endpoint as Responses-incapable and we stop re-issuing the
- /// guaranteed-failing second request, routing to chat-completions only. This
- /// is the runtime complement to the builtin-slug gate in `factory.rs`
- /// (`builtin_cloud_supports_responses_api`) for custom slugs like
- /// `nous-portal` that the factory can't classify (TAURI-RUST-FJZ).
- pub(super) fn responses_fallback_active(&self) -> bool {
- self.supports_responses_fallback && !responses_api_known_unsupported(&self.base_url)
- }
-
- pub fn with_extra_query_param(
- mut self,
- name: impl Into,
- value: impl Into,
- ) -> Self {
- let name = name.into();
- let value = value.into();
- if !name.trim().is_empty() && !value.trim().is_empty() {
- self.extra_query_params
- .push((name.trim().to_string(), value.trim().to_string()));
- }
- self
- }
-}
-
-/// Endpoints (`base_url`) whose `/v1/responses` route has returned 404 — i.e.
-/// they do not implement the OpenAI Responses API. Once an endpoint is recorded
-/// here, the chat-completions-404 → `/responses` fallback is disabled for it for
-/// the rest of the process lifetime (see [`OpenAiCompatibleProvider::responses_fallback_active`]),
-/// so a permanent client 404 stops triggering a second guaranteed 404 on every
-/// retry (TAURI-RUST-FJZ — `nous-portal`, a chat-completions-only custom slug).
-///
-/// Keyed on `base_url` because that, not the user-facing slug, determines
-/// Responses support: two slugs pointed at the same endpoint share its
-/// capability, and a slug rename must not reset what we learned.
-fn responses_unsupported_endpoints() -> &'static std::sync::Mutex>
-{
- static CACHE: std::sync::OnceLock>> =
- std::sync::OnceLock::new();
- CACHE.get_or_init(|| std::sync::Mutex::new(std::collections::HashSet::new()))
-}
-
-/// Record that `base_url` returned 404 from its `/v1/responses` route and is
-/// therefore not Responses-capable. Idempotent.
-pub(super) fn mark_responses_api_unsupported(base_url: &str) {
- if let Ok(mut set) = responses_unsupported_endpoints().lock() {
- if set.insert(base_url.to_string()) {
- log::debug!(
- "[provider] /responses route 404'd — disabling responses fallback for \
- endpoint {} (chat-completions only henceforth)",
- super::factory::redact_endpoint(base_url),
- );
- }
- }
-}
-
-/// Whether `base_url` has been recorded as not implementing the Responses API.
-pub(super) fn responses_api_known_unsupported(base_url: &str) -> bool {
- responses_unsupported_endpoints()
- .lock()
- .map(|set| set.contains(base_url))
- .unwrap_or(false)
-}
-
-/// Prompt-cache behaviour for an OpenAI-compatible provider, keyed on its
-/// configured slug (#3939).
-///
-/// Conservative by default: only providers we have verified to both (a) cache
-/// identical request prefixes server-side and (b) report cached input tokens
-/// via the OpenAI `prompt_tokens_details.cached_tokens` shape that
-/// [`OpenAiCompatibleProvider`]'s usage extractor already normalises are opted
-/// in. Unknown / custom slugs (including local LM Studio endpoints, which do no
-/// server-side billing-grade caching) get the all-`false` default, so we never
-/// advertise caching a custom endpoint may not do. `explicit_cache_control`
-/// stays `false` for every OpenAI-compatible provider — the chat-completions
-/// API has no cache-control field — and `cache_key_grouping` is reserved for
-/// the OpenHuman backend's `thread_id` extension, declared on
-/// `OpenHumanBackendProvider` directly.
-pub(crate) fn prompt_cache_for_compatible_slug(
- slug: &str,
-) -> super::traits::PromptCacheCapabilities {
- // Compare on the leading slug segment so a user-renamed `openai-eu` or a
- // `openai:gpt-5.1` style slug still resolves to the `openai` family.
- let normalized = slug.trim().to_ascii_lowercase();
- let family = normalized
- .split([':', '/', '-'])
- .next()
- .unwrap_or("")
- .trim();
-
- // Verified OpenAI-style implicit prefix cache + cached-token usage reporting.
- let openai_style_cache = matches!(family, "openai" | "openrouter" | "gmi");
-
- let caps = super::traits::PromptCacheCapabilities {
- automatic_prefix_cache: openai_style_cache,
- explicit_cache_control: false,
- usage_reports_cached_input: openai_style_cache,
- cache_key_grouping: false,
- };
-
- tracing::debug!(
- domain = "llm_provider",
- operation = "prompt_cache_capability",
- provider = %family,
- automatic_prefix_cache = caps.automatic_prefix_cache,
- explicit_cache_control = caps.explicit_cache_control,
- usage_reports_cached_input = caps.usage_reports_cached_input,
- cache_key_grouping = caps.cache_key_grouping,
- "[llm_provider] prompt-cache capability selected for compatible provider"
- );
-
- caps
-}
-
-#[cfg(test)]
-#[path = "compatible_tests.rs"]
-mod tests;
diff --git a/src/openhuman/inference/provider/compatible_dump.rs b/src/openhuman/inference/provider/compatible_dump.rs
deleted file mode 100644
index 0680b4990..000000000
--- a/src/openhuman/inference/provider/compatible_dump.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-//! Prompt and response dump utilities for KV-cache debugging.
-//!
-//! When `OPENHUMAN_PROMPT_DUMP_DIR` is set, both the outbound request payload
-//! and the inbound response body are written to timestamped files under that
-//! directory. Best-effort: failures are logged and swallowed so a dump outage
-//! never breaks inference.
-
-use serde::Serialize;
-use std::sync::atomic::{AtomicU64, Ordering};
-
-/// Monotonic sequence so multiple requests in the same millisecond sort
-/// deterministically in the dump directory.
-pub(crate) static PROMPT_DUMP_SEQ: AtomicU64 = AtomicU64::new(0);
-
-/// Atomically reserve the next dump sequence number. This is the single
-/// source of truth for seq allocation — both the prompt dump and its
-/// paired response dump must use the value returned here. A non-atomic
-/// peek-then-increment split would race under concurrent requests (two
-/// callers could reserve the same seq or correlate a request/response
-/// pair across different turns).
-pub(crate) fn reserve_dump_seq() -> u64 {
- PROMPT_DUMP_SEQ.fetch_add(1, Ordering::Relaxed)
-}
-
-/// When `OPENHUMAN_PROMPT_DUMP_DIR` is set, write `body` (the exact JSON
-/// payload we're about to POST to the provider) to a timestamped file
-/// under that directory. Best-effort: failures are logged and swallowed
-/// so a dump outage never breaks inference.
-///
-/// Intended for KV-cache debugging — diff consecutive turns to see which
-/// bytes of the prefix drifted and broke the cache hit.
-pub(crate) fn dump_prompt_if_enabled(
- provider: &str,
- model: &str,
- seq: u64,
- body: &T,
-) {
- let Ok(dir) = std::env::var("OPENHUMAN_PROMPT_DUMP_DIR") else {
- return;
- };
- let dir = std::path::PathBuf::from(dir);
- if let Err(err) = std::fs::create_dir_all(&dir) {
- log::warn!(
- "[prompt_dump] failed to create dir {}: {err}",
- dir.display()
- );
- return;
- }
- let ts = chrono::Utc::now().format("%Y%m%dT%H%M%S%.3fZ");
- let safe_model: String = model
- .chars()
- .map(|c| {
- if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' {
- c
- } else {
- '_'
- }
- })
- .collect();
- let filename = format!("{ts}_{seq:06}_{provider}_{safe_model}.json");
- let path = dir.join(filename);
- match serde_json::to_vec_pretty(body) {
- Ok(bytes) => {
- if let Err(err) = std::fs::write(&path, &bytes) {
- log::warn!("[prompt_dump] write failed {}: {err}", path.display());
- } else {
- log::debug!(
- "[prompt_dump] wrote {} bytes -> {}",
- bytes.len(),
- path.display()
- );
- }
- }
- Err(err) => {
- log::warn!("[prompt_dump] serialize failed: {err}");
- }
- }
-}
-
-/// Write raw response bytes to the dump dir paired with the most-recent
-/// prompt file (same `seq` prefix, `.response.json` suffix). `seq` must
-/// be the value reserved via `reserve_dump_seq` and passed to
-/// `dump_prompt_if_enabled` so request/response files sort next to
-/// each other.
-pub(crate) fn dump_response_if_enabled(provider: &str, model: &str, seq: u64, bytes: &[u8]) {
- let Ok(dir) = std::env::var("OPENHUMAN_PROMPT_DUMP_DIR") else {
- return;
- };
- let dir = std::path::PathBuf::from(dir);
- if let Err(err) = std::fs::create_dir_all(&dir) {
- log::warn!(
- "[prompt_dump] failed to create dir {}: {err}",
- dir.display()
- );
- return;
- }
- let ts = chrono::Utc::now().format("%Y%m%dT%H%M%S%.3fZ");
- let safe_model: String = model
- .chars()
- .map(|c| {
- if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' {
- c
- } else {
- '_'
- }
- })
- .collect();
- let filename = format!("{ts}_{seq:06}_{provider}_{safe_model}.response.json");
- let path = dir.join(filename);
- // Re-pretty-print if it parses as JSON so diffs are stable; otherwise
- // write raw bytes (SSE fragments, error HTML, etc).
- let payload: Vec = match serde_json::from_slice::(bytes) {
- Ok(v) => serde_json::to_vec_pretty(&v).unwrap_or_else(|_| bytes.to_vec()),
- Err(_) => bytes.to_vec(),
- };
- if let Err(err) = std::fs::write(&path, &payload) {
- log::warn!(
- "[prompt_dump] response write failed {}: {err}",
- path.display()
- );
- } else {
- log::debug!(
- "[prompt_dump] wrote response {} bytes -> {}",
- payload.len(),
- path.display()
- );
- }
-}
diff --git a/src/openhuman/inference/provider/compatible_helpers.rs b/src/openhuman/inference/provider/compatible_helpers.rs
deleted file mode 100644
index fe7281b4d..000000000
--- a/src/openhuman/inference/provider/compatible_helpers.rs
+++ /dev/null
@@ -1,843 +0,0 @@
-use crate::openhuman::inference::provider::traits::{
- ChatMessage, ChatResponse as ProviderChatResponse, ToolCall as ProviderToolCall,
- UsageInfo as ProviderUsageInfo,
-};
-
-use super::compatible_parse::{
- aggregate_responses_sse_body, build_responses_prompt, extract_responses_text,
- normalize_function_arguments, parse_responses_response_body,
- parse_tool_calls_from_content_json,
-};
-use super::compatible_types::{
- ApiChatResponse, MessageContent, NativeMessage, ResponsesRequest, ToolCall,
-};
-use super::OpenAiCompatibleProvider;
-
-impl OpenAiCompatibleProvider {
- pub(super) async fn chat_via_responses(
- &self,
- credential: Option<&str>,
- messages: &[ChatMessage],
- model: &str,
- max_output_tokens: Option,
- ) -> anyhow::Result {
- let (instructions, input) = build_responses_prompt(messages);
- if input.is_empty() {
- anyhow::bail!(
- "{} Responses API fallback requires at least one non-system message",
- self.name
- );
- }
-
- log::debug!(
- "[provider] {} responses-path model={model} max_output_tokens={:?} input_msgs={}",
- self.name,
- max_output_tokens,
- input.len(),
- );
-
- // #3201: the Codex/ChatGPT OAuth Responses endpoint rejects `stream: false`
- // outright. This branch lifts the constraint for that endpoint specifically
- // and parses the resulting SSE body so the existing non-streaming call
- // signature is preserved. Other providers keep the single-envelope path.
- let is_codex_oauth_responses = reqwest::Url::parse(&self.base_url)
- .ok()
- .and_then(|url| {
- let segments: Vec<&str> = url.path_segments()?.collect();
- Some(
- segments
- .windows(2)
- .any(|window| window == ["backend-api", "codex"]),
- )
- })
- .unwrap_or(false);
-
- // TAURI-RUST-EWD: the Codex/ChatGPT OAuth Responses endpoint
- // (`chatgpt.com/backend-api/codex/responses`) rejects `max_output_tokens`
- // outright (400 `Unsupported parameter: max_output_tokens`), the same way
- // it rejects `stream: false` (#3201). Omit the cap proactively for that
- // endpoint; every other Responses backend keeps it (the cap still flows
- // through for `responses_api_primary` on a real `/v1/responses`).
- if is_codex_oauth_responses && max_output_tokens.is_some() {
- log::debug!(
- "[provider] {} omitting max_output_tokens={:?} for Codex OAuth responses endpoint (unsupported param)",
- self.name,
- max_output_tokens,
- );
- }
-
- // TAURI-RUST-AHX: the ChatGPT-OAuth Codex Responses endpoint rejects the
- // `auto` model sentinel with a 400 (`The 'auto' model is not supported
- // when using Codex with a ChatGPT account.`). `auto` is a Codex-CLI alias
- // valid only for API-key Codex; here it would otherwise leak unchanged to
- // the provider. Remap it to a concrete Codex-class model proactively for
- // this endpoint only, mirroring the #3201 (drop `stream:false`) and EWD
- // (drop `max_output_tokens`) adjustments above. Every other endpoint keeps
- // `model` untouched.
- let effective_model = if is_codex_oauth_responses && model.eq_ignore_ascii_case("auto") {
- let remapped = super::super::openai_codex::OPENAI_CODEX_MODEL_HINTS
- .first()
- .copied()
- .unwrap_or("gpt-5.5");
- log::info!(
- "[provider] {} remapping model=auto -> {remapped} for Codex OAuth responses endpoint (auto unsupported on ChatGPT account)",
- self.name,
- );
- remapped.to_string()
- } else {
- model.to_string()
- };
-
- let mut request = ResponsesRequest {
- model: effective_model,
- input,
- instructions,
- stream: Some(is_codex_oauth_responses),
- store: Some(false),
- max_output_tokens: if is_codex_oauth_responses {
- None
- } else {
- max_output_tokens
- },
- };
-
- let url = self.responses_url();
- let mut retried_without_cap = false;
-
- let (status, error) = loop {
- let response = self
- .apply_auth_header(self.http_client().post(&url).json(&request), credential)
- .send()
- .await?;
-
- if response.status().is_success() {
- let body = response.text().await?;
- if is_codex_oauth_responses {
- return aggregate_responses_sse_body(&self.name, &body);
- }
- let responses = parse_responses_response_body(&self.name, &body)?;
- return extract_responses_text(responses).ok_or_else(|| {
- anyhow::anyhow!("No response from {} Responses API", self.name)
- });
- }
-
- let status = response.status();
- let error = response.text().await?;
-
- // Reactive defense-in-depth: a strict Responses backend may still
- // reject `max_output_tokens` with a 400 (e.g. a future Codex endpoint
- // variant we don't match above). Strip the field and retry once,
- // mirroring the no-tools / frequency_penalty retries. Bounded to a
- // single retry so a genuinely different 400 still surfaces.
- if !retried_without_cap
- && request.max_output_tokens.is_some()
- && status == reqwest::StatusCode::BAD_REQUEST
- && Self::err_indicates_max_output_tokens_unsupported(&error)
- {
- log::info!(
- "[provider] {} rejected max_output_tokens — retrying responses request without it",
- self.name,
- );
- request.max_output_tokens = None;
- retried_without_cap = true;
- continue;
- }
-
- break (status, error);
- };
-
- let status_str = status.as_u16().to_string();
- let sanitized = super::super::sanitize_api_error(&error);
- // Emit the status in the structured `()` position the retry
- // classifier understands (`reliable::structured_http_4xx`). The bare
- // `"… Responses API error: 404 Not Found"` form left the `404`
- // unanchored, so a terminal 404 was misclassified as retryable and
- // looped indefinitely (TAURI-RUST-FJZ, ~15k events).
- let message = format!(
- "{} Responses API error ({status_str}): {sanitized}",
- self.name
- );
- // A 404 from the `/responses` route can mean this endpoint has no
- // Responses API at all — disable the chat-completions-404 →
- // `/responses` fallback for it so we stop issuing a guaranteed second
- // 404. Guard against poisoning the process-global cache on a
- // model/deployment-specific 404 (the route exists, the model
- // doesn't), which would wrongly drop the fallback for every other
- // model on a Responses-capable endpoint. Skip when Responses is the
- // primary path (Codex OAuth): the fallback flag is never consulted
- // and a 404 there is not evidence the route is missing.
- let responses_route_missing = status == reqwest::StatusCode::NOT_FOUND
- && !self.responses_api_primary
- && Self::responses_404_indicates_missing_route(&error);
- if responses_route_missing {
- super::mark_responses_api_unsupported(&self.base_url);
- }
- if responses_route_missing {
- // The `/responses` route 404'd: this endpoint is chat-completions
- // only. We've just cached it unsupported so the fallback won't fire
- // again this process, but the very first probe per process still
- // lands here — and reporting it floods Sentry with one
- // `" Responses API error (404): …"` event per fresh
- // session (TAURI-RUST-5A1, ~900 status=404 events). It is an
- // expected capability-probe miss (the chat-completions path serves
- // the request), not a Sentry-actionable defect, so demote to info.
- log::info!(
- "[provider] {} /responses route 404 — endpoint is chat-completions only; \
- demoting and caching unsupported (fallback disabled henceforth): {}",
- self.name,
- super::super::factory::redact_endpoint(&self.base_url),
- );
- } else if super::super::is_budget_exhausted_http_400(status, &error) {
- super::super::log_budget_exhausted_http_400(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_custom_openai_upstream_bad_request_http_400(
- self.name.as_str(),
- status,
- &error,
- ) {
- super::super::log_custom_openai_upstream_bad_request_http_400(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_access_policy_denied_http_403(status, &error) {
- super::super::log_provider_access_policy_denied_http_403(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_config_rejection_http(
- status,
- self.name.as_str(),
- &error,
- ) {
- super::super::log_provider_config_rejection(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_byo_provider_auth_failure_http(
- self.name.as_str(),
- status,
- &error,
- ) {
- super::super::log_byo_provider_auth_failure(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_openai_oauth_session_expired_http(
- self.name.as_str(),
- status,
- &error,
- ) {
- super::super::log_openai_oauth_session_expired(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_insufficient_credits_402(status, &error) {
- // Insufficient-credits 402: the user's own BYO provider account
- // is out of balance — a flat billing fact, not a reservation-
- // window error, so there is NO local max_tokens lever to apply.
- // Demote to info instead of paging on every retry; this is the
- // complete classification for a genuinely-unpreventable
- // BYO-balance condition
- // (TAURI-RUST-4QF — DeepSeek "Insufficient Balance").
- super::super::log_provider_insufficient_credits_402(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_quota_exhausted(&error) {
- // Codex/ChatGPT OAuth `/responses` plan cap hit
- // (`usage_limit_reached` / "The usage limit has been reached"): a
- // third-party plan limit with no local lever. The subconscious loop
- // retries until `resets_at`, so a single capped Plus user emits
- // hundreds of identical events — demote to info instead of paging on
- // every retry (TAURI-RUST-AFE, extends the #4076/C9A quota machinery
- // to the Responses path).
- super::super::log_provider_quota_exhausted(
- "responses_api",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::should_report_provider_http_failure(status) {
- crate::core::observability::report_error(
- message.as_str(),
- "llm_provider",
- "responses_api",
- &[
- ("provider", self.name.as_str()),
- ("model", model),
- ("status", status_str.as_str()),
- ("failure", "non_2xx"),
- ],
- );
- }
- anyhow::bail!(message);
- }
-
- pub(super) fn convert_tool_specs(
- tools: Option<&[crate::openhuman::tools::ToolSpec]>,
- ) -> Option> {
- tools.map(|items| {
- let mut seen: std::collections::HashSet<&str> =
- std::collections::HashSet::with_capacity(items.len());
- let mut dropped: Vec<&str> = Vec::new();
- let mut out: Vec = Vec::with_capacity(items.len());
- for tool in items {
- if !seen.insert(tool.name.as_str()) {
- dropped.push(tool.name.as_str());
- continue;
- }
- out.push(serde_json::json!({
- "type": "function",
- "function": {
- "name": tool.name,
- "description": tool.description,
- "parameters": tool.parameters,
- }
- }));
- }
- if !dropped.is_empty() {
- log::warn!(
- "[providers][compatible] dropped {} duplicate tool spec(s) at wire \
- boundary (TAURI-RUST-2E): {:?}",
- dropped.len(),
- dropped
- );
- }
- out
- })
- }
-
- pub(super) fn convert_messages_for_native(messages: &[ChatMessage]) -> Vec {
- let converted: Vec =
- messages
- .iter()
- .map(|message| {
- let reasoning_content = if message.role == "assistant" {
- message
- .extra_metadata
- .as_ref()
- .and_then(|m| m.get("reasoning_content"))
- .and_then(serde_json::Value::as_str)
- .map(ToString::to_string)
- } else {
- None
- };
-
- if message.role == "assistant" {
- if let Ok(value) =
- serde_json::from_str::(&message.content)
- {
- if let Some(tool_calls_value) = value.get("tool_calls") {
- if let Ok(parsed_calls) =
- serde_json::from_value::>(
- tool_calls_value.clone(),
- )
- {
- let tool_calls = parsed_calls
- .into_iter()
- .map(|tc| ToolCall {
- id: Some(tc.id),
- kind: Some("function".to_string()),
- function: Some(super::compatible_types::Function {
- name: Some(tc.name),
- arguments: Some(serde_json::Value::String(
- tc.arguments,
- )),
- }),
- // Echo Gemini's thought_signature back on
- // the next turn (TAURI-RUST-4PK).
- extra_content: tc.extra_content,
- })
- .collect::>();
-
- let content = Some(MessageContent::Text(
- value
- .get("content")
- .and_then(serde_json::Value::as_str)
- .unwrap_or("")
- .to_string(),
- ));
-
- let reasoning_content = value
- .get("reasoning_content")
- .and_then(serde_json::Value::as_str)
- .filter(|s| !s.trim().is_empty())
- .map(ToString::to_string)
- .or_else(|| reasoning_content.clone());
-
- return NativeMessage {
- role: "assistant".to_string(),
- content,
- tool_call_id: None,
- tool_calls: Some(tool_calls),
- reasoning_content,
- };
- }
- }
- }
- }
-
- if message.role == "tool" {
- if let Ok(value) =
- serde_json::from_str::(&message.content)
- {
- let tool_call_id = value
- .get("tool_call_id")
- .and_then(serde_json::Value::as_str)
- .map(ToString::to_string);
- let content = value
- .get("content")
- .and_then(serde_json::Value::as_str)
- .map(ToString::to_string)
- .or_else(|| Some(message.content.clone()))
- .map(MessageContent::Text);
-
- return NativeMessage {
- role: "tool".to_string(),
- content,
- tool_call_id,
- tool_calls: None,
- reasoning_content: None,
- };
- }
- }
-
- NativeMessage {
- role: message.role.clone(),
- content: Some(MessageContent::from_chat_text(&message.content)),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content,
- }
- })
- .collect();
-
- Self::enforce_tool_message_invariants(converted)
- }
-
- /// Enforce the OpenAI-compatible tool-message ordering invariants on the
- /// fully-serialized wire array, immediately before it goes on the wire.
- ///
- /// Several upstream defects can leave the array malformed and trip a 400
- /// (`messages with role 'tool' must be a response to a preceding message
- /// with 'tool_calls'`). That 400 streams back as an empty completion, which
- /// the agent loop collapses to "The model returned an empty response" and
- /// the chat surface shows as a generic "Something went wrong":
- ///
- /// * **(A)** History tail-trimming cuts *between* an `assistant(tool_calls)`
- /// and its `tool` result, dropping the assistant and orphaning the result.
- /// * **(B)** A persisted assistant tool-call message whose `content` no
- /// longer deserializes as `tool_calls` (format drift) falls through and
- /// is emitted as plain text with its `tool_calls` stripped.
- /// * **(C)** An `assistant(tool_calls)` whose results never arrived leaves
- /// dangling tool-call ids with no matching `tool` response.
- pub(super) fn enforce_tool_message_invariants(
- messages: Vec,
- ) -> Vec {
- use std::collections::HashSet;
-
- let mut out: Vec = Vec::with_capacity(messages.len());
- let mut dropped_orphans = 0usize;
- let mut pruned_calls = 0usize;
-
- let mut iter = messages.into_iter().peekable();
- while let Some(mut msg) = iter.next() {
- if msg.role == "assistant" && msg.tool_calls.is_some() {
- let mut run: Vec = Vec::new();
- while iter.peek().is_some_and(|m| m.role == "tool") {
- run.push(iter.next().expect("peeked tool message"));
- }
- let responded: HashSet =
- run.iter().filter_map(|t| t.tool_call_id.clone()).collect();
-
- let calls = msg.tool_calls.take().unwrap_or_default();
- let before = calls.len();
- let kept: Vec = calls
- .into_iter()
- .filter(|c| c.id.as_deref().is_some_and(|id| responded.contains(id)))
- .collect();
- pruned_calls += before - kept.len();
- let kept_ids: HashSet = kept.iter().filter_map(|c| c.id.clone()).collect();
- msg.tool_calls = if kept.is_empty() { None } else { Some(kept) };
- if msg.tool_calls.is_none() {
- msg.reasoning_content = None;
- }
- out.push(msg);
-
- for tool_msg in run {
- let kept = tool_msg
- .tool_call_id
- .as_deref()
- .is_some_and(|id| kept_ids.contains(id));
- if kept {
- out.push(tool_msg);
- } else {
- dropped_orphans += 1;
- }
- }
- } else if msg.role == "tool" {
- dropped_orphans += 1;
- } else {
- out.push(msg);
- }
- }
-
- if dropped_orphans > 0 || pruned_calls > 0 {
- log::warn!(
- "[provider] sanitized malformed tool-message ordering before send: \
- dropped {dropped_orphans} orphaned tool result(s), pruned {pruned_calls} \
- unanswered tool_call(s)"
- );
- }
-
- out
- }
-
- pub(super) fn with_prompt_guided_tool_instructions(
- messages: &[ChatMessage],
- tools: Option<&[crate::openhuman::tools::ToolSpec]>,
- ) -> Vec {
- let Some(tools) = tools else {
- return messages.to_vec();
- };
-
- if tools.is_empty() {
- return messages.to_vec();
- }
-
- let instructions =
- crate::openhuman::inference::provider::traits::build_tool_instructions_text(tools);
- let mut modified_messages = messages.to_vec();
-
- if let Some(system_message) = modified_messages.iter_mut().find(|m| m.role == "system") {
- if !system_message.content.is_empty() {
- system_message.content.push_str("\n\n");
- }
- system_message.content.push_str(&instructions);
- } else {
- modified_messages.insert(0, ChatMessage::system(instructions));
- }
-
- modified_messages
- }
-
- pub(super) fn parse_native_response(
- api_response: ApiChatResponse,
- provider_name: &str,
- ) -> anyhow::Result {
- let usage = Self::extract_usage(&api_response);
-
- let message = api_response
- .choices
- .into_iter()
- .next()
- .map(|c| c.message)
- .ok_or_else(|| anyhow::anyhow!("No choices in response from {}", provider_name))?;
-
- let mut text = message.effective_content_optional();
- let reasoning_content = message
- .reasoning_content
- .as_deref()
- .map(str::trim)
- .filter(|s| !s.is_empty())
- .map(str::to_owned);
- let mut tool_calls = message
- .tool_calls
- .unwrap_or_default()
- .into_iter()
- .filter_map(|tc| {
- let function = tc.function?;
- let name = function.name?;
- let arguments = normalize_function_arguments(function.arguments);
- Some(ProviderToolCall {
- id: tc.id.unwrap_or_else(|| uuid::Uuid::new_v4().to_string()),
- name,
- arguments,
- // Preserve Gemini's thought_signature (TAURI-RUST-4PK) so it
- // can be echoed on the next turn; None for providers that
- // don't send extra_content.
- extra_content: tc.extra_content,
- })
- })
- .collect::>();
-
- if tool_calls.is_empty() {
- if let Some(function) = message.function_call.as_ref() {
- if let Some(name) = function
- .name
- .as_ref()
- .filter(|name| !name.trim().is_empty())
- {
- tool_calls.push(ProviderToolCall {
- id: uuid::Uuid::new_v4().to_string(),
- name: name.clone(),
- arguments: normalize_function_arguments(function.arguments.clone()),
- // Legacy `function_call` shape carries no extra_content.
- extra_content: None,
- });
- }
- }
- }
-
- if let Some(content) = message.content.as_deref() {
- if let Some((json_text, json_tool_calls)) = parse_tool_calls_from_content_json(content)
- {
- if !json_tool_calls.is_empty() {
- tool_calls = json_tool_calls;
- text = json_text.or(text);
- }
- }
- }
-
- tracing::debug!(
- has_reasoning_content = reasoning_content.is_some(),
- reasoning_content_chars = reasoning_content.as_ref().map_or(0, |r| r.chars().count()),
- "[provider:parse_native_response] reasoning_content capture"
- );
-
- Ok(ProviderChatResponse {
- text,
- tool_calls,
- usage,
- reasoning_content,
- })
- }
-
- /// Extract usage info from API response, preferring the OpenHuman
- /// metadata block (which includes cache stats and billing) over the
- /// standard OpenAI usage block.
- pub(super) fn extract_usage(resp: &ApiChatResponse) -> Option {
- let oh = resp.openhuman.as_ref();
- let std_usage = resp.usage.as_ref();
-
- if oh.is_none() && std_usage.is_none() {
- return None;
- }
-
- let oh_usage = oh.and_then(|o| o.usage.as_ref());
- let oh_billing = oh.and_then(|o| o.billing.as_ref());
-
- let input_tokens = oh_usage
- .and_then(|u| u.input_tokens)
- .or(std_usage.map(|u| u.prompt_tokens))
- .unwrap_or(0);
- let output_tokens = oh_usage
- .and_then(|u| u.output_tokens)
- .or(std_usage.map(|u| u.completion_tokens))
- .unwrap_or(0);
- let cached_input_tokens = oh_usage
- .and_then(|u| u.cached_input_tokens)
- .or(std_usage
- .and_then(|u| u.prompt_tokens_details.as_ref())
- .map(|d| d.cached_tokens))
- .unwrap_or(0);
- let charged_amount_usd = oh_billing.map(|b| b.charged_amount_usd).unwrap_or(0.0);
-
- let from_openhuman = oh_usage.is_some();
- let from_standard = std_usage.is_some() && !from_openhuman;
- let has_billing = oh_billing.is_some();
- tracing::debug!(
- from_openhuman,
- from_standard,
- has_billing,
- input_tokens,
- output_tokens,
- cached_input_tokens,
- charged_amount_usd,
- "[provider:usage] extract_usage resolved token counts"
- );
-
- Some(ProviderUsageInfo {
- input_tokens,
- output_tokens,
- context_window: 0,
- cached_input_tokens,
- cache_creation_tokens: 0,
- reasoning_tokens: 0,
- charged_amount_usd,
- })
- }
-
- pub(super) fn is_native_tool_schema_unsupported(
- status: reqwest::StatusCode,
- error: &str,
- ) -> bool {
- if !matches!(
- status,
- reqwest::StatusCode::BAD_REQUEST | reqwest::StatusCode::UNPROCESSABLE_ENTITY
- ) {
- return false;
- }
-
- let lower = error.to_lowercase();
- [
- "unknown parameter: tools",
- "unsupported parameter: tools",
- "unrecognized field `tools`",
- "does not support tools",
- "function calling is not supported",
- "tool_choice",
- ]
- .iter()
- .any(|hint| lower.contains(hint))
- }
-
- pub(super) fn err_supports_no_tools_retry(error: &str) -> bool {
- Self::is_native_tool_schema_unsupported(reqwest::StatusCode::BAD_REQUEST, error)
- }
-
- /// Detect a provider rejecting the `frequency_penalty` sampling field. Some
- /// strict OpenAI-compatible backends 400 on unknown params; when this fires
- /// the caller retries once with the field omitted (mirrors the no-tools
- /// retry). String-based because the streamed transport error surfaces the
- /// API error body.
- pub(super) fn err_indicates_frequency_penalty_unsupported(error: &str) -> bool {
- let lower = error.to_lowercase();
- lower.contains("frequency_penalty")
- && (lower.contains("unsupported")
- || lower.contains("unknown")
- || lower.contains("unrecognized")
- || lower.contains("not supported")
- || lower.contains("does not support")
- || lower.contains("invalid")
- || lower.contains("unexpected"))
- }
-
- /// Detect a Responses backend rejecting the `max_output_tokens` field as an
- /// *unrecognized parameter*. The Codex/ChatGPT OAuth endpoint 400s with
- /// `Unsupported parameter: max_output_tokens` (TAURI-RUST-EWD); when this
- /// fires the responses path retries once with the field omitted (mirrors the
- /// no-tools and frequency_penalty retries). String-based because the
- /// rejection surfaces as the API error body.
- ///
- /// Deliberately matches only *parameter-not-accepted* wording, **not**
- /// invalid-value wording (e.g. "value above the allowed range"). Stripping
- /// the cap turns a bounded request into an uncapped generation, so on a
- /// value-range error we must surface the config error rather than silently
- /// drop the credit-preflight / response-size protection `max_tokens` gives.
- pub(super) fn err_indicates_max_output_tokens_unsupported(error: &str) -> bool {
- let lower = error.to_lowercase();
- lower.contains("max_output_tokens")
- && (lower.contains("unsupported")
- || lower.contains("unknown")
- || lower.contains("unrecognized")
- || lower.contains("not supported")
- || lower.contains("does not support")
- || lower.contains("unexpected parameter"))
- }
-
- /// Disambiguate a 404 from the `/responses` route: `true` when it signals the
- /// *route itself* is absent (this endpoint has no Responses API), `false` when
- /// it looks model/deployment-specific (the route exists, that model doesn't).
- ///
- /// Only a missing-route 404 should disable the fallback for the whole endpoint
- /// (TAURI-RUST-FJZ). A bad-model 404 must NOT poison the process-global cache,
- /// or a single bad model would drop the `/responses` fallback for every other
- /// model on a Responses-capable endpoint. Conservative: any mention of a
- /// model/deployment keeps the fallback enabled.
- pub(super) fn responses_404_indicates_missing_route(error: &str) -> bool {
- let lower = error.to_lowercase();
- !(lower.contains("model") || lower.contains("deployment"))
- }
-
- /// Detect a 404 whose body says the model is completion-only. See issue #3193.
- pub(super) fn is_completion_only_model_404(status: reqwest::StatusCode, error: &str) -> bool {
- if status != reqwest::StatusCode::NOT_FOUND {
- return false;
- }
- let lower = error.to_lowercase();
- lower.contains("not a chat model")
- || (lower.contains("v1/chat/completions") && lower.contains("v1/completions"))
- }
-
- /// Detect a model rejected because it has no chat capability. See Sentry TAURI-RUST-4P6.
- pub(super) fn is_not_chat_capable_model(status: reqwest::StatusCode, error: &str) -> bool {
- if !matches!(
- status,
- reqwest::StatusCode::BAD_REQUEST | reqwest::StatusCode::UNPROCESSABLE_ENTITY
- ) {
- return false;
- }
- error.to_lowercase().contains("does not support chat")
- }
-
- pub(super) fn completion_only_model_message(&self, model: &str, sanitized: &str) -> String {
- format!(
- "{name} API error (404): model '{model}' does not support the \
- chat-completions API that OpenHuman uses — it appears to be a \
- completion-only / base model. Assign a chat-capable model to this \
- provider (e.g. in Connections → API keys → LLM), or pick a different model. \
- Provider detail: {sanitized}",
- name = self.name,
- )
- }
-
- /// Guard shared by every chat-completions 404 handler. See issue #3193.
- pub(super) fn completion_only_404_guard(
- &self,
- status: reqwest::StatusCode,
- sanitized: &str,
- model: &str,
- ) -> Option {
- if Self::is_completion_only_model_404(status, sanitized) {
- Some(anyhow::anyhow!(
- self.completion_only_model_message(model, sanitized)
- ))
- } else {
- None
- }
- }
-
- pub(super) fn not_chat_capable_model_message(&self, model: &str, sanitized: &str) -> String {
- format!(
- "{name} API error: model '{model}' does not support chat — it \
- appears to be an embedding or non-chat model. Assign a \
- chat-capable model to this provider (e.g. in Connections → API keys → LLM), or \
- pick a different model. Provider detail: {sanitized}",
- name = self.name,
- )
- }
-
- /// Guard shared by every chat-completions error handler. See Sentry TAURI-RUST-4P6.
- pub(super) fn not_chat_capable_guard(
- &self,
- status: reqwest::StatusCode,
- sanitized: &str,
- model: &str,
- ) -> Option {
- if Self::is_not_chat_capable_model(status, sanitized) {
- Some(anyhow::anyhow!(
- self.not_chat_capable_model_message(model, sanitized)
- ))
- } else {
- None
- }
- }
-
- pub(super) fn enrich_404_message(&self, base: String, status: reqwest::StatusCode) -> String {
- if status == reqwest::StatusCode::NOT_FOUND && !self.supports_responses_fallback {
- format!(
- "{base}; check that your endpoint URL is correct \
- and the model name exists on your provider"
- )
- } else {
- base
- }
- }
-}
diff --git a/src/openhuman/inference/provider/compatible_parse.rs b/src/openhuman/inference/provider/compatible_parse.rs
deleted file mode 100644
index 6c38c307f..000000000
--- a/src/openhuman/inference/provider/compatible_parse.rs
+++ /dev/null
@@ -1,423 +0,0 @@
-//! Parsing and response-extraction free functions for the OpenAI-compatible provider.
-//!
-//! All functions here are stateless transforms — no I/O, no HTTP. They take
-//! raw strings or deserialized values and return structured results.
-
-use crate::openhuman::inference::provider::traits::{
- ChatMessage, StreamError, StreamResult, ToolCall as ProviderToolCall,
-};
-
-use super::compatible_types::{
- ApiChatResponse, ResponsesContentPart, ResponsesInput, ResponsesResponse, StreamChunkResponse,
-};
-
-// ── Think-tag stripping ───────────────────────────────────────────────────────
-
-/// Remove `...` blocks from model output.
-/// Some reasoning models (e.g. MiniMax) embed their chain-of-thought inline
-/// in the `content` field rather than a separate `reasoning_content` field.
-/// The resulting `` tags must be stripped before returning to the user.
-pub(crate) fn strip_think_tags(s: &str) -> String {
- let mut result = String::with_capacity(s.len());
- let mut rest = s;
- loop {
- if let Some(start) = rest.find("") {
- result.push_str(&rest[..start]);
- if let Some(end) = rest[start..].find("") {
- rest = &rest[start + end + "".len()..];
- } else {
- // Unclosed tag: drop the rest to avoid leaking partial reasoning.
- break;
- }
- } else {
- result.push_str(rest);
- break;
- }
- }
- result.trim().to_string()
-}
-
-// ── SSE line parser ───────────────────────────────────────────────────────────
-
-/// Parse a single SSE (Server-Sent Events) line from OpenAI-compatible providers.
-/// Handles the `data: {...}` format and `[DONE]` sentinel.
-pub(crate) fn parse_sse_line(line: &str) -> StreamResult> {
- let line = line.trim();
-
- // Skip empty lines and comments
- if line.is_empty() || line.starts_with(':') {
- return Ok(None);
- }
-
- // SSE format: "data: {...}"
- if let Some(data) = line.strip_prefix("data:") {
- let data = data.trim();
-
- // Check for [DONE] sentinel
- if data == "[DONE]" {
- return Ok(None);
- }
-
- // Parse JSON delta
- let chunk: StreamChunkResponse = serde_json::from_str(data).map_err(StreamError::Json)?;
-
- // Extract content from delta
- if let Some(choice) = chunk.choices.first() {
- if let Some(content) = &choice.delta.content {
- if !content.is_empty() {
- return Ok(Some(content.clone()));
- }
- }
- // Fallback to reasoning_content for thinking models
- if let Some(reasoning) = &choice.delta.reasoning_content {
- return Ok(Some(reasoning.clone()));
- }
- }
- }
-
- Ok(None)
-}
-
-// ── Response body parsers ─────────────────────────────────────────────────────
-
-pub(crate) fn compact_sanitized_body_snippet(body: &str) -> String {
- // super = compatible module; super::super = providers module (where sanitize_api_error lives)
- crate::openhuman::inference::provider::sanitize_api_error(body)
- .split_whitespace()
- .collect::>()
- .join(" ")
-}
-
-pub(crate) fn parse_chat_response_body(
- provider_name: &str,
- body: &str,
-) -> anyhow::Result {
- serde_json::from_str::(body).map_err(|error| {
- let snippet = compact_sanitized_body_snippet(body);
- anyhow::anyhow!(
- "{provider_name} API returned an unexpected chat-completions payload: {error}; body={snippet}"
- )
- })
-}
-
-pub(crate) fn parse_responses_response_body(
- provider_name: &str,
- body: &str,
-) -> anyhow::Result {
- serde_json::from_str::(body).map_err(|error| {
- let snippet = compact_sanitized_body_snippet(body);
- anyhow::anyhow!(
- "{provider_name} Responses API returned an unexpected payload: {error}; body={snippet}"
- )
- })
-}
-
-// ── Tool-call argument normalisation ─────────────────────────────────────────
-
-pub(crate) fn normalize_function_arguments(arguments: Option) -> String {
- match arguments {
- Some(serde_json::Value::String(raw)) => {
- if raw.trim().is_empty() {
- "{}".to_string()
- } else if serde_json::from_str::(&raw).is_ok() {
- raw
- } else {
- // OPENHUMAN-TAURI-6F: model emitted malformed JSON in
- // `function.arguments`. Log the discard so it's traceable
- // without leaking argument contents (which may contain PII).
- log::warn!(
- "[providers] normalize_function_arguments: \
- discarding malformed JSON string (len={}) — substituting {{}}",
- raw.len()
- );
- "{}".to_string()
- }
- }
- Some(serde_json::Value::Null) | None => "{}".to_string(),
- Some(other) => serde_json::to_string(&other).unwrap_or_else(|_| "{}".to_string()),
- }
-}
-
-pub(crate) fn parse_provider_tool_call_from_value(
- value: &serde_json::Value,
-) -> Option {
- if let Ok(call) = serde_json::from_value::(value.clone()) {
- if !call.name.trim().is_empty() {
- return Some(ProviderToolCall {
- id: if call.id.trim().is_empty() {
- uuid::Uuid::new_v4().to_string()
- } else {
- call.id
- },
- name: call.name,
- // Route through normalize_function_arguments so malformed
- // JSON strings in pre-deserialized ProviderToolCall values
- // receive the same guard as the function.arguments path below.
- arguments: normalize_function_arguments(Some(serde_json::Value::String(
- call.arguments,
- ))),
- // Preserve Gemini's thought_signature through the stored-history
- // recovery path so it is echoed on the next turn (TAURI-RUST-4PK).
- extra_content: call.extra_content,
- });
- }
- }
-
- let function = value.get("function")?;
- let name = function.get("name").and_then(serde_json::Value::as_str)?;
- if name.trim().is_empty() {
- return None;
- }
-
- let id = value
- .get("id")
- .and_then(serde_json::Value::as_str)
- .map(ToString::to_string)
- .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
-
- Some(ProviderToolCall {
- id,
- name: name.to_string(),
- arguments: normalize_function_arguments(function.get("arguments").cloned()),
- // Carry Gemini's thought_signature if the stored value had one
- // (TAURI-RUST-4PK).
- extra_content: value.get("extra_content").cloned(),
- })
-}
-
-pub(crate) fn parse_tool_calls_from_content_json(
- content: &str,
-) -> Option<(Option, Vec)> {
- let value = serde_json::from_str::(content).ok()?;
- let tool_calls_value = value.get("tool_calls")?.as_array()?;
- let tool_calls: Vec = tool_calls_value
- .iter()
- .filter_map(parse_provider_tool_call_from_value)
- .collect();
- if tool_calls.is_empty() {
- return None;
- }
-
- let text = value
- .get("content")
- .and_then(serde_json::Value::as_str)
- .map(str::trim)
- .filter(|s| !s.is_empty())
- .map(ToString::to_string);
-
- Some((text, tool_calls))
-}
-
-// ── Responses API helpers ─────────────────────────────────────────────────────
-
-pub(crate) fn first_nonempty(text: Option<&str>) -> Option {
- text.and_then(|value| {
- let trimmed = value.trim();
- if trimmed.is_empty() {
- None
- } else {
- Some(trimmed.to_string())
- }
- })
-}
-
-pub(crate) fn normalize_responses_role(role: &str) -> &'static str {
- match role {
- "assistant" => "assistant",
- "tool" => "assistant",
- _ => "user",
- }
-}
-
-pub(crate) fn build_responses_prompt(
- messages: &[ChatMessage],
-) -> (Option, Vec) {
- let mut instructions_parts = Vec::new();
- let mut input = Vec::new();
-
- for message in messages {
- if message.content.trim().is_empty() {
- continue;
- }
-
- if message.role == "system" {
- instructions_parts.push(message.content.clone());
- continue;
- }
-
- // Key the content-part kind on the NORMALIZED role, not the raw one.
- // `normalize_responses_role` folds `tool` (and any non-user role) into
- // `assistant`; the Responses API only accepts `output_text`/`refusal`
- // for assistant items, so the kind must track the same normalized value.
- // Reading `message.role` here instead let a `tool` turn become an
- // assistant item carrying `input_text`, which OpenAI rejects with
- // "Invalid value: 'input_text'" (Sentry TAURI-RUST-8FQ / GH #3624).
- let role = normalize_responses_role(&message.role);
- input.push(ResponsesInput {
- role: role.to_string(),
- content: vec![ResponsesContentPart {
- kind: if role == "assistant" {
- "output_text".to_string()
- } else {
- "input_text".to_string()
- },
- text: message.content.clone(),
- }],
- });
- }
-
- let instructions = if instructions_parts.is_empty() {
- None
- } else {
- Some(instructions_parts.join("\n\n"))
- };
-
- (instructions, input)
-}
-
-pub(crate) fn extract_responses_text(response: ResponsesResponse) -> Option {
- if let Some(text) = first_nonempty(response.output_text.as_deref()) {
- return Some(text);
- }
-
- for item in &response.output {
- for content in &item.content {
- if content.kind.as_deref() == Some("output_text") {
- if let Some(text) = first_nonempty(content.text.as_deref()) {
- return Some(text);
- }
- }
- }
- }
-
- for item in &response.output {
- for content in &item.content {
- if let Some(text) = first_nonempty(content.text.as_deref()) {
- return Some(text);
- }
- }
- }
-
- None
-}
-
-/// Aggregate an OpenAI Responses-API **SSE** body into the final assistant
-/// text (#3201).
-///
-/// The Codex/ChatGPT OAuth Responses endpoint
-/// (`https://chatgpt.com/backend-api/codex/responses`) rejects requests with
-/// `stream: false` (`Stream must be set to true`), so callers that target it
-/// must send `stream: true` and parse the resulting Server-Sent Event
-/// stream instead of the single JSON envelope `parse_responses_response_body`
-/// handles.
-///
-/// SSE shape (simplified — only the parts we depend on):
-///
-/// ```text
-/// event: response.output_text.delta
-/// data: {"type":"response.output_text.delta","delta":"Hello"}
-///
-/// event: response.output_text.delta
-/// data: {"type":"response.output_text.delta","delta":" world"}
-///
-/// event: response.completed
-/// data: {"type":"response.completed","response":{"output_text":"Hello world", ...}}
-///
-/// data: [DONE]
-/// ```
-///
-/// Strategy:
-///
-/// - Walk every `data: …` line (the `event:` line is informational; we route
-/// off the `type` field inside the JSON payload for resilience to the
-/// sentinel-style endings some providers emit).
-/// - `[DONE]` and empty data lines terminate the loop cleanly.
-/// - `response.output_text.delta` → push `delta` onto the accumulator.
-/// - `response.completed` → if we have a non-empty terminal
-/// `response.output_text`, prefer it (covers providers that batch the full
-/// text in the completion event and omit deltas).
-/// - Unrecognized `type` values are ignored — the spec is open-ended (tool
-/// calls, reasoning summaries, …) and we only need the assistant text here.
-///
-/// Returns the joined text on success. The error path returns the
-/// snippet-sanitised body just like [`parse_responses_response_body`] so a
-/// genuinely malformed stream is debuggable without leaking arbitrary chunk
-/// payloads.
-pub(crate) fn aggregate_responses_sse_body(
- provider_name: &str,
- body: &str,
-) -> anyhow::Result {
- let mut accumulated = String::new();
- let mut terminal_text: Option = None;
-
- for raw_line in body.split('\n') {
- let line = raw_line.trim_end_matches('\r');
- let Some(data) = line.strip_prefix("data:") else {
- continue;
- };
- let data = data.trim();
- if data.is_empty() || data == "[DONE]" {
- continue;
- }
-
- let value: serde_json::Value = match serde_json::from_str(data) {
- Ok(v) => v,
- Err(error) => {
- // Skip individual unparseable events rather than failing the
- // whole turn — providers occasionally emit comments/keepalives
- // shaped like `data: {ping}` that aren't strict JSON.
- log::debug!(
- "[providers][{provider_name}] Responses SSE: skipping unparseable event ({error})"
- );
- continue;
- }
- };
-
- let event_type = value.get("type").and_then(serde_json::Value::as_str);
- match event_type {
- Some("response.output_text.delta") => {
- if let Some(delta) = value.get("delta").and_then(serde_json::Value::as_str) {
- accumulated.push_str(delta);
- }
- }
- Some("response.completed") => {
- // Use the same "non-empty-after-trim" policy as
- // `extract_responses_text` / `first_nonempty` so a
- // whitespace-only terminal `output_text` doesn't override
- // a non-empty accumulated delta stream and collapse a
- // valid streamed reply to blank output.
- terminal_text = value
- .get("response")
- .and_then(|response| response.get("output_text"))
- .and_then(serde_json::Value::as_str)
- .and_then(|text| first_nonempty(Some(text)));
- }
- // Treat error-shaped events as a hard failure so the caller
- // surfaces the upstream reason instead of an empty completion.
- Some("response.failed") | Some("response.error") | Some("error") => {
- let snippet = compact_sanitized_body_snippet(data);
- anyhow::bail!(
- "{provider_name} Responses API stream reported a failure event: {snippet}"
- );
- }
- _ => {}
- }
- }
-
- // Prefer the terminal `response.output_text` when it carries a non-empty
- // string — some providers batch full text in `response.completed` and
- // skip per-token deltas, and others repeat what we accumulated. Either
- // way the terminal text is the authoritative version on the wire.
- // (`first_nonempty` in the match arm above already filtered whitespace.)
- if let Some(text) = terminal_text {
- return Ok(text);
- }
- if !accumulated.is_empty() {
- return Ok(accumulated);
- }
-
- let snippet = compact_sanitized_body_snippet(body);
- anyhow::bail!(
- "{provider_name} Responses API SSE stream produced no text events; body={snippet}"
- )
-}
diff --git a/src/openhuman/inference/provider/compatible_provider_impl.rs b/src/openhuman/inference/provider/compatible_provider_impl.rs
deleted file mode 100644
index a88ac85ac..000000000
--- a/src/openhuman/inference/provider/compatible_provider_impl.rs
+++ /dev/null
@@ -1,1551 +0,0 @@
-use crate::openhuman::inference::provider::traits::{
- ChatMessage, ChatRequest as ProviderChatRequest, ChatResponse as ProviderChatResponse,
- Provider, StreamChunk, StreamError, StreamOptions, StreamResult, ToolCall as ProviderToolCall,
-};
-use async_trait::async_trait;
-use futures_util::{stream, StreamExt};
-
-use super::compatible_dump::{dump_prompt_if_enabled, dump_response_if_enabled, reserve_dump_seq};
-use super::compatible_parse::normalize_function_arguments;
-use super::compatible_stream::sse_bytes_to_chunks;
-use super::compatible_types::{
- ApiChatRequest, ApiChatResponse, Message, MessageContent, NativeChatRequest,
- OpenAiStreamOptions,
-};
-use super::{AuthStyle, OpenAiCompatibleProvider};
-
-#[async_trait]
-impl Provider for OpenAiCompatibleProvider {
- fn telemetry_provider_id(&self) -> String {
- // The configured provider slug ("openai", "groq", "venice", ...),
- // normalized for stable telemetry labels.
- self.name.trim().to_ascii_lowercase().replace(' ', "-")
- }
-
- fn capabilities(&self) -> crate::openhuman::inference::provider::traits::ProviderCapabilities {
- crate::openhuman::inference::provider::traits::ProviderCapabilities {
- native_tool_calling: self.native_tool_calling,
- vision: self.vision,
- }
- }
-
- fn prompt_cache_capabilities(
- &self,
- ) -> crate::openhuman::inference::provider::traits::PromptCacheCapabilities {
- // Derive from the configured slug — conservative for unknown / custom
- // providers (#3939). The OpenHuman backend wraps this provider but
- // declares its own grouping-aware caps on `OpenHumanBackendProvider`.
- super::prompt_cache_for_compatible_slug(&self.name)
- }
-
- async fn chat_with_system(
- &self,
- system_prompt: Option<&str>,
- message: &str,
- model: &str,
- temperature: f64,
- ) -> anyhow::Result {
- let credential = self.credential_for_request()?;
-
- let mut messages = Vec::new();
-
- if self.merge_system_into_user {
- let content = match system_prompt {
- Some(sys) => format!("{sys}\n\n{message}"),
- None => message.to_string(),
- };
- messages.push(Message {
- role: "user".to_string(),
- content: MessageContent::from_chat_text(&content),
- });
- } else {
- if let Some(sys) = system_prompt {
- messages.push(Message {
- role: "system".to_string(),
- content: sys.into(),
- });
- }
- messages.push(Message {
- role: "user".to_string(),
- content: MessageContent::from_chat_text(message),
- });
- }
-
- let request = ApiChatRequest {
- model: model.to_string(),
- messages,
- temperature: self.effective_temperature(model, temperature),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- };
-
- let url = self.chat_completions_url();
-
- let mut fallback_messages = Vec::new();
- if let Some(system_prompt) = system_prompt {
- fallback_messages.push(ChatMessage::system(system_prompt));
- }
- fallback_messages.push(ChatMessage::user(message));
- let fallback_messages = if self.merge_system_into_user {
- Self::flatten_system_messages(&fallback_messages)
- } else {
- fallback_messages
- };
-
- if self.responses_api_primary {
- return self
- .chat_via_responses(credential, &fallback_messages, model, None)
- .await;
- }
-
- let response = match self
- .apply_auth_header(self.http_client().post(&url).json(&request), credential)
- .send()
- .await
- {
- Ok(response) => response,
- Err(chat_error) => {
- if self.responses_fallback_active() {
- let detail = super::super::format_error_chain(&chat_error);
- return self
- .chat_via_responses(credential, &fallback_messages, model, None)
- .await
- .map_err(|responses_err| {
- let fb = super::super::format_anyhow_chain(&responses_err);
- anyhow::anyhow!(
- "{} chat completions transport error: {detail} (responses fallback failed: {fb})",
- self.name
- )
- });
- }
-
- return Err(chat_error.into());
- }
- };
-
- if !response.status().is_success() {
- let status = response.status();
- let error = response.text().await?;
- let sanitized = super::super::sanitize_api_error(&error);
-
- if let Some(err) = self.completion_only_404_guard(status, &sanitized, model) {
- return Err(err);
- }
-
- if let Some(err) = self.not_chat_capable_guard(status, &sanitized, model) {
- return Err(err);
- }
-
- if status == reqwest::StatusCode::NOT_FOUND && self.responses_fallback_active() {
- return self
- .chat_via_responses(credential, &fallback_messages, model, None)
- .await
- .map_err(|responses_err| {
- let fb = super::super::format_anyhow_chain(&responses_err);
- anyhow::anyhow!(
- "{} API error ({status}): {sanitized} (chat completions unavailable; responses fallback failed: {fb})",
- self.name
- )
- });
- }
-
- let status_str = status.as_u16().to_string();
- let message = self.enrich_404_message(
- format!("{} API error ({status}): {sanitized}", self.name),
- status,
- );
- if super::super::is_backend_auth_failure(self.name.as_str(), status) {
- super::super::publish_backend_session_expired(
- "chat_completions",
- self.name.as_str(),
- status,
- &message,
- );
- } else if super::super::is_budget_exhausted_http_400(status, &error) {
- super::super::log_budget_exhausted_http_400(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_local_provider_no_model_loaded(status, &error) {
- // Local inference server up but no model loaded — pure local
- // user-state, demote instead of paging (TAURI-RUST-DMQ).
- super::super::log_local_provider_no_model_loaded(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_custom_openai_upstream_bad_request_http_400(
- self.name.as_str(),
- status,
- &error,
- ) {
- super::super::log_custom_openai_upstream_bad_request_http_400(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_access_policy_denied_http_403(status, &error) {
- super::super::log_provider_access_policy_denied_http_403(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_config_rejection_http(
- status,
- self.name.as_str(),
- &error,
- ) {
- super::super::log_provider_config_rejection(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_byo_provider_auth_failure_http(
- self.name.as_str(),
- status,
- &error,
- ) {
- super::super::log_byo_provider_auth_failure(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_insufficient_credits_402(status, &error) {
- // Insufficient-credits 402: the user's own BYO provider account
- // is out of balance — a flat billing fact, not a reservation-
- // window error, so there is NO local max_tokens lever to apply.
- // Demote to info instead of paging on every retry; this is the
- // complete classification for a genuinely-unpreventable
- // BYO-balance condition (TAURI-RUST-4QF — DeepSeek "Insufficient
- // Balance"; same class as the native_chat arm added for -C62).
- super::super::log_provider_insufficient_credits_402(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_moderation_rejection_http_400(status, &error) {
- // External content-moderation proxy ("Ombudsman") refused the
- // prompt with a 400 + verdict — well-formed request, external
- // safety guard, no client lever. Demote like the native_chat
- // ladder so the looping triage agent doesn't flood Sentry
- // (TAURI-RUST-ECR).
- super::super::log_provider_moderation_rejection(
- "chat_completions",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::should_report_provider_http_failure(status) {
- crate::core::observability::report_error(
- message.as_str(),
- "llm_provider",
- "chat_completions",
- &[
- ("provider", self.name.as_str()),
- ("model", model),
- ("status", status_str.as_str()),
- ("failure", "non_2xx"),
- ],
- );
- }
- anyhow::bail!(message);
- }
-
- let body = response.text().await?;
- let chat_response = super::compatible_parse::parse_chat_response_body(&self.name, &body)?;
-
- chat_response
- .choices
- .into_iter()
- .next()
- .map(|c| {
- if c.message.tool_calls.is_some()
- && c.message.tool_calls.as_ref().is_some_and(|t| !t.is_empty())
- {
- serde_json::to_string(&c.message)
- .unwrap_or_else(|_| c.message.effective_content())
- } else {
- c.message.effective_content()
- }
- })
- .ok_or_else(|| anyhow::anyhow!("No response from {}", self.name))
- }
-
- async fn chat_with_history(
- &self,
- messages: &[ChatMessage],
- model: &str,
- temperature: f64,
- ) -> anyhow::Result {
- let credential = self.credential_for_request()?;
-
- let effective_messages = if self.merge_system_into_user {
- Self::flatten_system_messages(messages)
- } else {
- messages.to_vec()
- };
- let api_messages: Vec = effective_messages
- .iter()
- .map(|m| Message {
- role: m.role.clone(),
- content: MessageContent::from_chat_text(&m.content),
- })
- .collect();
-
- let request = ApiChatRequest {
- model: model.to_string(),
- messages: api_messages,
- temperature: self.effective_temperature(model, temperature),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- };
-
- let url = self.chat_completions_url();
- if self.responses_api_primary {
- return self
- .chat_via_responses(credential, &effective_messages, model, None)
- .await;
- }
-
- let response = match self
- .apply_auth_header(self.http_client().post(&url).json(&request), credential)
- .send()
- .await
- {
- Ok(response) => response,
- Err(chat_error) => {
- if self.responses_fallback_active() {
- let detail = super::super::format_error_chain(&chat_error);
- return self
- .chat_via_responses(credential, &effective_messages, model, None)
- .await
- .map_err(|responses_err| {
- let fb = super::super::format_anyhow_chain(&responses_err);
- anyhow::anyhow!(
- "{} chat completions transport error: {detail} (responses fallback failed: {fb})",
- self.name
- )
- });
- }
-
- return Err(chat_error.into());
- }
- };
-
- if !response.status().is_success() {
- let status = response.status();
-
- if status == reqwest::StatusCode::NOT_FOUND {
- let error = response.text().await?;
- let sanitized = super::super::sanitize_api_error(&error);
-
- if let Some(err) = self.completion_only_404_guard(status, &sanitized, model) {
- return Err(err);
- }
-
- if self.responses_fallback_active() {
- return self
- .chat_via_responses(credential, &effective_messages, model, None)
- .await
- .map_err(|responses_err| {
- let fb = super::super::format_anyhow_chain(&responses_err);
- anyhow::anyhow!(
- "{} API error ({status}): {sanitized} (chat completions unavailable; responses fallback failed: {fb})",
- self.name
- )
- });
- }
-
- let enriched = self.enrich_404_message(
- format!("{} API error ({status}): {sanitized}", self.name),
- status,
- );
- return Err(anyhow::anyhow!("{enriched}"));
- }
-
- let err = super::super::api_error(&self.name, response).await;
- let err_str = err.to_string();
- if Self::is_not_chat_capable_model(status, &err_str) {
- return Err(anyhow::anyhow!(
- self.not_chat_capable_model_message(model, &err_str)
- ));
- }
- let enriched = self.enrich_404_message(format!("{err:#}"), status);
- return Err(anyhow::anyhow!("{enriched}"));
- }
-
- let body = response.text().await?;
- let chat_response = super::compatible_parse::parse_chat_response_body(&self.name, &body)?;
-
- chat_response
- .choices
- .into_iter()
- .next()
- .map(|c| {
- if c.message.tool_calls.is_some()
- && c.message.tool_calls.as_ref().is_some_and(|t| !t.is_empty())
- {
- serde_json::to_string(&c.message)
- .unwrap_or_else(|_| c.message.effective_content())
- } else {
- c.message.effective_content()
- }
- })
- .ok_or_else(|| anyhow::anyhow!("No response from {}", self.name))
- }
-
- async fn chat_with_tools(
- &self,
- messages: &[ChatMessage],
- tools: &[serde_json::Value],
- model: &str,
- temperature: f64,
- ) -> anyhow::Result {
- let credential = self.credential_for_request()?;
-
- let effective_messages = if self.merge_system_into_user {
- Self::flatten_system_messages(messages)
- } else {
- messages.to_vec()
- };
- let api_messages: Vec = effective_messages
- .iter()
- .map(|m| Message {
- role: m.role.clone(),
- content: MessageContent::from_chat_text(&m.content),
- })
- .collect();
-
- let request = ApiChatRequest {
- model: model.to_string(),
- messages: api_messages,
- temperature: self.effective_temperature(model, temperature),
- stream: Some(false),
- tools: if tools.is_empty() {
- None
- } else {
- Some(tools.to_vec())
- },
- tool_choice: if tools.is_empty() {
- None
- } else {
- Some("auto".to_string())
- },
- };
-
- let url = self.chat_completions_url();
- let response = match self
- .apply_auth_header(self.http_client().post(&url).json(&request), credential)
- .send()
- .await
- {
- Ok(response) => response,
- Err(error) => {
- tracing::warn!(
- "{} native tool call transport failed: {error}; falling back to history path",
- self.name
- );
- let text = self.chat_with_history(messages, model, temperature).await?;
- return Ok(ProviderChatResponse {
- text: Some(text),
- tool_calls: vec![],
- usage: None,
- reasoning_content: None,
- });
- }
- };
-
- if !response.status().is_success() {
- return Err(super::super::api_error(&self.name, response).await);
- }
-
- let body = response.text().await?;
- let chat_response = super::compatible_parse::parse_chat_response_body(&self.name, &body)?;
- let usage = Self::extract_usage(&chat_response);
- let choice = chat_response
- .choices
- .into_iter()
- .next()
- .ok_or_else(|| anyhow::anyhow!("No response from {}", self.name))?;
-
- let text = choice.message.effective_content_optional();
- let reasoning_content = choice
- .message
- .reasoning_content
- .as_deref()
- .map(str::trim)
- .filter(|s| !s.is_empty())
- .map(ToString::to_string);
- let tool_calls = choice
- .message
- .tool_calls
- .unwrap_or_default()
- .into_iter()
- .filter_map(|tc| {
- let function = tc.function?;
- let name = function.name?;
- let arguments = normalize_function_arguments(function.arguments);
- Some(ProviderToolCall {
- // Treat an empty-string id like a missing one: some providers
- // (DashScope/GMI) return `""` rather than omitting it, and an
- // empty `tool_call_id` is rejected by the upstream tool-message
- // ordering check on the next turn.
- id: tc
- .id
- .filter(|s| !s.is_empty())
- .unwrap_or_else(|| uuid::Uuid::new_v4().to_string()),
- name,
- arguments,
- // Non-streaming response: preserve Gemini's thought_signature
- // so it round-trips on the next turn (TAURI-RUST-4PK).
- extra_content: tc.extra_content,
- })
- })
- .collect::>();
-
- tracing::debug!(
- has_reasoning_content = reasoning_content.is_some(),
- reasoning_content_chars = reasoning_content.as_ref().map_or(0, |r| r.chars().count()),
- tool_calls = tool_calls.len(),
- "[provider:chat] reasoning_content capture (non-streaming)"
- );
-
- Ok(ProviderChatResponse {
- text,
- tool_calls,
- usage,
- reasoning_content,
- })
- }
-
- async fn chat(
- &self,
- request: ProviderChatRequest<'_>,
- model: &str,
- temperature: f64,
- ) -> anyhow::Result {
- let credential = self.credential_for_request()?;
-
- let tools = Self::convert_tool_specs(request.tools);
- let effective_messages = if self.merge_system_into_user {
- Self::flatten_system_messages(request.messages)
- } else {
- request.messages.to_vec()
- };
-
- if self.responses_api_primary {
- let response_messages = if request.tools.is_some() {
- Self::with_prompt_guided_tool_instructions(request.messages, request.tools)
- } else {
- effective_messages.clone()
- };
- let text = self
- .chat_via_responses(credential, &response_messages, model, request.max_tokens)
- .await?;
- if let Some(tx) = request.stream {
- let _ = tx
- .send(
- crate::openhuman::inference::provider::ProviderDelta::TextDelta {
- delta: text.clone(),
- },
- )
- .await;
- }
- return Ok(ProviderChatResponse {
- text: Some(text),
- tool_calls: vec![],
- usage: None,
- reasoning_content: None,
- });
- }
-
- if let Some(tx) = request.stream {
- let native_request = NativeChatRequest {
- model: model.to_string(),
- messages: Self::convert_messages_for_native(&effective_messages),
- temperature: self.effective_temperature(model, temperature),
- stream: Some(true),
- tool_choice: tools.as_ref().map(|_| "auto".to_string()),
- tools: tools.clone(),
- thread_id: self.outbound_thread_id(),
- stream_options: Some(OpenAiStreamOptions {
- include_usage: true,
- }),
- options: self.build_ollama_options(),
- // Omitted for endpoints whose OpenAI-compat surface 400s on the
- // field (Google Gemini shim — TAURI-RUST-4PJ); the reactive
- // retry below stays as defense-in-depth for unknown providers.
- frequency_penalty: self.effective_frequency_penalty(),
- max_tokens: request.max_tokens,
- };
- let stream_dump_seq = reserve_dump_seq();
- dump_prompt_if_enabled(&self.name, model, stream_dump_seq, &native_request);
- match self
- .stream_native_chat(credential, &native_request, tx, stream_dump_seq)
- .await
- {
- Ok(resp) => return Ok(resp),
- Err(err) => {
- let err_str = err.to_string();
- if tools.is_some() && Self::err_supports_no_tools_retry(&err_str) {
- log::info!(
- "[stream] {} model does not support tools — retrying streaming without tools",
- self.name,
- );
- let retry_request = NativeChatRequest {
- tools: None,
- tool_choice: None,
- ..native_request.clone()
- };
- match self
- .stream_native_chat(credential, &retry_request, tx, stream_dump_seq)
- .await
- {
- Ok(resp) => return Ok(resp),
- Err(retry_err) => {
- log::warn!(
- "[stream] {} retry without tools also failed, falling back to non-streaming: {}",
- self.name,
- retry_err
- );
- }
- }
- } else if Self::err_indicates_frequency_penalty_unsupported(&err_str) {
- log::info!(
- "[stream] {} rejected frequency_penalty — retrying streaming without it",
- self.name,
- );
- let retry_request = NativeChatRequest {
- frequency_penalty: None,
- ..native_request.clone()
- };
- match self
- .stream_native_chat(credential, &retry_request, tx, stream_dump_seq)
- .await
- {
- Ok(resp) => return Ok(resp),
- Err(retry_err) => {
- log::warn!(
- "[stream] {} retry without frequency_penalty also failed, falling back to non-streaming: {}",
- self.name,
- retry_err
- );
- }
- }
- } else {
- log::warn!(
- "[stream] {} streaming chat failed, falling back to non-streaming: {}",
- self.name,
- err
- );
- }
- }
- }
- }
-
- let thread_id = self.outbound_thread_id();
- log::debug!(
- "[provider:{}] chat() outbound thread_id={} model={}",
- self.name,
- thread_id.as_deref().unwrap_or(""),
- model
- );
- let native_request = NativeChatRequest {
- model: model.to_string(),
- messages: Self::convert_messages_for_native(&effective_messages),
- temperature: self.effective_temperature(model, temperature),
- stream: Some(false),
- tool_choice: tools.as_ref().map(|_| "auto".to_string()),
- tools,
- thread_id,
- stream_options: None,
- options: self.build_ollama_options(),
- // The buffered non-streaming path omits `frequency_penalty` for maximum
- // compatibility. The streaming path carries it and retries without on rejection.
- frequency_penalty: None,
- max_tokens: request.max_tokens,
- };
- let dump_seq = reserve_dump_seq();
- dump_prompt_if_enabled(&self.name, model, dump_seq, &native_request);
-
- let url = self.chat_completions_url();
- let response = match self
- .apply_auth_header(
- self.http_client().post(&url).json(&native_request),
- credential,
- )
- .send()
- .await
- {
- Ok(response) => response,
- Err(chat_error) => {
- if self.responses_fallback_active() {
- let detail = super::super::format_error_chain(&chat_error);
- return self
- .chat_via_responses(
- credential,
- &effective_messages,
- model,
- request.max_tokens,
- )
- .await
- .map(|text| ProviderChatResponse {
- text: Some(text),
- tool_calls: vec![],
- usage: None,
- reasoning_content: None,
- })
- .map_err(|responses_err| {
- let fb = super::super::format_anyhow_chain(&responses_err);
- anyhow::anyhow!(
- "{} native chat transport error: {detail} (responses fallback failed: {fb})",
- self.name
- )
- });
- }
-
- return Err(chat_error.into());
- }
- };
-
- if !response.status().is_success() {
- let status = response.status();
- let error = response.text().await?;
- let sanitized = super::super::sanitize_api_error(&error);
-
- if Self::is_native_tool_schema_unsupported(status, &sanitized) {
- let fallback_messages =
- Self::with_prompt_guided_tool_instructions(request.messages, request.tools);
- let text = self
- .chat_with_history(&fallback_messages, model, temperature)
- .await?;
- return Ok(ProviderChatResponse {
- text: Some(text),
- tool_calls: vec![],
- usage: None,
- reasoning_content: None,
- });
- }
-
- if let Some(err) = self.completion_only_404_guard(status, &sanitized, model) {
- return Err(err);
- }
-
- if let Some(err) = self.not_chat_capable_guard(status, &sanitized, model) {
- return Err(err);
- }
-
- if status == reqwest::StatusCode::NOT_FOUND && self.responses_fallback_active() {
- return self
- .chat_via_responses(credential, &effective_messages, model, request.max_tokens)
- .await
- .map(|text| ProviderChatResponse {
- text: Some(text),
- tool_calls: vec![],
- usage: None,
- reasoning_content: None,
- })
- .map_err(|responses_err| {
- let fb = super::super::format_anyhow_chain(&responses_err);
- anyhow::anyhow!(
- "{} API error ({status}): {sanitized} (chat completions unavailable; responses fallback failed: {fb})",
- self.name
- )
- });
- }
-
- let status_str = status.as_u16().to_string();
- let mut message = self.enrich_404_message(
- format!("{} API error ({status}): {sanitized}", self.name),
- status,
- );
- if super::super::is_budget_exhausted_http_400(status, &error) {
- super::super::log_budget_exhausted_http_400(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_local_provider_no_model_loaded(status, &error) {
- // Local inference server (LM Studio etc.) is up but has no model
- // loaded — pure local user-state, nothing we sent is malformed.
- // Demote instead of paging on every retry, and replace the body
- // with actionable "load a model" guidance (TAURI-RUST-DMQ,
- // mirrors the embeddings #3688 special-case).
- super::super::log_local_provider_no_model_loaded(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- message = super::super::local_provider_no_model_loaded_user_message();
- } else if super::super::is_custom_openai_upstream_bad_request_http_400(
- self.name.as_str(),
- status,
- &error,
- ) {
- super::super::log_custom_openai_upstream_bad_request_http_400(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_access_policy_denied_http_403(status, &error) {
- super::super::log_provider_access_policy_denied_http_403(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_config_rejection_http(
- status,
- self.name.as_str(),
- &error,
- ) {
- super::super::log_provider_config_rejection(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_byo_provider_auth_failure_http(
- self.name.as_str(),
- status,
- &error,
- ) {
- super::super::log_byo_provider_auth_failure(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_insufficient_credits_402(status, &error) {
- // Residual 402 after the request already caps max_tokens: the
- // user's own BYO provider balance is exhausted — no local lever,
- // so demote to info instead of paging on every retry
- // (TAURI-RUST-C62).
- super::super::log_provider_insufficient_credits_402(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_provider_quota_exhausted(&error) {
- // Upstream plan quota spent (e.g. Kiro `MONTHLY_REQUEST_COUNT`),
- // sometimes wrapped in a 500 envelope so the credits matcher
- // above (402-gated) misses it — no local lever, demote instead
- // of paging once per memory-extraction retry (TAURI-RUST-C9A).
- super::super::log_provider_quota_exhausted(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::is_ollama_cloud_internal_500(self.name.as_str(), status, &error)
- {
- // ollama.com hosted-inference 500: opaque `Internal Server Error
- // (ref: )` from the cloud backend for `*:cloud` models.
- // Non-deterministic, byte-identical request succeeds when the
- // cloud is healthy → no client lever; the reliable-provider layer
- // retries + falls back. Demote to info and replace the ref body
- // with actionable guidance (TAURI-RUST-5MV).
- super::super::log_ollama_cloud_internal_500(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- message = super::super::ollama_cloud_internal_500_user_message(Some(model), status);
- } else if super::super::is_provider_moderation_rejection_http_400(status, &error) {
- // External content-moderation proxy ("Ombudsman") refused the
- // prompt with a 400 + verdict
- // (`{"error":"Message rejected by Ombudsman","score":80}`).
- // Well-formed request, external safety guard, no local lever —
- // the triage agent re-issues the same prompt every turn and
- // floods report_error (400 ∉ the transient set). Demote to info
- // while the error still propagates so retry/fallback runs
- // unchanged (TAURI-RUST-ECR).
- super::super::log_provider_moderation_rejection(
- "native_chat",
- self.name.as_str(),
- Some(model),
- status,
- );
- } else if super::super::should_report_provider_http_failure(status) {
- crate::core::observability::report_error(
- message.as_str(),
- "llm_provider",
- "native_chat",
- &[
- ("provider", self.name.as_str()),
- ("model", model),
- ("status", status_str.as_str()),
- ("failure", "non_2xx"),
- ],
- );
- }
- anyhow::bail!(message);
- }
-
- let response_bytes = response.bytes().await?;
- dump_response_if_enabled(&self.name, model, dump_seq, &response_bytes);
- let native_response: ApiChatResponse = serde_json::from_slice(&response_bytes)
- .map_err(|err| anyhow::anyhow!("{} response parse error: {err}", self.name))?;
- Self::parse_native_response(native_response, &self.name)
- }
-
- fn supports_native_tools(&self) -> bool {
- self.native_tool_calling
- }
-
- fn supports_streaming(&self) -> bool {
- true
- }
-
- fn stream_chat_with_system(
- &self,
- system_prompt: Option<&str>,
- message: &str,
- model: &str,
- temperature: f64,
- options: StreamOptions,
- ) -> stream::BoxStream<'static, StreamResult> {
- let credential = match self.credential_for_request() {
- Ok(value) => value.map(str::to_string),
- Err(err) => {
- return stream::once(async move { Err(StreamError::Provider(err.to_string())) })
- .boxed();
- }
- };
-
- let mut messages = Vec::new();
- if let Some(sys) = system_prompt {
- messages.push(Message {
- role: "system".to_string(),
- content: sys.into(),
- });
- }
- messages.push(Message {
- role: "user".to_string(),
- content: MessageContent::from_chat_text(message),
- });
-
- let request = ApiChatRequest {
- model: model.to_string(),
- messages,
- temperature: self.effective_temperature(model, temperature),
- stream: Some(options.enabled),
- tools: None,
- tool_choice: None,
- };
-
- let url = self.chat_completions_url();
- let client = self.http_client();
- let auth_header = self.auth_header.clone();
- let extra_headers = self.extra_headers.clone();
- let openrouter_attribution_headers = self.openrouter_attribution_headers();
- let provider_name = self.name.clone();
- let model_owned = model.to_string();
-
- let (tx, rx) = tokio::sync::mpsc::channel::>(100);
-
- tokio::spawn(async move {
- let mut req_builder = client.post(&url).json(&request);
-
- req_builder = match (&auth_header, credential.as_deref()) {
- (AuthStyle::None, _) | (_, None) => req_builder,
- (AuthStyle::Bearer, Some(credential)) => {
- req_builder.header("Authorization", format!("Bearer {credential}"))
- }
- (AuthStyle::XApiKey, Some(credential)) => {
- req_builder.header("x-api-key", credential)
- }
- (AuthStyle::Anthropic, Some(credential)) => req_builder
- .header("x-api-key", credential)
- .header("anthropic-version", "2023-06-01"),
- (AuthStyle::Custom(header), Some(credential)) => {
- req_builder.header(header, credential)
- }
- };
-
- for (name, value) in &extra_headers {
- req_builder = req_builder.header(name.as_str(), value.as_str());
- }
- if let Some((referer, title)) = openrouter_attribution_headers {
- req_builder = req_builder
- .header("HTTP-Referer", referer)
- .header("X-OpenRouter-Title", title);
- }
-
- req_builder = req_builder.header("Accept", "text/event-stream");
-
- let response = match req_builder.send().await {
- Ok(r) => r,
- Err(e) => {
- let detail = e.to_string();
- // F7: a flaky-network timeout / reset / TLS-handshake EOF on
- // the streaming send is transient transport noise the
- // socket layer recovers from — gate it so those blips stop
- // paging Sentry. A non-transient transport failure (DNS
- // misconfig, unexpected protocol error) still reports.
- if crate::core::observability::contains_transient_transport_phrase(&detail) {
- tracing::debug!(
- domain = "llm_provider",
- operation = "stream_chat",
- provider = provider_name.as_str(),
- model = model_owned.as_str(),
- failure = "transport",
- "[llm_provider] stream_chat transient transport error — not reporting to Sentry: {detail}"
- );
- } else {
- crate::core::observability::report_error(
- detail.as_str(),
- "llm_provider",
- "stream_chat",
- &[
- ("provider", provider_name.as_str()),
- ("model", model_owned.as_str()),
- ("failure", "transport"),
- ],
- );
- }
- let _ = tx.send(Err(StreamError::Http(e))).await;
- return;
- }
- };
-
- if !response.status().is_success() {
- let status = response.status();
- let status_str = status.as_u16().to_string();
- let raw_error = match response.text().await {
- Ok(e) => e,
- Err(_) => format!("HTTP error: {}", status),
- };
- let sanitized_error =
- crate::openhuman::inference::provider::sanitize_api_error(&raw_error);
- let message = format!("{}: {}", status, sanitized_error);
- if crate::openhuman::inference::provider::is_budget_exhausted_http_400(
- status, &raw_error,
- ) {
- crate::openhuman::inference::provider::log_budget_exhausted_http_400(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_local_provider_no_model_loaded(
- status, &raw_error,
- ) {
- // Local inference server up but no model loaded — pure local
- // user-state, demote instead of paging (TAURI-RUST-DMQ).
- crate::openhuman::inference::provider::log_local_provider_no_model_loaded(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_custom_openai_upstream_bad_request_http_400(
- provider_name.as_str(),
- status,
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_custom_openai_upstream_bad_request_http_400(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_access_policy_denied_http_403(
- status,
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_provider_access_policy_denied_http_403(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_config_rejection_http(
- status,
- provider_name.as_str(),
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_provider_config_rejection(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_backend_error_code_owned(
- provider_name.as_str(),
- &raw_error,
- ) {
- // F4/F2: managed-backend errorCode (#870) — backend-owned;
- // the FE must not double-report. Malformed BAD_REQUEST is
- // excluded and reaches the status gate (it pages — F8).
- crate::openhuman::inference::provider::log_backend_error_code_owned(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- &raw_error,
- );
- } else if crate::openhuman::inference::provider::is_byo_provider_auth_failure_http(
- provider_name.as_str(),
- status,
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_byo_provider_auth_failure(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_insufficient_credits_402(
- status,
- &raw_error,
- ) {
- // Insufficient-credits 402: the user's own BYO provider
- // account is out of balance — a flat billing fact, not a
- // reservation-window error, so there is NO local max_tokens
- // lever to apply. Demote to info instead of paging on every
- // retry; complete classification for a genuinely-
- // unpreventable BYO-balance condition
- // (TAURI-RUST-4QF — DeepSeek "Insufficient Balance").
- crate::openhuman::inference::provider::log_provider_insufficient_credits_402(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_moderation_rejection_http_400(
- status,
- &raw_error,
- ) {
- // External content-moderation proxy ("Ombudsman") refused
- // the prompt with a 400 + verdict — well-formed request,
- // external safety guard, no client lever. Demote like the
- // native_chat ladder so the looping triage agent doesn't
- // flood Sentry (TAURI-RUST-ECR).
- crate::openhuman::inference::provider::log_provider_moderation_rejection(
- "stream_chat",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::should_report_provider_http_failure(
- status,
- ) {
- crate::core::observability::report_error(
- message.as_str(),
- "llm_provider",
- "stream_chat",
- &[
- ("provider", provider_name.as_str()),
- ("model", model_owned.as_str()),
- ("status", status_str.as_str()),
- ("failure", "non_2xx"),
- ],
- );
- }
- let _ = tx.send(Err(StreamError::Provider(message))).await;
- return;
- }
-
- let mut chunk_stream = sse_bytes_to_chunks(response, options.count_tokens);
- while let Some(chunk) = chunk_stream.next().await {
- if tx.send(chunk).await.is_err() {
- break;
- }
- }
- });
-
- stream::unfold(rx, |mut rx| async move {
- rx.recv().await.map(|chunk| (chunk, rx))
- })
- .boxed()
- }
-
- fn stream_chat_with_history(
- &self,
- messages: &[ChatMessage],
- model: &str,
- temperature: f64,
- options: StreamOptions,
- ) -> stream::BoxStream<'static, StreamResult> {
- let credential = match self.credential_for_request() {
- Ok(value) => value.map(str::to_string),
- Err(err) => {
- return stream::once(async move { Err(StreamError::Provider(err.to_string())) })
- .boxed();
- }
- };
-
- let effective_messages = if self.merge_system_into_user {
- Self::flatten_system_messages(messages)
- } else {
- messages.to_vec()
- };
- let api_messages = effective_messages
- .into_iter()
- .map(|message| Message {
- role: message.role,
- content: MessageContent::from_chat_text(&message.content),
- })
- .collect();
-
- let request = ApiChatRequest {
- model: model.to_string(),
- messages: api_messages,
- temperature: self.effective_temperature(model, temperature),
- stream: Some(options.enabled),
- tools: None,
- tool_choice: None,
- };
-
- let url = self.chat_completions_url();
- let client = self.http_client();
- let auth_header = self.auth_header.clone();
- let extra_headers = self.extra_headers.clone();
- let openrouter_attribution_headers = self.openrouter_attribution_headers();
- let provider_name = self.name.clone();
- let model_owned = model.to_string();
-
- let (tx, rx) = tokio::sync::mpsc::channel::>(100);
-
- tokio::spawn(async move {
- let mut req_builder = client.post(&url).json(&request);
- req_builder = match (&auth_header, credential.as_deref()) {
- (AuthStyle::None, _) | (_, None) => req_builder,
- (AuthStyle::Bearer, Some(credential)) => {
- req_builder.header("Authorization", format!("Bearer {credential}"))
- }
- (AuthStyle::XApiKey, Some(credential)) => {
- req_builder.header("x-api-key", credential)
- }
- (AuthStyle::Anthropic, Some(credential)) => req_builder
- .header("x-api-key", credential)
- .header("anthropic-version", "2023-06-01"),
- (AuthStyle::Custom(header), Some(credential)) => {
- req_builder.header(header, credential)
- }
- };
- for (name, value) in &extra_headers {
- req_builder = req_builder.header(name.as_str(), value.as_str());
- }
- if let Some((referer, title)) = openrouter_attribution_headers {
- req_builder = req_builder
- .header("HTTP-Referer", referer)
- .header("X-OpenRouter-Title", title);
- }
- req_builder = req_builder.header("Accept", "text/event-stream");
-
- let response = match req_builder.send().await {
- Ok(response) => response,
- Err(error) => {
- let detail = error.to_string();
- // F7: gate transient transport blips (timeout / reset / TLS
- // handshake EOF) so flaky-network failures on the streaming
- // send stop paging Sentry; non-transient transport errors
- // still report.
- if crate::core::observability::contains_transient_transport_phrase(&detail) {
- tracing::debug!(
- domain = "llm_provider",
- operation = "stream_chat_history",
- provider = provider_name.as_str(),
- model = model_owned.as_str(),
- failure = "transport",
- "[llm_provider] stream_chat_history transient transport error — not reporting to Sentry: {detail}"
- );
- } else {
- crate::core::observability::report_error(
- detail.as_str(),
- "llm_provider",
- "stream_chat_history",
- &[
- ("provider", provider_name.as_str()),
- ("model", model_owned.as_str()),
- ("failure", "transport"),
- ],
- );
- }
- let _ = tx.send(Err(StreamError::Http(error))).await;
- return;
- }
- };
-
- if !response.status().is_success() {
- let status = response.status();
- let status_str = status.as_u16().to_string();
- let raw_error = match response.text().await {
- Ok(error) => error,
- Err(_) => format!("HTTP error: {status}"),
- };
- let sanitized_error =
- crate::openhuman::inference::provider::sanitize_api_error(&raw_error);
- let message = format!("{status}: {sanitized_error}");
- if crate::openhuman::inference::provider::is_budget_exhausted_http_400(
- status, &raw_error,
- ) {
- crate::openhuman::inference::provider::log_budget_exhausted_http_400(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_local_provider_no_model_loaded(
- status, &raw_error,
- ) {
- // Local inference server up but no model loaded — pure local
- // user-state, demote instead of paging (TAURI-RUST-DMQ).
- crate::openhuman::inference::provider::log_local_provider_no_model_loaded(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_custom_openai_upstream_bad_request_http_400(
- provider_name.as_str(),
- status,
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_custom_openai_upstream_bad_request_http_400(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_access_policy_denied_http_403(
- status,
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_provider_access_policy_denied_http_403(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_config_rejection_http(
- status,
- provider_name.as_str(),
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_provider_config_rejection(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_backend_error_code_owned(
- provider_name.as_str(),
- &raw_error,
- ) {
- // F4/F2: managed-backend errorCode (#870) — backend-owned;
- // the FE must not double-report. Malformed BAD_REQUEST is
- // excluded and reaches the status gate (it pages — F8).
- crate::openhuman::inference::provider::log_backend_error_code_owned(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- &raw_error,
- );
- } else if crate::openhuman::inference::provider::is_byo_provider_auth_failure_http(
- provider_name.as_str(),
- status,
- &raw_error,
- ) {
- crate::openhuman::inference::provider::log_byo_provider_auth_failure(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_insufficient_credits_402(
- status,
- &raw_error,
- ) {
- // Insufficient-credits 402: the user's own BYO provider
- // account is out of balance — a flat billing fact, not a
- // reservation-window error, so there is NO local max_tokens
- // lever to apply. Demote to info instead of paging on every
- // retry; complete classification for a genuinely-
- // unpreventable BYO-balance condition
- // (TAURI-RUST-4QF — DeepSeek "Insufficient Balance").
- crate::openhuman::inference::provider::log_provider_insufficient_credits_402(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::is_provider_moderation_rejection_http_400(
- status,
- &raw_error,
- ) {
- // External content-moderation proxy ("Ombudsman") refused
- // the prompt with a 400 + verdict — well-formed request,
- // external safety guard, no client lever. Demote like the
- // native_chat ladder so the looping triage agent doesn't
- // flood Sentry (TAURI-RUST-ECR).
- crate::openhuman::inference::provider::log_provider_moderation_rejection(
- "stream_chat_history",
- provider_name.as_str(),
- Some(model_owned.as_str()),
- status,
- );
- } else if crate::openhuman::inference::provider::should_report_provider_http_failure(
- status,
- ) {
- crate::core::observability::report_error(
- message.as_str(),
- "llm_provider",
- "stream_chat_history",
- &[
- ("provider", provider_name.as_str()),
- ("model", model_owned.as_str()),
- ("status", status_str.as_str()),
- ("failure", "non_2xx"),
- ],
- );
- }
- let _ = tx.send(Err(StreamError::Provider(message))).await;
- return;
- }
-
- let mut chunk_stream = sse_bytes_to_chunks(response, options.count_tokens);
- while let Some(chunk) = chunk_stream.next().await {
- if tx.send(chunk).await.is_err() {
- break;
- }
- }
- });
-
- stream::unfold(rx, |mut rx| async move {
- rx.recv().await.map(|chunk| (chunk, rx))
- })
- .boxed()
- }
-
- async fn warmup(&self) -> anyhow::Result<()> {
- if let Some(credential) = self.credential.as_ref() {
- let url = self.chat_completions_url();
- let _ = self
- .apply_auth_header(self.http_client().get(&url), Some(credential.as_str()))
- .send()
- .await?;
- }
- Ok(())
- }
-
- fn is_local_provider(&self) -> bool {
- self.local_provider_kind.is_some()
- }
-
- /// Resolve the effective context window for pre-dispatch trimming.
- ///
- /// For cloud (non-local) providers this is the static model table. For
- /// local providers the trained-maximum table over-estimates the window
- /// the runtime actually enforces — LM Studio lets the user load a model
- /// with a smaller `n_ctx`, and budgeting against the max overflows it
- /// (#3550 / Sentry TAURI-RUST-6V0). So for LM Studio we query the native
- /// `/api/v0/models` endpoint for the model's loaded context window, and
- /// fall back to the provider-profile default when it's unavailable.
- async fn effective_context_window(&self, model: &str) -> Option {
- use crate::openhuman::inference::local::profile::LocalProviderKind;
- let Some(kind) = self.local_provider_kind else {
- return crate::openhuman::inference::context_window_for_model(model);
- };
- // LM Studio: the OpenAI-compat /v1/models hides the context window, but
- // the native /api/v0/models reports the loaded n_ctx. Prefer it.
- if kind == LocalProviderKind::LmStudio {
- if let Some(window) = self.lm_studio_loaded_context_window(model).await {
- return Some(window);
- }
- }
- // Local fallback: pattern table → provider-profile default. Ensures
- // unknown local models still get trimmed instead of skipped.
- crate::openhuman::inference::model_context::context_window_for_model_with_local_fallback(
- model,
- Some(kind),
- )
- }
-
- /// Authoritative runtime-loaded window: only the value the local runtime
- /// genuinely reports. Today that is LM Studio's native `/api/v0/models`
- /// `loaded_context_length`. For every other case — cloud, llama.cpp / vLLM
- /// (no loaded window endpoint), or a missing probe — we return `None`
- /// rather than a guess, so the engine's hard pre-dispatch abort never fires
- /// on an estimated window (Codex P1 review on PR #3771 / TAURI-RUST-6V0).
- async fn loaded_context_window(&self, model: &str) -> Option {
- use crate::openhuman::inference::local::profile::LocalProviderKind;
- if self.local_provider_kind == Some(LocalProviderKind::LmStudio) {
- return self.lm_studio_loaded_context_window(model).await;
- }
- None
- }
-}
-
-impl OpenAiCompatibleProvider {
- /// Best-effort fetch of the model's loaded context window from LM Studio's
- /// native `/api/v0/models` endpoint. Returns `None` on any transport /
- /// parse error or when the model reports no window — callers then fall
- /// back to the profile default. Never panics, never propagates errors.
- async fn lm_studio_loaded_context_window(&self, model: &str) -> Option {
- use crate::openhuman::inference::local::lm_studio;
- let url = lm_studio::lm_studio_native_models_url(&self.base_url);
- let resp = match self
- .apply_auth_header(self.http_client().get(&url), self.credential.as_deref())
- .send()
- .await
- {
- Ok(resp) => resp,
- Err(err) => {
- tracing::debug!(
- provider = %self.name,
- model,
- error = %err,
- "[lm-studio] native models probe transport error; using profile default context window"
- );
- return None;
- }
- };
- if !resp.status().is_success() {
- tracing::debug!(
- provider = %self.name,
- status = resp.status().as_u16(),
- "[lm-studio] native models probe non-success; using profile default context window"
- );
- return None;
- }
- let parsed: lm_studio::LmStudioNativeModelsResponse = match resp.json().await {
- Ok(parsed) => parsed,
- Err(err) => {
- tracing::debug!(
- provider = %self.name,
- model,
- error = %err,
- "[lm-studio] native models probe parse error; using profile default context window"
- );
- return None;
- }
- };
- let window = lm_studio::lm_studio_context_window_for(&parsed, model);
- tracing::debug!(
- provider = %self.name,
- model,
- loaded_context_window = window.unwrap_or(0),
- "[lm-studio] resolved loaded context window for pre-dispatch trimming"
- );
- window
- }
-}
diff --git a/src/openhuman/inference/provider/compatible_repeat.rs b/src/openhuman/inference/provider/compatible_repeat.rs
deleted file mode 100644
index e16eb5138..000000000
--- a/src/openhuman/inference/provider/compatible_repeat.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-/// `frequency_penalty` applied to streaming chat-completions requests.
-///
-/// Autoregressive models have a self-reinforcing bias toward repeating spans
-/// already in their context; with no penalty a momentary repeat can spiral into
-/// the same line emitted until the output-token cap (degenerate decoding). A
-/// small positive penalty damps that loop without harming coherence. Carried on
-/// the streaming path (where those loops occur — long autonomous turns) and
-/// retried without it if a strict provider rejects it; the buffered
-/// non-streaming fallback omits it for maximum compatibility. Skipped in
-/// serialisation when `None` so providers that don't accept the field are
-/// unaffected.
-pub(super) const CHAT_FREQUENCY_PENALTY: f64 = 0.3;
-
-/// Consecutive identical substantial lines that trip the in-generation repeat
-/// cutoff. Autoregressive models can latch onto a line and emit it verbatim
-/// until the token cap (observed: 234× the same sentence in one response).
-/// `frequency_penalty` / stronger model tiers only lower the odds — they don't
-/// prevent it — so this is the deterministic, model-agnostic stop. Set well
-/// above any legitimate repetition.
-pub(crate) const STREAM_REPEAT_THRESHOLD: u32 = 6;
-/// Minimum trimmed length for a line to count toward [`STREAM_REPEAT_THRESHOLD`].
-/// Keeps short, legitimately-repeated lines (`}`, blank-ish code) from tripping
-/// it; degenerate spirals are long sentences well over this.
-pub(super) const MIN_REPEAT_LINE_CHARS: usize = 16;
-
-/// Detects in-generation repetition degeneration on the streaming path so the
-/// reader can abort the stream and truncate the blob. Trips after
-/// [`STREAM_REPEAT_THRESHOLD`] consecutive identical substantial lines; blank
-/// separator lines are ignored, so `"sentence\n\nsentence\n\n…"` still trips.
-#[derive(Default)]
-pub(crate) struct StreamRepeatDetector {
- current_line: String,
- last_line: Option,
- consecutive: u32,
-}
-
-impl StreamRepeatDetector {
- pub(super) fn new() -> Self {
- Self::default()
- }
-
- /// Feed one streamed text delta. Returns `true` once the same substantial
- /// line has repeated [`STREAM_REPEAT_THRESHOLD`] times back-to-back.
- pub(super) fn observe(&mut self, delta: &str) -> bool {
- for ch in delta.chars() {
- if ch == '\n' {
- if self.finalize_line() {
- return true;
- }
- } else {
- self.current_line.push(ch);
- }
- }
- false
- }
-
- fn finalize_line(&mut self) -> bool {
- let line = self.current_line.trim().to_string();
- self.current_line.clear();
- if line.is_empty() {
- return false;
- }
- if line.chars().count() < MIN_REPEAT_LINE_CHARS {
- self.last_line = Some(line);
- self.consecutive = 1;
- return false;
- }
- if self.last_line.as_deref() == Some(line.as_str()) {
- self.consecutive += 1;
- } else {
- self.last_line = Some(line);
- self.consecutive = 1;
- }
- self.consecutive >= STREAM_REPEAT_THRESHOLD
- }
-}
diff --git a/src/openhuman/inference/provider/compatible_request.rs b/src/openhuman/inference/provider/compatible_request.rs
deleted file mode 100644
index 38b7ac9cf..000000000
--- a/src/openhuman/inference/provider/compatible_request.rs
+++ /dev/null
@@ -1,374 +0,0 @@
-use crate::openhuman::inference::provider::traits::ChatMessage;
-use reqwest::{
- header::{HeaderMap, HeaderValue, USER_AGENT},
- Client,
-};
-
-use crate::openhuman::inference::provider::{temperature, thread_context};
-
-use super::{AuthStyle, OpenAiCompatibleProvider};
-
-const OPENROUTER_REFERER: &str = "https://openhuman.ai";
-const OPENROUTER_TITLE: &str = "OpenHuman";
-
-impl OpenAiCompatibleProvider {
- /// Build the Ollama-specific `options` block for the request body.
- /// Returns `None` when no `num_ctx` override is configured.
- pub(super) fn build_ollama_options(&self) -> Option {
- self.ollama_num_ctx
- .map(|num_ctx| super::compatible_types::OllamaOptions {
- num_ctx: Some(num_ctx),
- })
- }
-
- /// Resolve the effective temperature for `model`. Returns `None` when the
- /// model matches a pattern in `temperature_unsupported_models` (causing the
- /// field to be omitted from the serialised request). Otherwise yields the
- /// per-workload override if one was configured, else the caller's value.
- pub(super) fn effective_temperature(&self, model: &str, temperature: f64) -> Option {
- if self
- .temperature_unsupported_models
- .iter()
- .any(|pat| temperature::glob_match(pat, model))
- {
- tracing::debug!(
- "[provider:{}] model='{}' matched temperature_unsupported_models — omitting temperature",
- self.name,
- model
- );
- None
- } else {
- Some(self.temperature_override.unwrap_or(temperature))
- }
- }
-
- /// Resolve the `frequency_penalty` to send on streaming chat requests.
- ///
- /// Returns `None` — omitting the field entirely — for endpoints whose
- /// OpenAI-compatible surface rejects the parameter with an HTTP 400
- /// (see [`endpoint_rejects_frequency_penalty`]). Google's Gemini shim
- /// (`generativelanguage.googleapis.com/v1beta/openai`) is the known case:
- /// it 400s on the unknown field, which previously forced every streaming
- /// call into a wasted reject→retry round-trip and one Sentry report
- /// (TAURI-RUST-4PJ). Omitting it up front removes the failing request at
- /// the source. Every other provider keeps the configured penalty.
- pub(super) fn effective_frequency_penalty(&self) -> Option {
- if endpoint_rejects_frequency_penalty(&self.base_url) {
- tracing::debug!(
- "[provider:{}] endpoint rejects frequency_penalty — omitting it",
- self.name
- );
- None
- } else {
- Some(super::compatible_repeat::CHAT_FREQUENCY_PENALTY)
- }
- }
-
- /// Read the ambient `thread_id` only when this provider has been
- /// opted in via [`with_openhuman_thread_id`]. Returns `None` for
- /// every third-party provider so the field is omitted by
- /// `skip_serializing_if`.
- pub(super) fn outbound_thread_id(&self) -> Option {
- if self.emit_openhuman_thread_id {
- thread_context::current_thread_id()
- } else {
- None
- }
- }
-
- /// Collect all `system` role messages, concatenate their content,
- /// and prepend to the first `user` message. Drop all system messages.
- /// Used for providers (e.g. MiniMax) that reject `role: system`.
- pub(super) fn flatten_system_messages(messages: &[ChatMessage]) -> Vec {
- let system_content: String = messages
- .iter()
- .filter(|m| m.role == "system")
- .map(|m| m.content.as_str())
- .collect::>()
- .join("\n\n");
-
- if system_content.is_empty() {
- return messages.to_vec();
- }
-
- let mut result: Vec = messages
- .iter()
- .filter(|m| m.role != "system")
- .cloned()
- .collect();
-
- if let Some(first_user) = result.iter_mut().find(|m| m.role == "user") {
- first_user.content = format!("{system_content}\n\n{}", first_user.content);
- } else {
- // No user message found: insert a synthetic user message with system content
- result.insert(0, ChatMessage::user(&system_content));
- }
-
- result
- }
-
- pub(super) fn http_client(&self) -> Client {
- if let Some(ua) = self.user_agent.as_deref() {
- let mut headers = HeaderMap::new();
- if let Ok(value) = HeaderValue::from_str(ua) {
- headers.insert(USER_AGENT, value);
- }
-
- // Platform-appropriate TLS backend — see [`crate::openhuman::tls`].
- let builder = crate::openhuman::tls::tls_client_builder()
- .timeout(super::compatible_timeout::request_timeout())
- .connect_timeout(super::compatible_timeout::connect_timeout())
- .default_headers(headers);
- let builder = crate::openhuman::config::apply_runtime_proxy_to_builder(
- builder,
- "provider.compatible",
- );
-
- return builder.build().unwrap_or_else(|error| {
- tracing::warn!("Failed to build proxied timeout client with user-agent: {error}");
- crate::openhuman::tls::tls_client_builder()
- .build()
- .unwrap_or_default()
- });
- }
-
- // Platform-appropriate TLS backend — see [`crate::openhuman::tls`].
- let builder = crate::openhuman::tls::tls_client_builder()
- .timeout(super::compatible_timeout::request_timeout())
- .connect_timeout(super::compatible_timeout::connect_timeout());
- let builder = crate::openhuman::config::apply_runtime_proxy_to_builder(
- builder,
- "provider.compatible",
- );
- builder.build().unwrap_or_else(|error| {
- tracing::warn!("Failed to build proxied timeout client: {error}");
- crate::openhuman::tls::tls_client_builder()
- .build()
- .unwrap_or_default()
- })
- }
-
- /// Build the full URL for chat completions, detecting if base_url already includes the path.
- /// This allows custom providers with non-standard endpoints (e.g., VolcEngine ARK uses
- /// `/api/coding/v3/chat/completions` instead of `/v1/chat/completions`).
- pub(super) fn chat_completions_url(&self) -> String {
- let has_full_endpoint = reqwest::Url::parse(&self.base_url)
- .map(|url| {
- url.path()
- .trim_end_matches('/')
- .ends_with("/chat/completions")
- })
- .unwrap_or_else(|_| {
- self.base_url
- .trim_end_matches('/')
- .ends_with("/chat/completions")
- });
-
- let url = if has_full_endpoint {
- self.base_url.clone()
- } else {
- format!("{}/chat/completions", self.base_url)
- };
- let url = self.apply_extra_query_params(url);
- log::info!(
- "[provider:{}] outbound chat/completions -> {}",
- self.name,
- url
- );
- url
- }
-
- pub(super) fn path_ends_with(&self, suffix: &str) -> bool {
- if let Ok(url) = reqwest::Url::parse(&self.base_url) {
- return url.path().trim_end_matches('/').ends_with(suffix);
- }
-
- self.base_url.trim_end_matches('/').ends_with(suffix)
- }
-
- pub(super) fn has_explicit_api_path(&self) -> bool {
- let Ok(url) = reqwest::Url::parse(&self.base_url) else {
- return false;
- };
-
- let path = url.path().trim_end_matches('/');
- !path.is_empty() && path != "/"
- }
-
- /// Build the full URL for responses API, detecting if base_url already includes the path.
- pub(super) fn responses_url(&self) -> String {
- let url = if self.path_ends_with("/responses") {
- self.base_url.clone()
- } else {
- let normalized_base = self.base_url.trim_end_matches('/');
-
- // If chat endpoint is explicitly configured, derive sibling responses endpoint.
- if let Some(prefix) = normalized_base.strip_suffix("/chat/completions") {
- format!("{prefix}/responses")
- } else if self.has_explicit_api_path() {
- // If an explicit API path already exists (e.g. /v1, /openai, /api/coding/v3),
- // append responses directly to avoid duplicate /v1 segments.
- format!("{normalized_base}/responses")
- } else {
- format!("{normalized_base}/v1/responses")
- }
- };
-
- self.apply_extra_query_params(url)
- }
-
- pub(super) fn apply_extra_query_params(&self, url: String) -> String {
- if self.extra_query_params.is_empty() {
- return url;
- }
-
- if let Ok(mut parsed) = reqwest::Url::parse(&url) {
- {
- let mut pairs = parsed.query_pairs_mut();
- for (name, value) in &self.extra_query_params {
- pairs.append_pair(name, value);
- }
- }
- return parsed.to_string();
- }
-
- let mut output = url;
- for (index, (name, value)) in self.extra_query_params.iter().enumerate() {
- let separator = if output.contains('?') || index > 0 {
- '&'
- } else {
- '?'
- };
- output.push(separator);
- output.push_str(name);
- output.push('=');
- output.push_str(value);
- }
- output
- }
-
- pub(super) fn tool_specs_to_openai_format(
- tools: &[crate::openhuman::tools::ToolSpec],
- ) -> Vec {
- tools
- .iter()
- .map(|tool| {
- serde_json::json!({
- "type": "function",
- "function": {
- "name": tool.name,
- "description": tool.description,
- "parameters": tool.parameters
- }
- })
- })
- .collect()
- }
-
- pub(super) fn credential_for_request(&self) -> anyhow::Result> {
- if matches!(&self.auth_header, AuthStyle::None) {
- return Ok(None);
- }
-
- self.credential
- .as_deref()
- .map(str::trim)
- .filter(|credential| !credential.is_empty())
- .map(Some)
- .ok_or_else(|| {
- anyhow::anyhow!(
- "{} API key not set. Configure via the web UI or set the appropriate env var.",
- self.name
- )
- })
- }
-
- pub(super) fn apply_auth_header(
- &self,
- req: reqwest::RequestBuilder,
- credential: Option<&str>,
- ) -> reqwest::RequestBuilder {
- let req = match (&self.auth_header, credential) {
- (AuthStyle::None, _) => req,
- (_, None) => req,
- (AuthStyle::Bearer, Some(credential)) => {
- req.header("Authorization", format!("Bearer {credential}"))
- }
- (AuthStyle::XApiKey, Some(credential)) => req.header("x-api-key", credential),
- (AuthStyle::Anthropic, Some(credential)) => req
- .header("x-api-key", credential)
- .header("anthropic-version", "2023-06-01"),
- (AuthStyle::Custom(header), Some(credential)) => req.header(header, credential),
- };
- self.apply_openrouter_attribution_headers(self.apply_extra_headers(req))
- }
-
- pub(super) fn apply_extra_headers(
- &self,
- mut req: reqwest::RequestBuilder,
- ) -> reqwest::RequestBuilder {
- if let Some(user_agent) = self.user_agent.as_deref() {
- req = req.header(USER_AGENT, user_agent);
- }
- for (name, value) in &self.extra_headers {
- req = req.header(name.as_str(), value.as_str());
- }
- req
- }
-
- pub(super) fn is_openrouter_endpoint(&self) -> bool {
- if self.name.eq_ignore_ascii_case("openrouter") {
- return true;
- }
-
- reqwest::Url::parse(&self.base_url)
- .ok()
- .and_then(|url| url.host_str().map(str::to_ascii_lowercase))
- .is_some_and(|host| host == "openrouter.ai" || host.ends_with(".openrouter.ai"))
- }
-
- pub(super) fn apply_openrouter_attribution_headers(
- &self,
- req: reqwest::RequestBuilder,
- ) -> reqwest::RequestBuilder {
- if let Some((referer, title)) = self.openrouter_attribution_headers() {
- req.header("HTTP-Referer", referer)
- .header("X-OpenRouter-Title", title)
- } else {
- req
- }
- }
-
- pub(super) fn openrouter_attribution_headers(&self) -> Option<(&'static str, &'static str)> {
- self.is_openrouter_endpoint()
- .then_some((OPENROUTER_REFERER, OPENROUTER_TITLE))
- }
-}
-
-/// Endpoint hosts whose OpenAI-compatible surface rejects the
-/// `frequency_penalty` sampling field with an HTTP 400. Matched against the
-/// request host (exact or as a registrable-domain suffix), so a BYOK provider
-/// pointed at the same upstream is covered too. Single source of truth — add a
-/// host here if another strict endpoint surfaces the same rejection.
-const FREQUENCY_PENALTY_UNSUPPORTED_HOSTS: &[&str] = &["generativelanguage.googleapis.com"];
-
-/// Whether `base_url`'s host is known to reject `frequency_penalty`.
-///
-/// Google's Gemini OpenAI-compat shim
-/// (`https://generativelanguage.googleapis.com/v1beta/openai`) 400s on the
-/// unknown field (`Unknown name "frequency_penalty": Cannot find field`),
-/// which previously forced every streaming call into a wasted reject→retry
-/// and one Sentry report per first attempt (TAURI-RUST-4PJ). Detecting it by
-/// host — rather than provider slug — also covers BYOK providers configured
-/// against the same endpoint.
-pub(super) fn endpoint_rejects_frequency_penalty(base_url: &str) -> bool {
- let host = reqwest::Url::parse(base_url)
- .ok()
- .and_then(|url| url.host_str().map(str::to_ascii_lowercase));
- let Some(host) = host else {
- return false;
- };
- FREQUENCY_PENALTY_UNSUPPORTED_HOSTS
- .iter()
- .any(|known| host == *known || host.ends_with(&format!(".{known}")))
-}
diff --git a/src/openhuman/inference/provider/compatible_stream.rs b/src/openhuman/inference/provider/compatible_stream.rs
deleted file mode 100644
index 4209e1357..000000000
--- a/src/openhuman/inference/provider/compatible_stream.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-//! SSE streaming support for the OpenAI-compatible provider.
-//!
-//! Converts a raw `reqwest::Response` byte stream into a typed
-//! `StreamChunk` stream via Server-Sent Events parsing.
-
-use crate::openhuman::inference::provider::traits::{StreamChunk, StreamError, StreamResult};
-use futures_util::{stream, StreamExt};
-
-use super::compatible_parse::parse_sse_line;
-
-/// Convert SSE byte stream to text chunks.
-pub(crate) fn sse_bytes_to_chunks(
- response: reqwest::Response,
- count_tokens: bool,
-) -> stream::BoxStream<'static, StreamResult> {
- // Create a channel to send chunks
- let (tx, rx) = tokio::sync::mpsc::channel::>(100);
-
- tokio::spawn(async move {
- // Buffer for incomplete lines
- let mut buffer = String::new();
-
- // Get response body as bytes stream
- match response.error_for_status_ref() {
- Ok(_) => {}
- Err(e) => {
- let _ = tx.send(Err(StreamError::Http(e))).await;
- return;
- }
- }
-
- let mut bytes_stream = response.bytes_stream();
-
- while let Some(item) = bytes_stream.next().await {
- match item {
- Ok(bytes) => {
- // Convert bytes to string and process line by line
- let text = match String::from_utf8(bytes.to_vec()) {
- Ok(t) => t,
- Err(e) => {
- let _ = tx
- .send(Err(StreamError::InvalidSse(format!(
- "Invalid UTF-8: {}",
- e
- ))))
- .await;
- break;
- }
- };
-
- buffer.push_str(&text);
-
- // Process complete lines
- while let Some(pos) = buffer.find('\n') {
- let line: String = buffer.drain(..=pos).collect();
-
- match parse_sse_line(&line) {
- Ok(Some(content)) => {
- let mut chunk = StreamChunk::delta(content);
- if count_tokens {
- chunk = chunk.with_token_estimate();
- }
- if tx.send(Ok(chunk)).await.is_err() {
- return; // Receiver dropped
- }
- }
- Ok(None) => {}
- Err(e) => {
- let _ = tx.send(Err(e)).await;
- return;
- }
- }
- }
- }
- Err(e) => {
- let _ = tx.send(Err(StreamError::Http(e))).await;
- break;
- }
- }
- }
-
- // Send final chunk
- let _ = tx.send(Ok(StreamChunk::final_chunk())).await;
- });
-
- // Convert channel receiver to stream
- stream::unfold(rx, |mut rx| async {
- rx.recv().await.map(|chunk| (chunk, rx))
- })
- .boxed()
-}
diff --git a/src/openhuman/inference/provider/compatible_stream_native.rs b/src/openhuman/inference/provider/compatible_stream_native.rs
deleted file mode 100644
index 5415fab0f..000000000
--- a/src/openhuman/inference/provider/compatible_stream_native.rs
+++ /dev/null
@@ -1,823 +0,0 @@
-use crate::openhuman::inference::provider::traits::ChatResponse as ProviderChatResponse;
-use crate::openhuman::inference::provider::ProviderDelta;
-
-use super::compatible_dump::dump_response_if_enabled;
-use super::compatible_repeat::{StreamRepeatDetector, STREAM_REPEAT_THRESHOLD};
-use super::compatible_types::{
- ApiChatResponse, ApiUsage, Choice, NativeChatRequest, OpenHumanMeta, ResponseMessage,
- StreamChunkResponse, StreamingToolCall, ToolCall,
-};
-use super::OpenAiCompatibleProvider;
-
-impl OpenAiCompatibleProvider {
- /// Streaming variant of the native-tools chat path.
- ///
- /// Sends the request with `stream: true`, consumes the upstream SSE
- /// stream chunk by chunk, forwards fine-grained `ProviderDelta`
- /// events to the caller-supplied sender, and returns the aggregated
- /// [`ProviderChatResponse`] once the stream ends.
- pub(super) async fn stream_native_chat(
- &self,
- credential: Option<&str>,
- native_request: &NativeChatRequest,
- delta_tx: &tokio::sync::mpsc::Sender,
- dump_seq: u64,
- ) -> anyhow::Result {
- use futures_util::StreamExt;
-
- let url = self.chat_completions_url();
- log::info!(
- "[stream] {} POST {} (stream=true, tools={})",
- self.name,
- url,
- native_request.tools.as_ref().map_or(0, |t| t.len()),
- );
-
- // Captured at request send so the empty-2xx-stream diagnostic
- // below can report elapsed_ms — a fast empty stream points at a
- // backend reject, a slow one at an upstream stall / timeout.
- let stream_started_at = std::time::Instant::now();
-
- let response = self
- .apply_auth_header(
- self.http_client()
- .post(&url)
- .header("Accept", "text/event-stream")
- .json(native_request),
- credential,
- )
- .send()
- .await?;
-
- if !response.status().is_success() {
- let status = response.status();
- let status_str = status.as_u16().to_string();
- let body = response.text().await.unwrap_or_default();
- let sanitized = super::super::sanitize_api_error(&body);
- let mut message = format!(
- "{} streaming API error ({}): {}",
- self.name, status, sanitized
- );
- if super::super::is_budget_exhausted_http_400(status, &body) {
- super::super::log_budget_exhausted_http_400(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- );
- } else if super::super::is_custom_openai_upstream_bad_request_http_400(
- self.name.as_str(),
- status,
- &body,
- ) {
- super::super::log_custom_openai_upstream_bad_request_http_400(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- );
- } else if super::super::is_provider_access_policy_denied_http_403(status, &body) {
- super::super::log_provider_access_policy_denied_http_403(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- );
- } else if super::super::is_provider_config_rejection_http(
- status,
- self.name.as_str(),
- &body,
- ) {
- super::super::log_provider_config_rejection(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- );
- } else if Self::is_native_tool_schema_unsupported(status, &body) {
- log::info!(
- "[stream] {} model rejected tool schema (status={}) — caller will retry without tools",
- self.name,
- status,
- );
- } else if Self::err_indicates_frequency_penalty_unsupported(&body) {
- // Endpoint rejects `frequency_penalty` (e.g. an unknown strict
- // provider not yet covered by `effective_frequency_penalty`).
- // The caller retries without the field and succeeds, so this is
- // a self-healed recoverable condition — log, don't page
- // (TAURI-RUST-4PJ). Defense-in-depth behind the prevent-at-source
- // omission; the bail! below still drives the retry path.
- log::info!(
- "[stream] {} rejected frequency_penalty (status={}) — caller will retry without it",
- self.name,
- status,
- );
- } else if super::super::is_backend_error_code_owned(self.name.as_str(), &body) {
- // F4/F2: managed-backend errorCode (#870) — backend-owned, FE
- // must not double-report. Malformed BAD_REQUEST is excluded and
- // falls through to the status gate below.
- super::super::log_backend_error_code_owned(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- &body,
- );
- } else if super::super::is_byo_provider_auth_failure_http(
- self.name.as_str(),
- status,
- &body,
- ) {
- super::super::log_byo_provider_auth_failure(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- );
- } else if super::super::is_provider_insufficient_credits_402(status, &body) {
- // Insufficient-credits 402: the user's own BYO provider account
- // is out of balance — a flat billing fact, not a reservation-
- // window error, so there is NO local max_tokens lever to apply.
- // Demote to info instead of paging on every retry; this is the
- // complete classification for a genuinely-unpreventable
- // BYO-balance condition
- // (TAURI-RUST-4QF — DeepSeek "Insufficient Balance").
- super::super::log_provider_insufficient_credits_402(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- );
- } else if super::super::is_ollama_cloud_internal_500(self.name.as_str(), status, &body)
- {
- // ollama.com hosted-inference 500 on the streaming path — same
- // provider-internal, no-client-lever condition as the native
- // cascade. Demote to info and swap the opaque ref body for
- // actionable guidance (TAURI-RUST-5MV).
- super::super::log_ollama_cloud_internal_500(
- "streaming_chat",
- self.name.as_str(),
- Some(native_request.model.as_str()),
- status,
- );
- message = super::super::ollama_cloud_internal_500_user_message(
- Some(native_request.model.as_str()),
- status,
- );
- } else if super::super::should_report_provider_http_failure(status) {
- crate::core::observability::report_error(
- message.as_str(),
- "llm_provider",
- "streaming_chat",
- &[
- ("provider", self.name.as_str()),
- ("model", native_request.model.as_str()),
- ("status", status_str.as_str()),
- ("failure", "non_2xx"),
- ],
- );
- }
- anyhow::bail!(message);
- }
-
- let is_sse = response
- .headers()
- .get(reqwest::header::CONTENT_TYPE)
- .and_then(|v| v.to_str().ok())
- .map(|ct| ct.to_ascii_lowercase().contains("text/event-stream"))
- .unwrap_or(false);
- if !is_sse {
- log::warn!(
- "[stream] {} upstream replied with non-SSE content-type; falling back to JSON parse \
- (no token deltas reach the UI)",
- self.name,
- );
- let response_bytes = response.bytes().await?;
- let body_bytes_received = response_bytes.len();
- dump_response_if_enabled(&self.name, &native_request.model, dump_seq, &response_bytes);
- let api_resp: ApiChatResponse = serde_json::from_slice(&response_bytes)
- .map_err(|err| anyhow::anyhow!("{} response parse error: {err}", self.name))?;
-
- // Mirror the SSE-branch empty-2xx-stream diagnostic (#3335 /
- // #3386) on the buffered JSON path. The same upstream
- // collapse to `AgentError::EmptyProviderResponse` is
- // reachable here when a managed backend returns 200 with a
- // content-less JSON payload (credit exhaustion served as
- // JSON instead of SSE, or an upstream stall flushed as an
- // empty completion). Without this sibling guard the warn
- // would only fire on the SSE branch and the buffered case
- // would silently miss the very signal we're trying to
- // capture.
- let buffered_is_empty = api_resp
- .choices
- .first()
- .map(|c| {
- let m = &c.message;
- let content_empty = m.content.as_deref().is_none_or(str::is_empty);
- let reasoning_empty = m.reasoning_content.as_deref().is_none_or(str::is_empty);
- let tool_calls_empty = m.tool_calls.as_ref().is_none_or(|t| t.is_empty());
- let function_call_empty = m.function_call.is_none();
- content_empty && reasoning_empty && tool_calls_empty && function_call_empty
- })
- .unwrap_or(true);
- if buffered_is_empty {
- let elapsed_ms = stream_started_at.elapsed().as_millis() as u64;
- log::warn!(
- "[stream] {} empty 2xx buffered JSON — model={} elapsed_ms={} body_bytes={} has_usage={} has_openhuman_meta={}",
- self.name,
- native_request.model,
- elapsed_ms,
- body_bytes_received,
- api_resp.usage.is_some(),
- api_resp.openhuman.is_some(),
- );
- }
- return Self::parse_native_response(api_resp, &self.name);
- }
-
- let mut text_accum = String::new();
- let mut thinking_accum = String::new();
- let mut tool_accum: std::collections::BTreeMap =
- std::collections::BTreeMap::new();
- let mut last_usage: Option = None;
- let mut last_openhuman: Option = None;
-
- let mut bytes_stream = response.bytes_stream();
- let mut buffer = String::new();
- let mut repeat_detector = StreamRepeatDetector::new();
- let mut degenerate_repeat = false;
- // Forensic counters for the empty-2xx-stream diagnostic below
- // (issue #3335 / #3386). Both are append-only, never read by
- // request path logic — strictly observability.
- //
- // `body_bytes_received` is the count of body bytes yielded by
- // `bytes_stream()`. This crate builds reqwest without the
- // `gzip` / `brotli` / `zstd` / `deflate` features (see
- // root Cargo.toml), so no Content-Encoding decompression happens
- // and the count matches what's on the wire. The neutral name
- // (rather than `raw_bytes` / `decoded_bytes`) sidesteps the
- // ambiguity an operator would otherwise hit reading the log.
- let mut sse_chunks_parsed: usize = 0;
- let mut body_bytes_received: usize = 0;
-
- // #4269: bound each SSE read with a per-chunk inactivity watchdog. The
- // window RESETS on every received chunk, so a legitimately long response
- // that keeps emitting tokens is never cut — only a stream that goes
- // silent for the whole window (an upstream that flushed 200 then stalled
- // / half-closed the body) trips it. Without this the read parks on
- // `next().await` until the blunt whole-request timeout fires — which
- // operators are told to raise up to 3600s for long research turns
- // (#3856) — presenting as the indefinite RESPONSE-phase hang in #4269.
- // The bail classifies as retryable, so `ReliableProvider` replays it.
- let idle_window = self.stream_idle_timeout;
- 'stream: loop {
- let item = match tokio::time::timeout(idle_window, bytes_stream.next()).await {
- Ok(Some(item)) => item,
- Ok(None) => break 'stream,
- Err(_elapsed) => {
- let idle_secs = idle_window.as_secs();
- log::warn!(
- "[stream] {} watchdog fired — no SSE data for {}s (elapsed_ms={} sse_chunks={} body_bytes={}); aborting stalled stream for retry",
- self.name,
- idle_secs,
- stream_started_at.elapsed().as_millis(),
- sse_chunks_parsed,
- body_bytes_received,
- );
- anyhow::bail!(
- "{} streaming watchdog: no response data for {}s — aborting stalled stream for retry",
- self.name,
- idle_secs,
- );
- }
- };
- let bytes = item?;
- body_bytes_received += bytes.len();
- buffer.push_str(&String::from_utf8_lossy(&bytes));
-
- while let Some(sep_idx) = buffer.find("\n\n") {
- let event = buffer[..sep_idx].to_string();
- buffer.drain(..sep_idx + 2);
-
- // In-band SSE error frame. The response status flushed 200
- // before the upstream call, so the managed backend delivers
- // post-flush errors — including instant 4xx/429/413 whose typed
- // `errorCode` (#870) is now stamped on the frame, see
- // backend `routes/inference.ts` — as `event: error\ndata: {…}`.
- // Surface it as a streaming-envelope error string so the
- // `errorCode` classifier + Sentry golden rule run downstream,
- // instead of skipping it as an unparseable chunk (which would
- // aggregate to empty and surface as "empty response").
- if let Some(message) = sse_error_frame_bail_message(
- self.name.as_str(),
- Some(native_request.model.as_str()),
- &event,
- ) {
- anyhow::bail!(message);
- }
-
- for line in event.lines() {
- let line = line.trim();
- if line.is_empty() || line.starts_with(':') {
- continue;
- }
- let Some(data) = line.strip_prefix("data:") else {
- continue;
- };
- let data = data.trim();
- if data == "[DONE]" {
- // `[DONE]` is the terminal SSE sentinel — the response is
- // complete. Stop reading immediately rather than looping
- // back to another watchdog-armed read: a provider that
- // sends `[DONE]` but lingers the socket would otherwise
- // trip the inactivity watchdog and fail a finished
- // response as a retryable stall (#4269 watchdog review).
- break 'stream;
- }
-
- let chunk: StreamChunkResponse = match serde_json::from_str(data) {
- Ok(v) => {
- sse_chunks_parsed += 1;
- v
- }
- Err(e) => {
- log::debug!(
- "[stream] {} skipping unparseable chunk: {} — data={}",
- self.name,
- e,
- data,
- );
- continue;
- }
- };
-
- if let Some(usage) = chunk.usage {
- last_usage = Some(usage);
- }
- if let Some(meta) = chunk.openhuman {
- last_openhuman = Some(meta);
- }
-
- for choice in chunk.choices {
- if let Some(content) = choice.delta.content.as_ref() {
- if !content.is_empty() {
- text_accum.push_str(content);
- self.forward_delta(
- delta_tx,
- ProviderDelta::TextDelta {
- delta: content.clone(),
- },
- )
- .await?;
- if repeat_detector.observe(content) {
- log::warn!(
- "[stream] {} degenerate repetition detected (≥{} identical lines) — aborting generation, truncating (text_chars={})",
- self.name,
- STREAM_REPEAT_THRESHOLD,
- text_accum.chars().count(),
- );
- degenerate_repeat = true;
- break 'stream;
- }
- }
- }
- if let Some(reasoning) = choice.delta.reasoning_content.as_ref() {
- if !reasoning.is_empty() {
- thinking_accum.push_str(reasoning);
- self.forward_delta(
- delta_tx,
- ProviderDelta::ThinkingDelta {
- delta: reasoning.clone(),
- },
- )
- .await?;
- }
- }
- // Tool-call fragments.
- //
- // Ordering invariant emitted downstream:
- // ToolCallStart (once, when id+name both known)
- // → ToolCallArgsDelta* (buffered then streamed)
- //
- // Args fragments that arrive *before* we know the
- // canonical id are buffered but NOT emitted — emitting
- // them with a synthetic id would break client-side
- // reconciliation. Once start fires we flush the buffered
- // prefix in a single delta, then stream subsequent
- // fragments as they arrive.
- if let Some(tc_list) = choice.delta.tool_calls.as_ref() {
- for tc in tc_list {
- let idx = tc.index.unwrap_or(0);
- let entry = tool_accum.entry(idx).or_default();
-
- // Capture the first non-null extra_content seen for
- // this index (Gemini's thought_signature, TAURI-RUST-4PK).
- if entry.extra_content.is_none() {
- if let Some(ec) = tc.extra_content.as_ref() {
- if !ec.is_null() {
- entry.extra_content = Some(ec.clone());
- }
- }
- }
-
- // Only the FIRST delta for a tool-call index carries
- // the real id; argument-continuation deltas repeat the
- // index with an EMPTY id (`""`) on some providers
- // (DashScope/GMI) and omit it entirely on others
- // (DeepSeek). Guard against the empty string so a
- // continuation delta can't clobber the resolved id down
- // to `""` — which later trips the upstream tool-message
- // ordering check (empty `tool_call_id` → 400).
- if let Some(id) = tc.id.as_ref() {
- if !id.is_empty() {
- if entry.id.is_none() {
- log::debug!(
- "[stream] {} tool_call[{}] id resolved: {}",
- self.name,
- idx,
- id,
- );
- }
- entry.id = Some(id.clone());
- }
- }
- if let Some(func) = tc.function.as_ref() {
- if let Some(name) = func.name.as_ref() {
- if !name.is_empty() && entry.name.is_none() {
- log::debug!(
- "[stream] {} tool_call[{}] name resolved: {}",
- self.name,
- idx,
- name,
- );
- }
- if !name.is_empty() {
- entry.name = Some(name.clone());
- }
- }
- if let Some(args) = func.arguments.as_ref() {
- if !args.is_empty() {
- entry.arguments.push_str(args);
- if !entry.emitted_start {
- log::debug!(
- "[stream] {} tool_call[{}] buffering args ({} chars total) — waiting for id/name",
- self.name,
- idx,
- entry.arguments.len(),
- );
- }
- }
- }
- }
-
- if !entry.emitted_start {
- if let (Some(id), Some(name)) =
- (entry.id.as_ref(), entry.name.as_ref())
- {
- log::debug!(
- "[stream] {} tool_call[{}] emitting ToolCallStart id={} name={}",
- self.name,
- idx,
- id,
- name,
- );
- self.forward_delta(
- delta_tx,
- ProviderDelta::ToolCallStart {
- call_id: id.clone(),
- tool_name: name.clone(),
- },
- )
- .await?;
- entry.emitted_start = true;
- if !entry.arguments.is_empty() {
- log::debug!(
- "[stream] {} tool_call[{}] flushing buffered args ({} chars)",
- self.name,
- idx,
- entry.arguments.len(),
- );
- let buffered = entry.arguments.clone();
- self.forward_delta(
- delta_tx,
- ProviderDelta::ToolCallArgsDelta {
- call_id: id.clone(),
- delta: buffered,
- },
- )
- .await?;
- entry.emitted_chars = entry.arguments.len();
- }
- }
- } else if entry.arguments.len() > entry.emitted_chars {
- if let Some(ref id) = entry.id {
- let fresh =
- entry.arguments[entry.emitted_chars..].to_string();
- self.forward_delta(
- delta_tx,
- ProviderDelta::ToolCallArgsDelta {
- call_id: id.clone(),
- delta: fresh,
- },
- )
- .await?;
- entry.emitted_chars = entry.arguments.len();
- }
- }
- }
- }
- }
- }
- }
- }
-
- if degenerate_repeat {
- text_accum.push_str(
- "\n\n[Output stopped: detected repeated/looping generation (model degeneration).]",
- );
- }
-
- let tool_call_count = tool_accum.len();
- log::info!(
- "[stream] {} aggregated text_chars={} thinking_chars={} tool_calls={}",
- self.name,
- text_accum.chars().count(),
- thinking_accum.chars().count(),
- tool_call_count,
- );
-
- // Issue #3335 / #3386 forensic signal. The streaming chat call
- // completed with HTTP 2xx but delivered zero visible text, zero
- // thinking, and zero tool calls. This is the upstream shape that
- // collapses to `AgentError::EmptyProviderResponse` and gets
- // rendered to the user as "The model returned an empty
- // response" with the wrong remediation. Most likely causes:
- // (a) backend closed the SSE cleanly under credit exhaustion
- // (no `[stream] streaming API error` breadcrumb fires
- // because status was 200) — common on the OpenHuman
- // managed route under #3386,
- // (b) backend's upstream LLM provider stalled / timed out
- // and the backend forwarded an empty stream instead of
- // propagating the upstream error,
- // (c) a genuine degenerate model output (rare on hosted
- // reasoning models; more common on community quants).
- // Logged at warn so it lands in Sentry breadcrumbs even after
- // `AgentError::skips_sentry()` (PR #2790) silences the parent
- // event. Correlate by elapsed_ms (fast == reject, slow ==
- // stall), sse_chunks (0 == no SSE at all, >0 == backend
- // streamed metadata-only chunks), has_usage (the upstream
- // counted tokens but delivered no content), and
- // has_openhuman_meta (managed backend reported routing info).
- if text_accum.is_empty() && thinking_accum.is_empty() && tool_call_count == 0 {
- let elapsed_ms = stream_started_at.elapsed().as_millis() as u64;
- log::warn!(
- "[stream] {} empty 2xx stream — model={} elapsed_ms={} sse_chunks={} body_bytes={} has_usage={} has_openhuman_meta={}",
- self.name,
- native_request.model,
- elapsed_ms,
- sse_chunks_parsed,
- body_bytes_received,
- last_usage.is_some(),
- last_openhuman.is_some(),
- );
- }
-
- let tool_calls_for_api: Vec = tool_accum
- .into_values()
- .map(|c| ToolCall {
- id: c.id,
- kind: Some("function".to_string()),
- function: Some(super::compatible_types::Function {
- name: c.name,
- arguments: if c.arguments.is_empty() {
- None
- } else {
- Some(
- serde_json::from_str(&c.arguments)
- .unwrap_or(serde_json::Value::String(c.arguments)),
- )
- },
- }),
- // Carry Gemini's thought_signature through to parse_native_response
- // so it lands on the harness ToolCall (TAURI-RUST-4PK).
- extra_content: c.extra_content,
- })
- .collect();
-
- let api_resp = ApiChatResponse {
- choices: vec![Choice {
- message: ResponseMessage {
- content: if text_accum.is_empty() {
- None
- } else {
- Some(text_accum)
- },
- reasoning_content: if thinking_accum.is_empty() {
- None
- } else {
- Some(thinking_accum)
- },
- tool_calls: if tool_calls_for_api.is_empty() {
- None
- } else {
- Some(tool_calls_for_api)
- },
- function_call: None,
- },
- }],
- usage: last_usage,
- openhuman: last_openhuman,
- };
-
- if std::env::var("OPENHUMAN_PROMPT_DUMP_DIR").is_ok() {
- let msg = &api_resp.choices[0].message;
- let aggregated = serde_json::json!({
- "content": msg.content,
- "reasoning_content": msg.reasoning_content,
- "tool_calls": msg.tool_calls.as_ref().map(|calls| {
- calls.iter().map(|c| serde_json::json!({
- "id": c.id,
- "type": c.kind,
- "function": c.function.as_ref().map(|f| serde_json::json!({
- "name": f.name,
- "arguments": f.arguments,
- })),
- })).collect::>()
- }),
- "usage": api_resp.usage.as_ref().map(|u| serde_json::json!({
- "prompt_tokens": u.prompt_tokens,
- "completion_tokens": u.completion_tokens,
- "total_tokens": u.total_tokens,
- "prompt_cached_tokens": u.prompt_tokens_details
- .as_ref().map(|d| d.cached_tokens),
- })),
- "openhuman": api_resp.openhuman.as_ref().map(|m| serde_json::json!({
- "usage": m.usage.as_ref().map(|u| serde_json::json!({
- "input_tokens": u.input_tokens,
- "output_tokens": u.output_tokens,
- "cached_input_tokens": u.cached_input_tokens,
- })),
- "billing": m.billing.as_ref().map(|b| serde_json::json!({
- "charged_amount_usd": b.charged_amount_usd,
- })),
- })),
- });
- if let Ok(bytes) = serde_json::to_vec(&aggregated) {
- dump_response_if_enabled(&self.name, &native_request.model, dump_seq, &bytes);
- }
- }
-
- Self::parse_native_response(api_resp, &self.name)
- }
-
- /// Forward a streamed [`ProviderDelta`] to the caller under the same
- /// inactivity watchdog as the SSE read (#4269). A dropped receiver is a
- /// benign stop (the consumer is gone — `Ok`, and the loop keeps aggregating
- /// as before); a consumer that backpressures for the whole idle window is a
- /// wedge (e.g. a stalled UI progress bridge), which trips the watchdog so a
- /// turn can't hang on a full delta channel. The bail classifies as retryable.
- async fn forward_delta(
- &self,
- delta_tx: &tokio::sync::mpsc::Sender,
- delta: ProviderDelta,
- ) -> anyhow::Result<()> {
- match tokio::time::timeout(self.stream_idle_timeout, delta_tx.send(delta)).await {
- Ok(Ok(())) => Ok(()),
- Ok(Err(_)) => Ok(()), // receiver dropped — consumer gone, not a stall
- Err(_elapsed) => {
- let idle_secs = self.stream_idle_timeout.as_secs();
- log::warn!(
- "[stream] {} watchdog fired — delta channel backpressured for {}s; aborting stalled stream for retry",
- self.name,
- idle_secs,
- );
- anyhow::bail!(
- "{} streaming watchdog: delta channel stalled for {}s — aborting stalled stream for retry",
- self.name,
- idle_secs,
- )
- }
- }
- }
-}
-
-/// Extract the `data:` payload of an SSE `event: error` frame, or `None` when
-/// the event block is not an error frame.
-///
-/// The managed backend delivers post-flush stream errors as a two-line SSE
-/// block — `event: error` followed by `data: {"error":{…,"errorCode":…}}`
-/// (backend `routes/inference.ts`). The normal chunk loop can't parse that
-/// `data:` line as a `StreamChunkResponse`, so without this detection the frame
-/// is silently skipped and the turn aggregates to an empty response. We key on
-/// the `event: error` field rather than sniffing the data so a normal chunk
-/// that merely mentions "error" is never misclassified.
-fn sse_error_frame_payload(event: &str) -> Option {
- let mut is_error_frame = false;
- let mut data: Option = None;
- for line in event.lines() {
- let line = line.trim();
- if let Some(event_type) = line.strip_prefix("event:") {
- if event_type.trim() == "error" {
- is_error_frame = true;
- }
- } else if let Some(payload) = line.strip_prefix("data:") {
- data = Some(payload.trim().to_string());
- }
- }
- is_error_frame.then(|| data.unwrap_or_default())
-}
-
-/// Build the bail message for an in-band SSE `event: error` frame, or `None`
-/// when the event block is a normal chunk / metadata event (the caller then
-/// continues parsing it as a chunk).
-///
-/// Mirrors the non-2xx HTTP path: produces a ` streaming API error:
-/// ` envelope so the downstream `errorCode` classifier and the
-/// Sentry golden rule run on it. When the frame carries a backend-owned
-/// `errorCode`, it is logged (not re-reported) here, matching the HTTP path's
-/// [`is_backend_error_code_owned`] branch; a malformed `BAD_REQUEST` is excluded
-/// by that helper and still pages downstream. There is no HTTP status for an
-/// in-band frame, so the log records the `200` that was actually sent.
-fn sse_error_frame_bail_message(
- provider: &str,
- model: Option<&str>,
- event: &str,
-) -> Option {
- let payload = sse_error_frame_payload(event)?;
- let sanitized = super::super::sanitize_api_error(&payload);
- let message = format!("{provider} streaming API error: {sanitized}");
- if super::super::is_backend_error_code_owned(provider, &payload) {
- super::super::log_backend_error_code_owned(
- "streaming_chat",
- provider,
- model,
- reqwest::StatusCode::OK,
- &payload,
- );
- }
- Some(message)
-}
-
-#[cfg(test)]
-mod sse_error_frame_tests {
- use super::{sse_error_frame_bail_message, sse_error_frame_payload};
- use crate::openhuman::inference::provider::openhuman_backend::PROVIDER_LABEL;
-
- #[test]
- fn extracts_payload_from_error_frame() {
- let event = "event: error\ndata: {\"error\":{\"message\":\"boom\",\"type\":\"stream_error\",\"errorCode\":\"BAD_REQUEST\"}}";
- let payload = sse_error_frame_payload(event).expect("error frame detected");
- assert!(payload.contains("\"errorCode\":\"BAD_REQUEST\""));
- assert!(payload.contains("\"type\":\"stream_error\""));
- }
-
- #[test]
- fn ignores_normal_data_chunk() {
- let event =
- "data: {\"choices\":[{\"delta\":{\"content\":\"an error occurred in the story\"}}]}";
- assert!(sse_error_frame_payload(event).is_none());
- }
-
- #[test]
- fn ignores_metadata_event() {
- let event = "event: openhuman-metadata\ndata: {\"openhuman\":{}}";
- assert!(sse_error_frame_payload(event).is_none());
- }
-
- #[test]
- fn bail_message_wraps_error_frame_in_streaming_envelope() {
- // A managed-backend error frame yields a streaming-envelope string the
- // downstream classifier recognises, preserving the `errorCode`.
- let event = "event: error\ndata: {\"error\":{\"message\":\"slow down\",\"type\":\"stream_error\",\"errorCode\":\"RATE_LIMITED\"}}";
- let message = sse_error_frame_bail_message(PROVIDER_LABEL, Some("reasoning-v1"), event)
- .expect("bail message built");
- assert!(message.contains("streaming API error"));
- assert!(message.contains("\"errorCode\":\"RATE_LIMITED\""));
- }
-
- #[test]
- fn bail_message_handles_frame_without_error_code() {
- // An untyped mid-stream drop (no `errorCode`) still produces an
- // envelope; it is simply not backend-owned, so downstream Sentry gating
- // applies as before.
- let event =
- "event: error\ndata: {\"error\":{\"message\":\"socket hang up\",\"type\":\"stream_error\"}}";
- let message =
- sse_error_frame_bail_message(PROVIDER_LABEL, None, event).expect("bail message built");
- assert!(message.contains("socket hang up"));
- }
-
- #[test]
- fn bail_message_is_none_for_normal_chunk() {
- let event = "data: {\"choices\":[{\"delta\":{\"content\":\"hi\"}}]}";
- assert!(sse_error_frame_bail_message(PROVIDER_LABEL, None, event).is_none());
- }
-
- #[test]
- fn error_frame_without_data_yields_empty_payload() {
- // Defensive: an `event: error` with no `data:` line still resolves to a
- // (empty) payload so the caller bails rather than skipping it.
- let event = "event: error";
- assert_eq!(sse_error_frame_payload(event).as_deref(), Some(""));
- }
-}
diff --git a/src/openhuman/inference/provider/compatible_tests.rs b/src/openhuman/inference/provider/compatible_tests.rs
deleted file mode 100644
index 43b9747ca..000000000
--- a/src/openhuman/inference/provider/compatible_tests.rs
+++ /dev/null
@@ -1,4851 +0,0 @@
-use super::*;
-use sentry::test::TestTransport;
-use std::sync::Arc;
-use wiremock::matchers::{body_json, method, path};
-use wiremock::{Mock, MockServer, ResponseTemplate};
-
-fn make_provider(name: &str, url: &str, key: Option<&str>) -> OpenAiCompatibleProvider {
- OpenAiCompatibleProvider::new(name, url, key, AuthStyle::Bearer)
-}
-
-/// Wrap a ResponseMessage in a minimal ApiChatResponse for tests.
-fn wrap_message(message: ResponseMessage) -> ApiChatResponse {
- ApiChatResponse {
- choices: vec![Choice { message }],
- usage: None,
- openhuman: None,
- }
-}
-
-#[test]
-fn creates_with_key() {
- let p = make_provider(
- "venice",
- "https://api.venice.ai",
- Some("venice-test-credential"),
- );
- assert_eq!(p.name, "venice");
- assert_eq!(p.base_url, "https://api.venice.ai");
- assert_eq!(p.credential.as_deref(), Some("venice-test-credential"));
-}
-
-#[test]
-fn creates_without_key() {
- let p = make_provider("test", "https://example.com", None);
- assert!(p.credential.is_none());
-}
-
-#[test]
-fn strips_trailing_slash() {
- let p = make_provider("test", "https://example.com/", None);
- assert_eq!(p.base_url, "https://example.com");
-}
-
-#[tokio::test]
-async fn chat_fails_without_key() {
- let p = make_provider("Venice", "https://api.venice.ai", None);
- let result = p
- .chat_with_system(None, "hello", "llama-3.3-70b", 0.7)
- .await;
- assert!(result.is_err());
- assert!(result
- .unwrap_err()
- .to_string()
- .contains("Venice API key not set"));
-}
-
-#[test]
-fn native_request_emits_thread_id_when_present() {
- let req = super::NativeChatRequest {
- model: "sonnet".to_string(),
- messages: Vec::new(),
- temperature: Some(0.7),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: Some("thread-abc".to_string()),
- stream_options: None,
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let json = serde_json::to_value(&req).unwrap();
- assert_eq!(
- json.get("thread_id").and_then(|v| v.as_str()),
- Some("thread-abc"),
- "thread_id must be forwarded so the backend can group InferenceLog + KV cache by chat thread"
- );
-
- let req_no_thread = super::NativeChatRequest {
- model: "sonnet".to_string(),
- messages: Vec::new(),
- temperature: Some(0.7),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: None,
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let json_no_thread = serde_json::to_value(&req_no_thread).unwrap();
- assert!(
- json_no_thread.get("thread_id").is_none(),
- "absent thread_id must not be serialized so non-OpenHuman backends don't reject the field"
- );
-}
-
-#[test]
-fn native_request_serializes_frequency_penalty_only_when_set() {
- let base = super::NativeChatRequest {
- model: "kimi".to_string(),
- messages: Vec::new(),
- temperature: Some(0.7),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: None,
- options: None,
- frequency_penalty: Some(0.3),
- max_tokens: None,
- };
- let json = serde_json::to_value(&base).unwrap();
- assert_eq!(
- json.get("frequency_penalty")
- .and_then(serde_json::Value::as_f64),
- Some(0.3),
- "a set frequency_penalty must be forwarded to damp repetition loops"
- );
-
- let none = super::NativeChatRequest {
- frequency_penalty: None,
- ..base
- };
- let json_none = serde_json::to_value(&none).unwrap();
- assert!(
- json_none.get("frequency_penalty").is_none(),
- "absent frequency_penalty must be omitted so providers that reject it are unaffected"
- );
-}
-
-#[test]
-fn native_request_serializes_max_tokens_only_when_set() {
- // A set cap must reach the wire as OpenAI `max_tokens` so a credit-metered
- // provider prices the request against a realistic output budget rather than
- // the model's full window (TAURI-RUST-C62).
- let with_cap = super::NativeChatRequest {
- model: "anthropic/claude-fable-5".to_string(),
- messages: Vec::new(),
- temperature: Some(0.0),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: None,
- options: None,
- frequency_penalty: None,
- max_tokens: Some(8192),
- };
- let json = serde_json::to_value(&with_cap).unwrap();
- assert_eq!(
- json.get("max_tokens").and_then(serde_json::Value::as_u64),
- Some(8192),
- "a set max_tokens must be forwarded so the provider's balance pre-flight is bounded"
- );
-
- let no_cap = super::NativeChatRequest {
- max_tokens: None,
- ..with_cap
- };
- let json_none = serde_json::to_value(&no_cap).unwrap();
- assert!(
- json_none.get("max_tokens").is_none(),
- "absent max_tokens must be omitted so open-ended generations are unaffected"
- );
-}
-
-#[test]
-fn agent_turn_cap_reaches_the_wire() {
- // The agent turns now set `max_tokens: Some(AGENT_TURN_MAX_OUTPUT_TOKENS)`
- // (#4005); assert that exact cap serializes onto the wire so a careless edit
- // to the const — or a regression to `None` on the agent path — fails CI and
- // can't silently restore the full-window reservation that 402s low-balance
- // BYO users (TAURI-RUST-C62).
- let cap = crate::openhuman::inference::provider::AGENT_TURN_MAX_OUTPUT_TOKENS;
- assert!(
- (8192..=32768).contains(&cap),
- "agent cap must stay well above realistic turns yet below the model's full output window; got {cap}"
- );
- let req = super::NativeChatRequest {
- model: "anthropic/claude-fable-5".to_string(),
- messages: Vec::new(),
- temperature: Some(0.0),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: None,
- options: None,
- frequency_penalty: None,
- max_tokens: Some(cap),
- };
- let json = serde_json::to_value(&req).unwrap();
- assert_eq!(
- json.get("max_tokens").and_then(serde_json::Value::as_u64),
- Some(u64::from(cap)),
- "the agent-turn cap must be forwarded as OpenAI max_tokens"
- );
-}
-
-#[test]
-fn responses_request_serializes_max_output_tokens_only_when_set() {
- // The Responses-API branch must carry the cap as `max_output_tokens` so a
- // capped request isn't silently uncapped when responses_api_primary is on
- // (TAURI-RUST-C62).
- let with_cap = super::compatible_types::ResponsesRequest {
- model: "gpt-x".to_string(),
- input: vec![],
- instructions: None,
- stream: Some(false),
- store: Some(false),
- max_output_tokens: Some(8192),
- };
- let json = serde_json::to_value(&with_cap).unwrap();
- assert_eq!(
- json.get("max_output_tokens")
- .and_then(serde_json::Value::as_u64),
- Some(8192),
- "a set cap must reach the Responses API as max_output_tokens"
- );
-
- let no_cap = super::compatible_types::ResponsesRequest {
- max_output_tokens: None,
- ..with_cap
- };
- let json_none = serde_json::to_value(&no_cap).unwrap();
- assert!(
- json_none.get("max_output_tokens").is_none(),
- "absent cap must be omitted"
- );
-}
-
-#[test]
-fn detects_frequency_penalty_rejection_for_retry() {
- use super::OpenAiCompatibleProvider as P;
- // Strict providers that 400 on the field → retry without it.
- assert!(P::err_indicates_frequency_penalty_unsupported(
- "400 Bad Request: unknown parameter 'frequency_penalty'"
- ));
- assert!(P::err_indicates_frequency_penalty_unsupported(
- "frequency_penalty is not supported by this model"
- ));
- // Unrelated errors, or the field merely mentioned, must NOT trigger a retry.
- assert!(!P::err_indicates_frequency_penalty_unsupported(
- "rate limit exceeded"
- ));
- assert!(!P::err_indicates_frequency_penalty_unsupported(
- "applied frequency_penalty 0.3"
- ));
-}
-
-#[test]
-fn endpoint_rejects_frequency_penalty_matches_google_gemini_host() {
- use super::compatible_request::endpoint_rejects_frequency_penalty as rejects;
- // The Google Gemini OpenAI-compat shim 400s on the field (TAURI-RUST-4PJ).
- assert!(rejects(
- "https://generativelanguage.googleapis.com/v1beta/openai"
- ));
- // Host match is case-insensitive and covers a registrable-domain suffix,
- // so a BYOK provider pointed at a regional/sub-host is covered too.
- assert!(rejects(
- "https://GenerativeLanguage.GoogleAPIs.com/v1beta/openai"
- ));
- assert!(rejects(
- "https://eu.generativelanguage.googleapis.com/v1beta/openai"
- ));
- // Every other provider keeps the penalty; an unparseable URL is a no-op.
- assert!(!rejects("https://api.openai.com/v1"));
- assert!(!rejects("https://api.venice.ai"));
- // A look-alike host must NOT match (suffix check is dot-anchored).
- assert!(!rejects(
- "https://notgenerativelanguage.googleapis.com.evil.test/v1"
- ));
- assert!(!rejects("not a url"));
-}
-
-#[test]
-fn effective_frequency_penalty_omitted_for_google_kept_for_others() {
- // Google Gemini endpoint → field omitted at the source (no rejected
- // round-trip, no Sentry report).
- let google = OpenAiCompatibleProvider::new(
- "google",
- "https://generativelanguage.googleapis.com/v1beta/openai",
- None,
- AuthStyle::Bearer,
- );
- assert_eq!(
- google.effective_frequency_penalty(),
- None,
- "Gemini shim rejects frequency_penalty — it must be omitted up front"
- );
-
- // Any other OpenAI-compatible provider keeps the repetition-damping value.
- let other = make_provider("openai", "https://api.openai.com/v1", None);
- assert_eq!(
- other.effective_frequency_penalty(),
- Some(super::compatible_repeat::CHAT_FREQUENCY_PENALTY),
- "providers that accept the field must still receive it"
- );
-}
-
-#[tokio::test]
-async fn streaming_chat_frequency_penalty_rejection_not_reported_to_sentry() {
- // Defense-in-depth (TAURI-RUST-4PJ): an unknown strict provider — one not
- // covered by the host allow-list, so prevention did not omit the field —
- // 400s on frequency_penalty. The caller retries without it and succeeds, so
- // this self-healed condition must NOT page Sentry, while still propagating
- // as an Err so the retry path fires.
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(400).set_body_string(
- r#"{"error":{"code":400,"message":"Invalid JSON payload received. Unknown name \"frequency_penalty\": Cannot find field.","status":"INVALID_ARGUMENT"}}"#,
- ))
- .mount(&mock_server)
- .await;
-
- let transport = TestTransport::new();
- let sentry_options = sentry::ClientOptions {
- dsn: Some("https://public@sentry.invalid/1".parse().unwrap()),
- transport: Some(Arc::new(transport.clone())),
- ..Default::default()
- };
- let sentry_hub = Arc::new(sentry::Hub::new(
- Some(Arc::new(sentry_options.into())),
- Arc::new(Default::default()),
- ));
- let _sentry_guard = sentry::HubSwitchGuard::new(sentry_hub);
-
- // Provider URL is the mock host (not the google allow-list host), so the
- // request DOES carry frequency_penalty and exercises the stream-error
- // classifier arm rather than the prevent-at-source omission.
- let provider =
- OpenAiCompatibleProvider::new("strict_byok", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "some-model".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("hello".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: Some(super::compatible_repeat::CHAT_FREQUENCY_PENALTY),
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(8);
-
- let err = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect_err(
- "400 frequency_penalty rejection must still propagate as Err to drive the retry",
- );
- assert!(
- err.to_string().contains("streaming API error"),
- "err: {err}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "a self-healed frequency_penalty rejection must not be reported to Sentry"
- );
-}
-
-/// Verbatim TAURI-RUST-5MV body — ollama.com hosted-inference 500 envelope.
-const OLLAMA_CLOUD_500_WIRE_BODY: &str =
- r#"{"error":"Internal Server Error (ref: df512dcb-d915-493b-8f2d-e8d3dfa640c1)"}"#;
-
-/// TAURI-RUST-5MV: ollama.com hosted-inference 500 on the non-streaming native
-/// path must be demoted (no Sentry event) and surface the actionable message,
-/// while still propagating as `Err` so reliable-provider retry/fallback runs.
-#[tokio::test]
-async fn native_chat_ollama_cloud_500_demoted_and_actionable() {
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(500).set_body_string(OLLAMA_CLOUD_500_WIRE_BODY))
- .mount(&mock_server)
- .await;
-
- let transport = TestTransport::new();
- let sentry_options = sentry::ClientOptions {
- dsn: Some("https://public@sentry.invalid/1".parse().unwrap()),
- transport: Some(Arc::new(transport.clone())),
- ..Default::default()
- };
- let sentry_hub = Arc::new(sentry::Hub::new(
- Some(Arc::new(sentry_options.into())),
- Arc::new(Default::default()),
- ));
- let _sentry_guard = sentry::HubSwitchGuard::new(sentry_hub);
-
- let provider =
- OpenAiCompatibleProvider::new("ollama", &mock_server.uri(), None, AuthStyle::None);
- let messages = vec![ChatMessage {
- id: None,
- role: "user".to_string(),
- content: "hello".to_string(),
- extra_metadata: None,
- }];
- let err = provider
- .chat(
- super::super::ChatRequest {
- messages: &messages,
- tools: None,
- stream: None,
- max_tokens: None,
- },
- "minimax-m3:cloud",
- 0.7,
- )
- .await
- .expect_err("ollama cloud 500 must still propagate as Err to drive retry/fallback");
-
- let msg = err.to_string();
- assert!(
- msg.contains("Ollama cloud is temporarily unavailable") && msg.contains("minimax-m3:cloud"),
- "expected actionable message, got: {msg}"
- );
- assert!(
- !msg.contains("ref:"),
- "opaque ref body must be replaced: {msg}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "ollama cloud 500 must be demoted, not reported to Sentry"
- );
-}
-
-/// TAURI-RUST-5MV: same demotion on the streaming native path.
-#[tokio::test]
-async fn streaming_chat_ollama_cloud_500_demoted_and_actionable() {
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(500).set_body_string(OLLAMA_CLOUD_500_WIRE_BODY))
- .mount(&mock_server)
- .await;
-
- let transport = TestTransport::new();
- let sentry_options = sentry::ClientOptions {
- dsn: Some("https://public@sentry.invalid/1".parse().unwrap()),
- transport: Some(Arc::new(transport.clone())),
- ..Default::default()
- };
- let sentry_hub = Arc::new(sentry::Hub::new(
- Some(Arc::new(sentry_options.into())),
- Arc::new(Default::default()),
- ));
- let _sentry_guard = sentry::HubSwitchGuard::new(sentry_hub);
-
- let provider =
- OpenAiCompatibleProvider::new("ollama", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "minimax-m3:cloud".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("hello".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(8);
-
- let err = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect_err("ollama cloud 500 must still propagate as Err to drive retry/fallback");
-
- let msg = err.to_string();
- assert!(
- msg.contains("Ollama cloud is temporarily unavailable") && msg.contains("minimax-m3:cloud"),
- "expected actionable message, got: {msg}"
- );
- assert!(
- !msg.contains("ref:"),
- "opaque ref body must be replaced: {msg}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "ollama cloud 500 must be demoted, not reported to Sentry"
- );
-}
-
-/// TAURI-RUST-5MV: the shared `api_error` helper demotes the same body and
-/// returns the actionable message (covers `chat_with_system` / `chat_with_history`
-/// callers that funnel through it).
-#[tokio::test]
-async fn api_error_ollama_cloud_500_demoted_and_actionable() {
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .respond_with(ResponseTemplate::new(500).set_body_string(OLLAMA_CLOUD_500_WIRE_BODY))
- .mount(&mock_server)
- .await;
-
- let transport = TestTransport::new();
- let sentry_options = sentry::ClientOptions {
- dsn: Some("https://public@sentry.invalid/1".parse().unwrap()),
- transport: Some(Arc::new(transport.clone())),
- ..Default::default()
- };
- let sentry_hub = Arc::new(sentry::Hub::new(
- Some(Arc::new(sentry_options.into())),
- Arc::new(Default::default()),
- ));
- let _sentry_guard = sentry::HubSwitchGuard::new(sentry_hub);
-
- let response = reqwest::Client::new()
- .post(mock_server.uri())
- .send()
- .await
- .expect("mock request");
- let err = super::super::api_error("ollama", response).await;
-
- let msg = err.to_string();
- assert!(
- msg.contains("Ollama cloud is temporarily unavailable"),
- "expected actionable message, got: {msg}"
- );
- assert!(
- !msg.contains("ref:"),
- "opaque ref body must be replaced: {msg}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "ollama cloud 500 must be demoted, not reported to Sentry"
- );
-}
-
-/// Streaming responses arrive without `usage` unless the request asks
-/// for `stream_options.include_usage = true` (OpenAI spec). Without it
-/// the OpenHuman backend's `openhuman.billing` block also never lands,
-/// so transcript headers for orchestrator sessions lose the
-/// `- Charged: $…` line. The non-streaming path stays untouched.
-#[test]
-fn streaming_request_sets_stream_options_include_usage() {
- let req = super::NativeChatRequest {
- model: "sonnet".to_string(),
- messages: Vec::new(),
- temperature: Some(0.0),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let json = serde_json::to_value(&req).unwrap();
- assert_eq!(
- json.pointer("/stream_options/include_usage")
- .and_then(|v| v.as_bool()),
- Some(true),
- "streaming requests must opt into the final usage chunk"
- );
-}
-
-#[test]
-fn non_streaming_request_omits_stream_options() {
- let req = super::NativeChatRequest {
- model: "sonnet".to_string(),
- messages: Vec::new(),
- temperature: Some(0.0),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: None,
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let json = serde_json::to_value(&req).unwrap();
- assert!(
- json.get("stream_options").is_none(),
- "non-streaming requests must not emit stream_options (OpenAI rejects it on stream=false)"
- );
-}
-
-#[test]
-fn ollama_options_num_ctx_serializes_correctly() {
- let req = super::NativeChatRequest {
- model: "qwen3:14b".to_string(),
- messages: Vec::new(),
- temperature: Some(0.7),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: None,
- options: Some(super::compatible_types::OllamaOptions {
- num_ctx: Some(32768),
- }),
- frequency_penalty: None,
- max_tokens: None,
- };
- let json = serde_json::to_value(&req).unwrap();
- assert_eq!(
- json.pointer("/options/num_ctx").and_then(|v| v.as_u64()),
- Some(32768),
- "Ollama num_ctx must appear at options.num_ctx in serialized body"
- );
-}
-
-#[test]
-fn ollama_options_none_is_omitted() {
- let req = super::NativeChatRequest {
- model: "gpt-4o".to_string(),
- messages: Vec::new(),
- temperature: Some(0.7),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: None,
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let json = serde_json::to_value(&req).unwrap();
- assert!(
- json.get("options").is_none(),
- "options field must be omitted when None (non-Ollama providers)"
- );
-}
-
-#[tokio::test]
-async fn outbound_thread_id_is_gated_per_provider() {
- use crate::openhuman::inference::provider::thread_context::with_thread_id;
-
- let third_party = make_provider("Venice", "https://api.venice.ai", None);
- let openhuman =
- make_provider("OpenHuman", "https://api.openhuman.test", None).with_openhuman_thread_id();
-
- with_thread_id("thread-xyz", async {
- assert!(
- third_party.outbound_thread_id().is_none(),
- "third-party OpenAI-compatible providers must NOT see the OpenHuman thread_id extension \
- — unknown fields can trip strict input validation on Venice/Moonshot/Groq/etc."
- );
- assert_eq!(
- openhuman.outbound_thread_id().as_deref(),
- Some("thread-xyz"),
- "the OpenHuman backend provider opts in via with_openhuman_thread_id() and must \
- forward the ambient id so InferenceLog grouping + KV cache locality work"
- );
- })
- .await;
-}
-
-#[test]
-fn request_serializes_correctly() {
- let req = ApiChatRequest {
- model: "llama-3.3-70b".to_string(),
- messages: vec![
- Message {
- role: "system".to_string(),
- content: "You are OpenHuman".into(),
- },
- Message {
- role: "user".to_string(),
- content: "hello".into(),
- },
- ],
- temperature: Some(0.4),
- stream: Some(false),
- tools: None,
- tool_choice: None,
- };
- let json = serde_json::to_string(&req).unwrap();
- assert!(json.contains("llama-3.3-70b"));
- assert!(json.contains("system"));
- assert!(json.contains("user"));
- // tools/tool_choice should be omitted when None
- assert!(!json.contains("tools"));
- assert!(!json.contains("tool_choice"));
-}
-
-#[test]
-fn response_deserializes() {
- let json = r#"{"choices":[{"message":{"content":"Hello from Venice!"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- assert_eq!(
- resp.choices[0].message.content,
- Some("Hello from Venice!".to_string())
- );
-}
-
-#[test]
-fn response_empty_choices() {
- let json = r#"{"choices":[]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- assert!(resp.choices.is_empty());
-}
-
-#[test]
-fn parse_chat_response_body_reports_sanitized_snippet() {
- let body = r#"{"choices":"invalid","api_key":"sk-test-secret-value"}"#;
- let err = parse_chat_response_body("custom", body).expect_err("payload should fail");
- let msg = err.to_string();
-
- assert!(msg.contains("custom API returned an unexpected chat-completions payload"));
- assert!(msg.contains("body="));
- assert!(msg.contains("[REDACTED]"));
- assert!(!msg.contains("sk-test-secret-value"));
-}
-
-#[test]
-fn parse_responses_response_body_reports_sanitized_snippet() {
- let body = r#"{"output_text":123,"api_key":"sk-another-secret"}"#;
- let err = parse_responses_response_body("custom", body).expect_err("payload should fail");
- let msg = err.to_string();
-
- assert!(msg.contains("custom Responses API returned an unexpected payload"));
- assert!(msg.contains("body="));
- assert!(msg.contains("[REDACTED]"));
- assert!(!msg.contains("sk-another-secret"));
-}
-
-// ── aggregate_responses_sse_body (#3201) ─────────────────────────────────────
-
-/// Per-delta accumulation: the Codex/ChatGPT OAuth stream is a sequence of
-/// `response.output_text.delta` events whose `delta` fields concatenate into
-/// the final assistant text.
-#[test]
-fn aggregate_responses_sse_body_concatenates_text_deltas() {
- let body = "data: {\"type\":\"response.output_text.delta\",\"delta\":\"hello \"}\n\n\
- data: {\"type\":\"response.output_text.delta\",\"delta\":\"world\"}\n\n\
- data: [DONE]\n";
- let text =
- super::compatible_parse::aggregate_responses_sse_body("custom", body).expect("aggregate");
- assert_eq!(text, "hello world");
-}
-
-/// Some providers (and the Codex endpoint when the model batches its
-/// reply) skip per-token deltas and emit the full text in
-/// `response.completed.response.output_text`. The aggregator must fall
-/// back to that terminal field when no deltas accumulated.
-#[test]
-fn aggregate_responses_sse_body_prefers_terminal_output_text_when_present() {
- let body = "data: {\"type\":\"response.created\",\"response\":{}}\n\n\
- data: {\"type\":\"response.completed\",\"response\":{\"output_text\":\"batched final text\"}}\n\n\
- data: [DONE]\n";
- let text =
- super::compatible_parse::aggregate_responses_sse_body("custom", body).expect("aggregate");
- assert_eq!(text, "batched final text");
-}
-
-/// #3201 CodeRabbit nit: a whitespace-only terminal `output_text` must
-/// behave like the field is absent, so accumulated deltas survive instead
-/// of being silently collapsed into blank output. Mirrors
-/// `extract_responses_text`'s `first_nonempty(...)` policy.
-#[test]
-fn aggregate_responses_sse_body_ignores_whitespace_only_terminal_output_text() {
- let body = "data: {\"type\":\"response.output_text.delta\",\"delta\":\"good \"}\n\n\
- data: {\"type\":\"response.output_text.delta\",\"delta\":\"reply\"}\n\n\
- data: {\"type\":\"response.completed\",\"response\":{\"output_text\":\" \\n\\t\"}}\n\n\
- data: [DONE]\n";
- let text =
- super::compatible_parse::aggregate_responses_sse_body("custom", body).expect("aggregate");
- assert_eq!(text, "good reply");
-}
-
-/// Carriage-return line endings (CRLF, common in HTTP/1.1 SSE) parse the
-/// same as LF-only — the trimming is just `\r` stripping.
-#[test]
-fn aggregate_responses_sse_body_tolerates_crlf_line_endings() {
- let body = "data: {\"type\":\"response.output_text.delta\",\"delta\":\"crlf\"}\r\n\r\n\
- data: [DONE]\r\n";
- let text =
- super::compatible_parse::aggregate_responses_sse_body("custom", body).expect("aggregate");
- assert_eq!(text, "crlf");
-}
-
-/// `response.failed` / `response.error` / `error` event shapes are
-/// terminal failures — bubble them up so the caller surfaces the upstream
-/// reason instead of returning empty text.
-#[test]
-fn aggregate_responses_sse_body_surfaces_failure_events() {
- let body = "data: {\"type\":\"response.created\",\"response\":{}}\n\n\
- data: {\"type\":\"response.failed\",\"error\":\"upstream model unavailable\"}\n\n";
- let err = super::compatible_parse::aggregate_responses_sse_body("custom", body)
- .expect_err("failure event should propagate");
- assert!(
- err.to_string()
- .contains("custom Responses API stream reported a failure event"),
- "unexpected error: {err}"
- );
-}
-
-/// A stream that produced no usable text events returns a sanitised
-/// "no text events" error so the caller sees something actionable
-/// instead of an empty string.
-#[test]
-fn aggregate_responses_sse_body_errors_when_no_text_events_present() {
- let body = "data: {\"type\":\"response.created\",\"response\":{}}\n\n\
- data: [DONE]\n";
- let err = super::compatible_parse::aggregate_responses_sse_body("custom", body)
- .expect_err("empty stream should fail");
- assert!(
- err.to_string()
- .contains("custom Responses API SSE stream produced no text events"),
- "unexpected error: {err}"
- );
-}
-
-/// Malformed individual events (provider keepalive comments, etc.) must
-/// not abort the whole turn — they're skipped and the good deltas still
-/// aggregate.
-#[test]
-fn aggregate_responses_sse_body_skips_unparseable_events() {
- let body = "data: {malformed-keepalive\n\n\
- data: {\"type\":\"response.output_text.delta\",\"delta\":\"good\"}\n\n\
- data: [DONE]\n";
- let text =
- super::compatible_parse::aggregate_responses_sse_body("custom", body).expect("aggregate");
- assert_eq!(text, "good");
-}
-
-#[test]
-fn x_api_key_auth_style() {
- let p = OpenAiCompatibleProvider::new(
- "moonshot",
- "https://api.moonshot.cn",
- Some("ms-key"),
- AuthStyle::XApiKey,
- );
- assert!(matches!(p.auth_header, AuthStyle::XApiKey));
-}
-
-#[test]
-fn custom_auth_style() {
- let p = OpenAiCompatibleProvider::new(
- "custom",
- "https://api.example.com",
- Some("key"),
- AuthStyle::Custom("X-Custom-Key".into()),
- );
- assert!(matches!(p.auth_header, AuthStyle::Custom(_)));
-}
-
-#[test]
-fn no_auth_style_allows_missing_key() {
- let p =
- OpenAiCompatibleProvider::new("ollama", "http://localhost:11434/v1", None, AuthStyle::None);
- assert!(matches!(p.auth_header, AuthStyle::None));
- assert!(p.credential_for_request().unwrap().is_none());
-
- let req = p
- .apply_auth_header(
- p.http_client()
- .post("http://localhost:11434/v1/chat/completions"),
- None,
- )
- .build()
- .unwrap();
- assert!(req.headers().get("authorization").is_none());
- assert!(req.headers().get("x-api-key").is_none());
-}
-
-#[test]
-fn extra_headers_are_applied_with_auth_header() {
- let p = OpenAiCompatibleProvider::new(
- "openai",
- "https://chatgpt.com/backend-api/codex",
- Some("oauth-access-token"),
- AuthStyle::Bearer,
- )
- .with_extra_header("ChatGPT-Account-ID", "acct_123")
- .with_extra_header("originator", "codex_cli_rs")
- .with_user_agent("codex_cli_rs/0.0.0 (OpenHuman test)");
-
- let req = p
- .apply_auth_header(
- p.http_client()
- .post("https://chatgpt.com/backend-api/codex/responses"),
- Some("oauth-access-token"),
- )
- .build()
- .unwrap();
-
- assert_eq!(
- req.headers()
- .get("authorization")
- .and_then(|value| value.to_str().ok()),
- Some("Bearer oauth-access-token")
- );
- assert_eq!(
- req.headers()
- .get("ChatGPT-Account-ID")
- .and_then(|value| value.to_str().ok()),
- Some("acct_123")
- );
- assert_eq!(
- req.headers()
- .get("originator")
- .and_then(|value| value.to_str().ok()),
- Some("codex_cli_rs")
- );
- assert_eq!(
- req.headers()
- .get(reqwest::header::USER_AGENT)
- .and_then(|value| value.to_str().ok()),
- Some("codex_cli_rs/0.0.0 (OpenHuman test)")
- );
-}
-
-#[test]
-fn openrouter_requests_include_app_attribution_headers() {
- let p = OpenAiCompatibleProvider::new(
- "openrouter",
- "https://openrouter.ai/api/v1",
- Some("sk-or-test"),
- AuthStyle::Bearer,
- );
-
- let req = p
- .apply_auth_header(
- p.http_client()
- .post("https://openrouter.ai/api/v1/chat/completions"),
- Some("sk-or-test"),
- )
- .build()
- .unwrap();
-
- assert_eq!(
- req.headers()
- .get("HTTP-Referer")
- .and_then(|value| value.to_str().ok()),
- Some("https://openhuman.ai")
- );
- assert_eq!(
- req.headers()
- .get("X-OpenRouter-Title")
- .and_then(|value| value.to_str().ok()),
- Some("OpenHuman")
- );
-}
-
-#[test]
-fn non_openrouter_requests_do_not_include_openrouter_attribution_headers() {
- let p = OpenAiCompatibleProvider::new(
- "custom",
- "https://api.example.com/v1",
- Some("test-key"),
- AuthStyle::Bearer,
- );
-
- let req = p
- .apply_auth_header(
- p.http_client()
- .post("https://api.example.com/v1/chat/completions"),
- Some("test-key"),
- )
- .build()
- .unwrap();
-
- assert!(req.headers().get("HTTP-Referer").is_none());
- assert!(req.headers().get("X-OpenRouter-Title").is_none());
-}
-
-#[test]
-fn extra_query_params_are_applied_to_codex_urls() {
- let p = OpenAiCompatibleProvider::new(
- "openai",
- "https://chatgpt.com/backend-api/codex",
- Some("oauth-access-token"),
- AuthStyle::Bearer,
- )
- .with_extra_query_param("client_version", "0.54.17");
-
- let chat_url = reqwest::Url::parse(&p.chat_completions_url()).unwrap();
- assert_eq!(chat_url.path(), "/backend-api/codex/chat/completions");
- assert_eq!(
- chat_url
- .query_pairs()
- .find(|(key, _)| key == "client_version")
- .map(|(_, value)| value.into_owned()),
- Some("0.54.17".to_string())
- );
-
- let responses_url = reqwest::Url::parse(&p.responses_url()).unwrap();
- assert_eq!(responses_url.path(), "/backend-api/codex/responses");
- assert_eq!(
- responses_url
- .query_pairs()
- .find(|(key, _)| key == "client_version")
- .map(|(_, value)| value.into_owned()),
- Some("0.54.17".to_string())
- );
-}
-
-/// #3201: the Codex/ChatGPT OAuth Responses endpoint rejects
-/// `stream: false` with `{"detail":"Stream must be set to true"}` and
-/// only emits SSE bodies. The non-streaming `chat_via_responses` wrapper
-/// must therefore (a) flip the `stream` flag for `/backend-api/codex`
-/// URLs and (b) aggregate the SSE body back into the same `String`
-/// the caller expects. PR #3192 fixed the sibling `store: false`
-/// requirement; this test pins both wire-shape requirements together.
-#[tokio::test]
-async fn responses_api_primary_posts_directly_to_responses() {
- let server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/backend-api/codex/responses"))
- .and(body_json(serde_json::json!({
- "model": "gpt-5.5",
- "input": [{
- "role": "user",
- "content": [{"type": "input_text", "text": "hello"}]
- }],
- "stream": true,
- "store": false
- })))
- .respond_with(ResponseTemplate::new(200).set_body_string(
- "data: {\"type\":\"response.output_text.delta\",\"delta\":\"hello \"}\n\n\
- data: {\"type\":\"response.output_text.delta\",\"delta\":\"from \"}\n\n\
- data: {\"type\":\"response.output_text.delta\",\"delta\":\"responses\"}\n\n\
- data: {\"type\":\"response.completed\",\"response\":{\"output_text\":\"hello from responses\"}}\n\n\
- data: [DONE]\n\n",
- ))
- .mount(&server)
- .await;
-
- let provider = OpenAiCompatibleProvider::new(
- "openai",
- &format!("{}/backend-api/codex", server.uri()),
- Some("oauth-access-token"),
- AuthStyle::Bearer,
- )
- .with_responses_api_primary();
-
- let text = provider
- .chat_with_history(&[ChatMessage::user("hello")], "gpt-5.5", 0.0)
- .await
- .unwrap();
-
- assert_eq!(text, "hello from responses");
-}
-
-/// TAURI-RUST-EWD: the Codex/ChatGPT OAuth Responses endpoint rejects
-/// `max_output_tokens` (400 `Unsupported parameter: max_output_tokens`). The
-/// memory-extraction cap (`ChatRequest::max_tokens`) must therefore be dropped
-/// on the wire for `/backend-api/codex/responses`. The exact `body_json`
-/// matcher omits the field, so a request that still carried it would fail to
-/// match the mock and the call would error — i.e. a match positively proves the
-/// omission.
-#[tokio::test]
-async fn codex_responses_omits_max_output_tokens() {
- let server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/backend-api/codex/responses"))
- .and(body_json(serde_json::json!({
- "model": "gpt-5.5",
- "input": [{
- "role": "user",
- "content": [{"type": "input_text", "text": "hello"}]
- }],
- "stream": true,
- "store": false
- })))
- .respond_with(ResponseTemplate::new(200).set_body_string(
- "data: {\"type\":\"response.output_text.delta\",\"delta\":\"ok\"}\n\n\
- data: {\"type\":\"response.completed\",\"response\":{\"output_text\":\"ok\"}}\n\n\
- data: [DONE]\n\n",
- ))
- .mount(&server)
- .await;
-
- let provider = OpenAiCompatibleProvider::new(
- "openai",
- &format!("{}/backend-api/codex", server.uri()),
- Some("oauth-access-token"),
- AuthStyle::Bearer,
- )
- .with_responses_api_primary();
-
- let messages = [ChatMessage::user("hello")];
- let request = crate::openhuman::inference::provider::traits::ChatRequest {
- messages: &messages,
- tools: None,
- stream: None,
- // A bounded cap (memory extraction) that the Codex endpoint rejects.
- max_tokens: Some(256),
- };
- let resp = provider.chat(request, "gpt-5.5", 0.0).await.unwrap();
- assert_eq!(resp.text.as_deref(), Some("ok"));
-}
-
-/// A non-Codex Responses backend (`/v1/responses`) must still receive the cap —
-/// the omission is endpoint-specific, not a blanket drop (guards against
-/// silently uncapping memory extraction on real `/v1/responses`, TAURI-RUST-C62).
-#[tokio::test]
-async fn standard_responses_keeps_max_output_tokens() {
- let server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/v1/responses"))
- .and(body_json(serde_json::json!({
- "model": "gpt-5.4",
- "input": [{
- "role": "user",
- "content": [{"type": "input_text", "text": "hello"}]
- }],
- "stream": false,
- "store": false,
- "max_output_tokens": 256
- })))
- .respond_with(
- ResponseTemplate::new(200).set_body_string(r#"{"output_text":"ok","output":[]}"#),
- )
- .mount(&server)
- .await;
-
- let provider = OpenAiCompatibleProvider::new(
- "openai",
- &format!("{}/v1", server.uri()),
- Some("sk-test"),
- AuthStyle::Bearer,
- )
- .with_responses_api_primary();
-
- let messages = [ChatMessage::user("hello")];
- let request = crate::openhuman::inference::provider::traits::ChatRequest {
- messages: &messages,
- tools: None,
- stream: None,
- max_tokens: Some(256),
- };
- let resp = provider.chat(request, "gpt-5.4", 0.0).await.unwrap();
- assert_eq!(resp.text.as_deref(), Some("ok"));
-}
-
-/// The reactive strip-and-retry defends Responses backends we don't match by
-/// URL: a 400 whose body flags `max_output_tokens` as unsupported triggers one
-/// retry with the field removed, which then succeeds. Exact-body matchers are
-/// mutually exclusive on `max_output_tokens`, so the result is deterministic
-/// regardless of mock precedence.
-#[tokio::test]
-async fn responses_strips_max_output_tokens_and_retries_on_400() {
- let server = MockServer::start().await;
- let input = serde_json::json!([{
- "role": "user",
- "content": [{"type": "input_text", "text": "hello"}]
- }]);
- Mock::given(method("POST"))
- .and(path("/v1/responses"))
- .and(body_json(serde_json::json!({
- "model": "gpt-5.5",
- "input": input.clone(),
- "stream": false,
- "store": false,
- "max_output_tokens": 256
- })))
- .respond_with(
- ResponseTemplate::new(400)
- .set_body_string(r#"{"detail":"Unsupported parameter: max_output_tokens"}"#),
- )
- .mount(&server)
- .await;
- Mock::given(method("POST"))
- .and(path("/v1/responses"))
- .and(body_json(serde_json::json!({
- "model": "gpt-5.5",
- "input": input.clone(),
- "stream": false,
- "store": false
- })))
- .respond_with(
- ResponseTemplate::new(200)
- .set_body_string(r#"{"output_text":"recovered","output":[]}"#),
- )
- .mount(&server)
- .await;
-
- let provider = OpenAiCompatibleProvider::new(
- "strict-responses",
- &format!("{}/v1", server.uri()),
- Some("sk-test"),
- AuthStyle::Bearer,
- )
- .with_responses_api_primary();
-
- let messages = [ChatMessage::user("hello")];
- let request = crate::openhuman::inference::provider::traits::ChatRequest {
- messages: &messages,
- tools: None,
- stream: None,
- max_tokens: Some(256),
- };
- let resp = provider.chat(request, "gpt-5.5", 0.0).await.unwrap();
- assert_eq!(resp.text.as_deref(), Some("recovered"));
-}
-
-#[test]
-fn err_indicates_max_output_tokens_unsupported_matches_codex_body() {
- assert!(
- OpenAiCompatibleProvider::err_indicates_max_output_tokens_unsupported(
- r#"{"detail":"Unsupported parameter: max_output_tokens"}"#
- )
- );
- assert!(
- !OpenAiCompatibleProvider::err_indicates_max_output_tokens_unsupported(
- r#"{"detail":"rate limit exceeded"}"#
- )
- );
- // A different unsupported parameter must not trip the max_output_tokens strip.
- assert!(
- !OpenAiCompatibleProvider::err_indicates_max_output_tokens_unsupported(
- r#"{"detail":"Unsupported parameter: temperature"}"#
- )
- );
- // An invalid-*value* error (cap out of the model's allowed range) must NOT
- // strip the cap — that would silently uncap the request. Surface it instead.
- assert!(
- !OpenAiCompatibleProvider::err_indicates_max_output_tokens_unsupported(
- r#"{"detail":"Invalid value for max_output_tokens: must be <= 4096"}"#
- )
- );
- assert!(
- !OpenAiCompatibleProvider::err_indicates_max_output_tokens_unsupported(
- r#"{"detail":"max_output_tokens exceeds the maximum allowed for this model"}"#
- )
- );
-}
-
-#[test]
-fn blank_required_key_counts_as_missing() {
- let p = OpenAiCompatibleProvider::new(
- "custom",
- "https://api.example.com",
- Some(" "),
- AuthStyle::Bearer,
- );
- let err = p.credential_for_request().unwrap_err().to_string();
- assert!(err.contains("custom API key not set"), "err: {err}");
-}
-
-#[tokio::test]
-async fn all_compatible_providers_fail_without_key() {
- let providers = vec![
- make_provider("Venice", "https://api.venice.ai", None),
- make_provider("Moonshot", "https://api.moonshot.cn", None),
- make_provider("GLM", "https://open.bigmodel.cn", None),
- make_provider("MiniMax", "https://api.minimaxi.com/v1", None),
- make_provider("Groq", "https://api.groq.com/openai", None),
- make_provider("Mistral", "https://api.mistral.ai", None),
- make_provider("xAI", "https://api.x.ai", None),
- make_provider("Astrai", "https://as-trai.com/v1", None),
- ];
-
- for p in providers {
- let result = p.chat_with_system(None, "test", "model", 0.7).await;
- assert!(result.is_err(), "{} should fail without key", p.name);
- assert!(
- result.unwrap_err().to_string().contains("API key not set"),
- "{} error should mention key",
- p.name
- );
- }
-}
-
-#[test]
-fn responses_extracts_top_level_output_text() {
- let json = r#"{"output_text":"Hello from top-level","output":[]}"#;
- let response: ResponsesResponse = serde_json::from_str(json).unwrap();
- assert_eq!(
- extract_responses_text(response).as_deref(),
- Some("Hello from top-level")
- );
-}
-
-#[test]
-fn responses_extracts_nested_output_text() {
- let json = r#"{"output":[{"content":[{"type":"output_text","text":"Hello from nested"}]}]}"#;
- let response: ResponsesResponse = serde_json::from_str(json).unwrap();
- assert_eq!(
- extract_responses_text(response).as_deref(),
- Some("Hello from nested")
- );
-}
-
-#[test]
-fn responses_extracts_any_text_as_fallback() {
- let json = r#"{"output":[{"content":[{"type":"message","text":"Fallback text"}]}]}"#;
- let response: ResponsesResponse = serde_json::from_str(json).unwrap();
- assert_eq!(
- extract_responses_text(response).as_deref(),
- Some("Fallback text")
- );
-}
-
-#[test]
-fn build_responses_prompt_preserves_multi_turn_history() {
- let messages = vec![
- ChatMessage::system("policy"),
- ChatMessage::user("step 1"),
- ChatMessage::assistant("ack 1"),
- ChatMessage::tool("{\"result\":\"ok\"}"),
- ChatMessage::user("step 2"),
- ];
-
- let (instructions, input) = build_responses_prompt(&messages);
-
- assert_eq!(instructions.as_deref(), Some("policy"));
- assert_eq!(input.len(), 4);
- assert_eq!(input[0].role, "user");
- assert_eq!(input[0].content[0].kind, "input_text");
- assert_eq!(input[0].content[0].text, "step 1");
- assert_eq!(input[1].role, "assistant");
- assert_eq!(input[1].content[0].kind, "output_text");
- assert_eq!(input[1].content[0].text, "ack 1");
- // A `tool` turn normalizes to the `assistant` role, so its content part
- // MUST be `output_text` — the Responses API rejects `input_text` on an
- // assistant item (Sentry TAURI-RUST-8FQ / GH #3624).
- assert_eq!(input[2].role, "assistant");
- assert_eq!(input[2].content[0].kind, "output_text");
- assert_eq!(input[2].content[0].text, "{\"result\":\"ok\"}");
- assert_eq!(input[3].role, "user");
- assert_eq!(input[3].content[0].kind, "input_text");
- assert_eq!(input[3].content[0].text, "step 2");
-}
-
-/// Regression for Sentry TAURI-RUST-8FQ / GH #3624: the Responses API only
-/// accepts `output_text`/`refusal` for assistant items. `normalize_responses_role`
-/// folds `tool` into `assistant`, so the content kind must follow the normalized
-/// role — never the raw one. No assistant-role item may carry `input_text`.
-#[test]
-fn build_responses_prompt_tool_role_uses_output_text() {
- let messages = vec![
- ChatMessage::assistant("calling a tool"),
- ChatMessage::tool("{\"result\":\"ok\"}"),
- ChatMessage::user("thanks"),
- ];
-
- let (_instructions, input) = build_responses_prompt(&messages);
-
- // The tool turn folds to assistant and must carry output_text.
- assert_eq!(input[1].role, "assistant");
- assert_eq!(input[1].content[0].kind, "output_text");
-
- // Invariant: an assistant-role item never carries input_text.
- for item in &input {
- if item.role == "assistant" {
- assert_eq!(
- item.content[0].kind, "output_text",
- "assistant-role item must use output_text, got {}",
- item.content[0].kind
- );
- }
- }
-}
-
-#[tokio::test]
-async fn chat_via_responses_requires_non_system_message() {
- let provider = make_provider("custom", "https://api.example.com", Some("test-key"));
- let err = provider
- .chat_via_responses(
- Some("test-key"),
- &[ChatMessage::system("policy")],
- "gpt-test",
- None,
- )
- .await
- .expect_err("system-only fallback payload should fail");
-
- assert!(err
- .to_string()
- .contains("requires at least one non-system message"));
-}
-
-#[tokio::test]
-async fn streaming_chat_config_rejection_propagates_error_without_sentry_report() {
- // Representative guardrail for the new provider-config-rejection
- // suppression branches in compatible.rs: streaming_chat should still
- // return an error, but it must not call report_error/Sentry for this
- // deterministic user-config state.
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(
- ResponseTemplate::new(400)
- .set_body_string("invalid temperature: only 1 is allowed for this model"),
- )
- .mount(&mock_server)
- .await;
-
- let transport = TestTransport::new();
- let sentry_options = sentry::ClientOptions {
- dsn: Some("https://public@sentry.invalid/1".parse().unwrap()),
- transport: Some(Arc::new(transport.clone())),
- ..Default::default()
- };
- let sentry_hub = Arc::new(sentry::Hub::new(
- Some(Arc::new(sentry_options.into())),
- Arc::new(Default::default()),
- ));
- let _sentry_guard = sentry::HubSwitchGuard::new(sentry_hub);
-
- let provider =
- OpenAiCompatibleProvider::new("custom_openai", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "kimi-k2".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("hello".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(8);
-
- let err = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect_err("400 provider config-rejection must still propagate as Err");
- assert!(
- err.to_string().contains("streaming API error"),
- "err: {err}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "provider config-rejection must not be reported to Sentry"
- );
-}
-
-#[tokio::test]
-async fn streaming_chat_byo_auth_failure_propagates_error_without_sentry_report() {
- // Guardrail for #3671 (TAURI-RUST-DHM): a missing/invalid BYO API key on a
- // non-backend custom provider returns 401 with an auth-error body. The
- // error must still propagate to the caller, but it must NOT page Sentry —
- // memory-tree extraction + memory jobs retry through the broken credential
- // and previously flooded Sentry with thousands of identical events.
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(401).set_body_string(
- r#"{"error":{"message":"Invalid or missing API key","type":"authentication_error"}}"#,
- ))
- .mount(&mock_server)
- .await;
-
- let transport = TestTransport::new();
- let sentry_options = sentry::ClientOptions {
- dsn: Some("https://public@sentry.invalid/1".parse().unwrap()),
- transport: Some(Arc::new(transport.clone())),
- ..Default::default()
- };
- let sentry_hub = Arc::new(sentry::Hub::new(
- Some(Arc::new(sentry_options.into())),
- Arc::new(Default::default()),
- ));
- let _sentry_guard = sentry::HubSwitchGuard::new(sentry_hub);
-
- // `kiro` is the exact (user-named) custom provider from the Sentry report.
- let provider = OpenAiCompatibleProvider::new("kiro", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "claude-sonnet-4.5".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("hello".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(8);
-
- let err = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect_err("401 BYO auth failure must still propagate as Err");
- assert!(
- err.to_string().contains("streaming API error"),
- "err: {err}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "BYO provider auth failure must not be reported to Sentry"
- );
-}
-
-// ----------------------------------------------------------
-// Custom endpoint path tests (Issue #114)
-// ----------------------------------------------------------
-
-#[test]
-fn chat_completions_url_standard_openai() {
- // Standard OpenAI-compatible providers get /chat/completions appended
- let p = make_provider("openai", "https://api.openai.com/v1", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://api.openai.com/v1/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_trailing_slash() {
- // Trailing slash is stripped, then /chat/completions appended
- let p = make_provider("test", "https://api.example.com/v1/", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://api.example.com/v1/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_volcengine_ark() {
- // VolcEngine ARK uses custom path - should use as-is
- let p = make_provider(
- "volcengine",
- "https://ark.cn-beijing.volces.com/api/coding/v3/chat/completions",
- None,
- );
- assert_eq!(
- p.chat_completions_url(),
- "https://ark.cn-beijing.volces.com/api/coding/v3/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_custom_full_endpoint() {
- // Custom provider with full endpoint path
- let p = make_provider(
- "custom",
- "https://my-api.example.com/v2/llm/chat/completions",
- None,
- );
- assert_eq!(
- p.chat_completions_url(),
- "https://my-api.example.com/v2/llm/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_requires_exact_suffix_match() {
- let p = make_provider(
- "custom",
- "https://my-api.example.com/v2/llm/chat/completions-proxy",
- None,
- );
- assert_eq!(
- p.chat_completions_url(),
- "https://my-api.example.com/v2/llm/chat/completions-proxy/chat/completions"
- );
-}
-
-#[test]
-fn responses_url_standard() {
- // Standard providers get /v1/responses appended
- let p = make_provider("test", "https://api.example.com", None);
- assert_eq!(p.responses_url(), "https://api.example.com/v1/responses");
-}
-
-#[test]
-fn responses_url_custom_full_endpoint() {
- // Custom provider with full responses endpoint
- let p = make_provider(
- "custom",
- "https://my-api.example.com/api/v2/responses",
- None,
- );
- assert_eq!(
- p.responses_url(),
- "https://my-api.example.com/api/v2/responses"
- );
-}
-
-#[test]
-fn responses_url_requires_exact_suffix_match() {
- let p = make_provider(
- "custom",
- "https://my-api.example.com/api/v2/responses-proxy",
- None,
- );
- assert_eq!(
- p.responses_url(),
- "https://my-api.example.com/api/v2/responses-proxy/responses"
- );
-}
-
-#[test]
-fn responses_url_derives_from_chat_endpoint() {
- let p = make_provider(
- "custom",
- "https://my-api.example.com/api/v2/chat/completions",
- None,
- );
- assert_eq!(
- p.responses_url(),
- "https://my-api.example.com/api/v2/responses"
- );
-}
-
-#[test]
-fn responses_url_base_with_v1_no_duplicate() {
- let p = make_provider("test", "https://api.example.com/v1", None);
- assert_eq!(p.responses_url(), "https://api.example.com/v1/responses");
-}
-
-#[test]
-fn responses_url_non_v1_api_path_uses_raw_suffix() {
- let p = make_provider("test", "https://api.example.com/api/coding/v3", None);
- assert_eq!(
- p.responses_url(),
- "https://api.example.com/api/coding/v3/responses"
- );
-}
-
-#[test]
-fn chat_completions_url_without_v1() {
- // Provider configured without /v1 in base URL
- let p = make_provider("test", "https://api.example.com", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://api.example.com/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_base_with_v1() {
- // Provider configured with /v1 in base URL
- let p = make_provider("test", "https://api.example.com/v1", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://api.example.com/v1/chat/completions"
- );
-}
-
-// ----------------------------------------------------------
-// Provider-specific endpoint tests (Issue #167)
-// ----------------------------------------------------------
-
-#[test]
-fn chat_completions_url_zai() {
- // Z.AI uses /api/paas/v4 base path
- let p = make_provider("zai", "https://api.z.ai/api/paas/v4", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://api.z.ai/api/paas/v4/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_minimax() {
- // MiniMax OpenAI-compatible endpoint requires /v1 base path.
- let p = make_provider("minimax", "https://api.minimaxi.com/v1", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://api.minimaxi.com/v1/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_glm() {
- // GLM (BigModel) uses /api/paas/v4 base path
- let p = make_provider("glm", "https://open.bigmodel.cn/api/paas/v4", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://open.bigmodel.cn/api/paas/v4/chat/completions"
- );
-}
-
-#[test]
-fn chat_completions_url_opencode() {
- // OpenCode Zen uses /zen/v1 base path
- let p = make_provider("opencode", "https://opencode.ai/zen/v1", None);
- assert_eq!(
- p.chat_completions_url(),
- "https://opencode.ai/zen/v1/chat/completions"
- );
-}
-
-#[test]
-fn parse_native_response_preserves_tool_call_id() {
- let message = ResponseMessage {
- content: None,
- tool_calls: Some(vec![ToolCall {
- id: Some("call_123".to_string()),
- kind: Some("function".to_string()),
- function: Some(Function {
- name: Some("shell".to_string()),
- arguments: Some(serde_json::Value::String(
- r#"{"command":"pwd"}"#.to_string(),
- )),
- }),
- extra_content: None,
- }]),
- function_call: None,
- reasoning_content: None,
- };
-
- let parsed =
- OpenAiCompatibleProvider::parse_native_response(wrap_message(message), "test").unwrap();
- assert_eq!(parsed.tool_calls.len(), 1);
- assert_eq!(parsed.tool_calls[0].id, "call_123");
- assert_eq!(parsed.tool_calls[0].name, "shell");
-}
-
-/// DeepSeek thinking mode emits the chain-of-thought in `reasoning_content`
-/// alongside the tool call. `parse_native_response` must surface it so the
-/// agent loop can replay it on the follow-up request (Sentry TAURI-RUST-4KB).
-#[test]
-fn parse_native_response_captures_reasoning_content() {
- let message = ResponseMessage {
- content: None,
- tool_calls: Some(vec![ToolCall {
- id: Some("call_r".to_string()),
- kind: Some("function".to_string()),
- function: Some(Function {
- name: Some("shell".to_string()),
- arguments: Some(serde_json::Value::String("{}".to_string())),
- }),
- extra_content: None,
- }]),
- function_call: None,
- reasoning_content: Some(" weighing the options ".to_string()),
- };
-
- let parsed =
- OpenAiCompatibleProvider::parse_native_response(wrap_message(message), "deepseek").unwrap();
- assert_eq!(
- parsed.reasoning_content.as_deref(),
- Some("weighing the options")
- );
-}
-
-/// Whitespace-only / empty reasoning is normalised to `None` so it never
-/// produces a spurious `reasoning_content` key on the wire.
-#[test]
-fn parse_native_response_blank_reasoning_is_none() {
- let message = ResponseMessage {
- content: Some("hello".to_string()),
- tool_calls: None,
- function_call: None,
- reasoning_content: Some(" ".to_string()),
- };
-
- let parsed =
- OpenAiCompatibleProvider::parse_native_response(wrap_message(message), "deepseek").unwrap();
- assert!(parsed.reasoning_content.is_none());
-}
-
-#[test]
-fn convert_messages_for_native_maps_tool_result_payload() {
- // A `tool` result must be opened by a preceding `assistant(tool_calls)`,
- // else the invariant sanitizer drops it as an orphan (see `tool_invariants_*`).
- // Pair it with its opener so this test exercises payload mapping only.
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":"on it","tool_calls":[{"id":"call_abc","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_abc","content":"done"}"#),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
- assert_eq!(converted.len(), 2);
- assert_eq!(converted[1].role, "tool");
- assert_eq!(converted[1].tool_call_id.as_deref(), Some("call_abc"));
- assert_eq!(
- serde_json::to_value(&converted[1].content).unwrap(),
- serde_json::json!("done")
- );
-}
-
-// ── TAURI-RUST-4PK: Gemini thought_signature round-trip ──────────────────────
-
-/// The wire `ToolCall` must capture Gemini's `extra_content` from the response
-/// and re-emit it verbatim on the request, so the thought_signature survives the
-/// round-trip. A tool call without it omits the field entirely (non-Gemini
-/// providers stay byte-identical on the wire).
-#[test]
-fn tool_call_wire_round_trips_extra_content() {
- let json = r#"{"id":"call_g","type":"function","function":{"name":"shell","arguments":"{}"},"extra_content":{"google":{"thought_signature":"SIG123"}}}"#;
- let tc: ToolCall = serde_json::from_str(json).unwrap();
- assert_eq!(
- tc.extra_content
- .as_ref()
- .and_then(|v| v.pointer("/google/thought_signature"))
- .and_then(|v| v.as_str()),
- Some("SIG123"),
- "extra_content must be captured from the Gemini response"
- );
- let reemitted = serde_json::to_value(&tc).unwrap();
- assert_eq!(
- reemitted
- .pointer("/extra_content/google/thought_signature")
- .and_then(|v| v.as_str()),
- Some("SIG123"),
- "extra_content must be echoed verbatim on the request body"
- );
-
- let bare: ToolCall = serde_json::from_str(
- r#"{"id":"c","type":"function","function":{"name":"x","arguments":"{}"}}"#,
- )
- .unwrap();
- assert!(bare.extra_content.is_none());
- assert!(
- serde_json::to_value(&bare)
- .unwrap()
- .get("extra_content")
- .is_none(),
- "providers that don't send extra_content keep a byte-identical wire body"
- );
-}
-
-/// `parse_native_response` lifts the tool-call `extra_content` onto the harness
-/// ToolCall so it can be persisted and echoed (TAURI-RUST-4PK).
-#[test]
-fn parse_native_response_captures_tool_call_extra_content() {
- let message = ResponseMessage {
- content: None,
- tool_calls: Some(vec![ToolCall {
- id: Some("call_g".to_string()),
- kind: Some("function".to_string()),
- function: Some(Function {
- name: Some("shell".to_string()),
- arguments: Some(serde_json::Value::String("{}".to_string())),
- }),
- extra_content: Some(serde_json::json!({"google":{"thought_signature":"SIG_RESP"}})),
- }]),
- function_call: None,
- reasoning_content: None,
- };
- let parsed =
- OpenAiCompatibleProvider::parse_native_response(wrap_message(message), "google").unwrap();
- assert_eq!(parsed.tool_calls.len(), 1);
- assert_eq!(
- parsed.tool_calls[0]
- .extra_content
- .as_ref()
- .and_then(|v| v.pointer("/google/thought_signature"))
- .and_then(|v| v.as_str()),
- Some("SIG_RESP"),
- "the signature must land on the harness ToolCall"
- );
-}
-
-/// On rebuild, a persisted assistant tool-call message whose stored JSON carries
-/// `extra_content` must re-emit it on the wire tool_calls, so Gemini sees the
-/// signature on the follow-up turn (TAURI-RUST-4PK).
-#[test]
-fn convert_messages_for_native_echoes_tool_call_extra_content() {
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":"on it","tool_calls":[{"id":"call_g","name":"shell","arguments":"{}","extra_content":{"google":{"thought_signature":"SIG_ECHO"}}}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_g","content":"done"}"#),
- ];
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
- let tool_calls = converted[0]
- .tool_calls
- .as_ref()
- .expect("assistant tool_calls present");
- assert_eq!(
- tool_calls[0]
- .extra_content
- .as_ref()
- .and_then(|v| v.pointer("/google/thought_signature"))
- .and_then(|v| v.as_str()),
- Some("SIG_ECHO"),
- "stored extra_content must be echoed back on the rebuilt request"
- );
- assert_eq!(
- serde_json::to_value(tool_calls)
- .unwrap()
- .pointer("/0/extra_content/google/thought_signature")
- .and_then(|v| v.as_str()),
- Some("SIG_ECHO"),
- "echoed signature must appear on the serialized wire body"
- );
-}
-
-/// A non-Gemini stored tool call (no `extra_content`) rebuilds with the field
-/// omitted — every other provider's wire body stays byte-identical.
-#[test]
-fn convert_messages_for_native_tool_call_without_extra_content_stays_none() {
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":"on it","tool_calls":[{"id":"call_x","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_x","content":"done"}"#),
- ];
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
- let tool_calls = converted[0]
- .tool_calls
- .as_ref()
- .expect("assistant tool_calls present");
- assert!(tool_calls[0].extra_content.is_none());
- assert!(serde_json::to_value(&tool_calls[0])
- .unwrap()
- .get("extra_content")
- .is_none());
-}
-
-/// INVARIANT (TAURI-RUST-4PK / 4PJ): a PARALLEL multi-`functionCall` assistant
-/// turn reloaded from history must echo a non-empty `thought_signature` on
-/// EVERY part of the rebuilt outbound payload — not just the first. The stored
-/// JSON here is the exact shape `build_native_assistant_history` now emits (per
-/// the writer-side test in `agent::harness::parse_tests`). Before the fix the
-/// writer dropped `extra_content`, so a reloaded multi-call turn went out with
-/// missing signatures and Gemini 400'd ("Function call is missing a
-/// thought_signature in functionCall parts"). Covers both the non-stream and
-/// streaming paths since both persist through the single native history writer.
-#[test]
-fn convert_messages_for_native_echoes_signature_on_every_parallel_call() {
- let stored = r#"{"content":"on it","tool_calls":[
- {"id":"call_a","name":"shell","arguments":"{}","extra_content":{"google":{"thought_signature":"SIG_A"}}},
- {"id":"call_b","name":"read","arguments":"{}","extra_content":{"google":{"thought_signature":"SIG_B"}}}
- ]}"#;
- let input = vec![
- ChatMessage::assistant(stored),
- ChatMessage::tool(r#"{"tool_call_id":"call_a","content":"done"}"#),
- ChatMessage::tool(r#"{"tool_call_id":"call_b","content":"done"}"#),
- ];
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
- let tool_calls = converted[0]
- .tool_calls
- .as_ref()
- .expect("assistant tool_calls survive the reload");
- assert_eq!(tool_calls.len(), 2, "both parallel calls survive");
-
- let wire = serde_json::to_value(tool_calls).unwrap();
- for (idx, expected) in ["SIG_A", "SIG_B"].iter().enumerate() {
- let sig = wire
- .pointer(&format!("/{idx}/extra_content/google/thought_signature"))
- .and_then(|v| v.as_str());
- assert_eq!(
- sig,
- Some(*expected),
- "functionCall part {idx} must echo its own thought_signature on the wire"
- );
- assert!(
- sig.is_some_and(|s| !s.is_empty()),
- "functionCall part {idx} thought_signature must be non-empty"
- );
- }
-}
-
-/// Streaming: Gemini sends the thought_signature in the tool-call delta's
-/// `extra_content` on the first chunk. The accumulator must preserve it onto the
-/// aggregated tool call so it reaches history (TAURI-RUST-4PK).
-#[tokio::test]
-async fn streaming_tool_call_captures_extra_content() {
- let mock_server = MockServer::start().await;
- let body = "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_g\",\"type\":\"function\",\"function\":{\"name\":\"shell\",\"arguments\":\"{}\"},\"extra_content\":{\"google\":{\"thought_signature\":\"SIG_STREAM\"}}}]}}]}\n\n\
- data: [DONE]\n\n";
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(200).set_body_raw(body, "text/event-stream"))
- .mount(&mock_server)
- .await;
-
- let provider =
- OpenAiCompatibleProvider::new("google", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "models/gemini-3.5-flash".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("hi".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(64);
- let resp = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .unwrap();
- assert_eq!(resp.tool_calls.len(), 1);
- assert_eq!(
- resp.tool_calls[0]
- .extra_content
- .as_ref()
- .and_then(|v| v.pointer("/google/thought_signature"))
- .and_then(|v| v.as_str()),
- Some("SIG_STREAM"),
- "streaming must preserve the thought_signature onto the aggregated tool call"
- );
-}
-
-/// Regression: some providers (DashScope/Qwen, GMI) emit the tool-call `id`
-/// ONLY on the first delta for an index, then send `"id": ""` (empty string,
-/// not omitted) on every argument-continuation delta. The streaming accumulator
-/// must not let those empty continuation ids clobber the resolved id down to
-/// `""` — an empty `tool_call_id` is rejected by the upstream tool-message
-/// ordering check on the next turn (400), dead-ending the conversation.
-#[tokio::test]
-async fn streaming_empty_continuation_id_does_not_clobber_tool_call_id() {
- let mock_server = MockServer::start().await;
- // Delta 1 carries the real id + name; deltas 2-3 are arg continuations that
- // repeat index 0 with an EMPTY id (the DashScope/GMI wire shape).
- let body = "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_real\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{}\"}}]}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"\",\"function\":{\"arguments\":\"\"}}]}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"\"}]}}]}\n\n\
- data: [DONE]\n\n";
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(200).set_body_raw(body, "text/event-stream"))
- .mount(&mock_server)
- .await;
-
- let provider =
- OpenAiCompatibleProvider::new("dashscope", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "qwen3.7-plus".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("weather in paris?".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(64);
- let resp = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .unwrap();
- assert_eq!(resp.tool_calls.len(), 1);
- assert_eq!(
- resp.tool_calls[0].id.as_str(),
- "call_real",
- "empty-string id on continuation deltas must not clobber the resolved tool_call id"
- );
-}
-
-/// Regression: a single turn can emit MULTIPLE parallel tool calls. The
-/// per-`index` accumulator must keep each call's first-delta id even when the
-/// empty-id continuation deltas for both indices arrive together — neither may
-/// clobber the other (or itself) to `""`.
-#[tokio::test]
-async fn streaming_parallel_tool_calls_preserve_ids_against_empty_continuations() {
- let mock_server = MockServer::start().await;
- // Two parallel calls (index 0 + 1), then one continuation delta carrying
- // BOTH indices with empty ids.
- let body = "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_a\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{}\"}}]}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":1,\"id\":\"call_b\",\"type\":\"function\",\"function\":{\"name\":\"get_time\",\"arguments\":\"{}\"}}]}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"\"},{\"index\":1,\"id\":\"\"}]}}]}\n\n\
- data: [DONE]\n\n";
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(200).set_body_raw(body, "text/event-stream"))
- .mount(&mock_server)
- .await;
-
- let provider =
- OpenAiCompatibleProvider::new("dashscope", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "qwen3.7-plus".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("weather and time?".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(64);
- let resp = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .unwrap();
- assert_eq!(resp.tool_calls.len(), 2, "both parallel tool calls survive");
- // Order-independent: each id must be preserved AND mapped to the right tool
- // (no cross-index contamination).
- let by_id: std::collections::HashMap<&str, (&str, &str)> = resp
- .tool_calls
- .iter()
- .map(|t| (t.id.as_str(), (t.name.as_str(), t.arguments.as_str())))
- .collect();
- assert_eq!(by_id.get("call_a"), Some(&("get_weather", "{}")));
- assert_eq!(by_id.get("call_b"), Some(&("get_time", "{}")));
-}
-
-/// Counterpart to the DashScope cases: DeepSeek OMITS the `id` key on
-/// argument-continuation deltas (rather than sending `""`). That deserializes
-/// to `None`, so the accumulator already leaves the resolved id alone — assert
-/// the contract holds for the key-absent shape too, and that args still
-/// accumulate across the continuation.
-#[tokio::test]
-async fn streaming_omitted_continuation_id_preserves_tool_call_id() {
- let mock_server = MockServer::start().await;
- // Delta 2 has NO `id` key at all (DeepSeek shape) and carries the rest of
- // the arguments.
- let body = "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_ds\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\"}}]}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"}\"}}]}}]}\n\n\
- data: [DONE]\n\n";
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(200).set_body_raw(body, "text/event-stream"))
- .mount(&mock_server)
- .await;
-
- let provider =
- OpenAiCompatibleProvider::new("deepseek", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "deepseek-v4-flash".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("weather?".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(64);
- let resp = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .unwrap();
- assert_eq!(resp.tool_calls.len(), 1);
- assert_eq!(resp.tool_calls[0].id.as_str(), "call_ds");
- assert_eq!(resp.tool_calls[0].name.as_str(), "get_weather");
- assert_eq!(
- resp.tool_calls[0].arguments.as_str(),
- "{}",
- "arguments must accumulate across the id-omitted continuation delta"
- );
-}
-
-/// Helper: roles in serialized order.
-fn roles(messages: &[NativeMessage]) -> Vec<&str> {
- messages.iter().map(|m| m.role.as_str()).collect()
-}
-
-/// Mechanism (A): history tail-trimming dropped an `assistant(tool_calls)` but
-/// kept its `tool` result, orphaning the result at the head of the window. The
-/// sanitizer must drop the orphan so the wire array never starts a tool block
-/// without a preceding `tool_calls`.
-#[test]
-fn tool_invariants_drop_orphaned_tool_result_from_trim(/* A */) {
- let input = vec![
- ChatMessage::system("system prompt"),
- // assistant(tool_calls=call_orphan) was sliced off by trim_history;
- // only its result survived as the first non-system message.
- ChatMessage::tool(r#"{"tool_call_id":"call_orphan","content":"stale result"}"#),
- ChatMessage::user("and then?"),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(roles(&converted), vec!["system", "user"]);
- assert!(
- converted.iter().all(|m| m.role != "tool"),
- "orphaned tool result must be dropped"
- );
-}
-
-/// Mechanism (B): a persisted assistant tool-call message whose `content` no
-/// longer parses as `{tool_calls: [...]}` is emitted as plain assistant text
-/// with its `tool_calls` stripped, orphaning the following `tool` result. The
-/// assistant message stays; the now-orphaned tool result is dropped.
-#[test]
-fn tool_invariants_drop_tool_after_unparseable_assistant_call(/* B */) {
- let input = vec![
- // Plain text, not the JSON tool-call shape -> tool_calls stripped on convert.
- ChatMessage::assistant("let me check that for you"),
- ChatMessage::tool(r#"{"tool_call_id":"call_b","content":"tool ran"}"#),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(roles(&converted), vec!["assistant"]);
- assert!(converted[0].tool_calls.is_none());
- assert!(
- converted.iter().all(|m| m.role != "tool"),
- "tool result with no opening tool_calls must be dropped"
- );
-}
-
-/// Mechanism (C): an `assistant(tool_calls=[answered, missing])` whose second
-/// call never received a `tool` response (aborted / max-iteration turn, or a
-/// partially-answered multi-call cycle). The sanitizer prunes the dangling
-/// tool-call entry while keeping the answered one and its result.
-#[test]
-fn tool_invariants_prune_unanswered_tool_call(/* C */) {
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":"on it","tool_calls":[{"id":"call_done","name":"shell","arguments":"{}"},{"id":"call_missing","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_done","content":"finished"}"#),
- // call_missing never gets a tool response.
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- let assistant = converted
- .iter()
- .find(|m| m.role == "assistant")
- .expect("assistant message present");
- let calls = assistant
- .tool_calls
- .as_ref()
- .expect("answered tool_call retained");
- assert_eq!(calls.len(), 1, "dangling tool_call must be pruned");
- assert_eq!(calls[0].id.as_deref(), Some("call_done"));
- assert!(
- converted
- .iter()
- .any(|m| m.role == "tool" && m.tool_call_id.as_deref() == Some("call_done")),
- "answered tool result must survive"
- );
-}
-
-/// (C) extreme: an `assistant(tool_calls)` with NO response at all collapses to
-/// a plain assistant message (tool_calls dropped) rather than a dangling block.
-#[test]
-fn tool_invariants_collapse_fully_unanswered_assistant_call() {
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":"on it","tool_calls":[{"id":"call_x","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::assistant("never mind, here's the answer"),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(roles(&converted), vec!["assistant", "assistant"]);
- assert!(
- converted[0].tool_calls.is_none(),
- "fully-unanswered tool_calls must be dropped"
- );
- assert_eq!(
- serde_json::to_value(&converted[0].content).unwrap(),
- serde_json::json!("on it")
- );
-}
-
-/// Regression guard: a well-formed tool cycle is passed through untouched —
-/// the sanitizer must not strip or reorder valid messages.
-#[test]
-fn tool_invariants_preserve_well_formed_cycle() {
- let input = vec![
- ChatMessage::system("system prompt"),
- ChatMessage::user("run it"),
- ChatMessage::assistant(
- r#"{"content":"on it","tool_calls":[{"id":"call_ok","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_ok","content":"done"}"#),
- ChatMessage::assistant("all set"),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(
- roles(&converted),
- vec!["system", "user", "assistant", "tool", "assistant"]
- );
- assert_eq!(converted[2].tool_calls.as_ref().unwrap().len(), 1);
- assert_eq!(
- converted[2].tool_calls.as_ref().unwrap()[0].id.as_deref(),
- Some("call_ok")
- );
- assert_eq!(converted[3].tool_call_id.as_deref(), Some("call_ok"));
-}
-
-/// Sequential tool cycles — successive agent iterations, each its own
-/// `assistant(tool_calls)` → `tool` block. Distinct ids, opened then immediately
-/// consumed. All survive untouched.
-#[test]
-fn tool_invariants_preserve_sequential_cycles() {
- let input = vec![
- ChatMessage::user("go"),
- ChatMessage::assistant(
- r#"{"content":"step 1","tool_calls":[{"id":"call_a","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_a","content":"a done"}"#),
- ChatMessage::assistant(
- r#"{"content":"step 2","tool_calls":[{"id":"call_b","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_b","content":"b done"}"#),
- ChatMessage::assistant(
- r#"{"content":"step 3","tool_calls":[{"id":"call_c","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_c","content":"c done"}"#),
- ChatMessage::assistant("all done"),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(
- roles(&converted),
- vec![
- "user",
- "assistant",
- "tool",
- "assistant",
- "tool",
- "assistant",
- "tool",
- "assistant"
- ]
- );
- for idx in [1usize, 3, 5] {
- assert_eq!(
- converted[idx].tool_calls.as_ref().unwrap().len(),
- 1,
- "cycle at index {idx} must keep its call"
- );
- }
-}
-
-/// Parallel tool calls — one `assistant` issuing N calls, answered by N `tool`
-/// messages arriving out of order. All survive; pairing is by membership, not
-/// position, so order does not matter.
-#[test]
-fn tool_invariants_preserve_parallel_calls() {
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":"fanning out","tool_calls":[{"id":"call_x","name":"shell","arguments":"{}"},{"id":"call_y","name":"shell","arguments":"{}"},{"id":"call_z","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_y","content":"y"}"#),
- ChatMessage::tool(r#"{"tool_call_id":"call_z","content":"z"}"#),
- ChatMessage::tool(r#"{"tool_call_id":"call_x","content":"x"}"#),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(roles(&converted), vec!["assistant", "tool", "tool", "tool"]);
- assert_eq!(converted[0].tool_calls.as_ref().unwrap().len(), 3);
-}
-
-/// Trim bisecting a sequence: the window opens inside cycle A (its assistant was
-/// sliced off), followed by an intact cycle B. The orphaned A result is dropped;
-/// cycle B survives — proving adjacency-pairing localizes the damage.
-#[test]
-fn tool_invariants_drop_orphan_but_keep_following_cycle() {
- let input = vec![
- // assistant(call_a) was sliced off by trim; only its result remains.
- ChatMessage::tool(r#"{"tool_call_id":"call_a","content":"orphaned"}"#),
- ChatMessage::assistant(
- r#"{"content":"step 2","tool_calls":[{"id":"call_b","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_b","content":"b done"}"#),
- ChatMessage::assistant("done"),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(roles(&converted), vec!["assistant", "tool", "assistant"]);
- assert_eq!(converted[0].tool_calls.as_ref().unwrap().len(), 1);
- assert_eq!(converted[1].tool_call_id.as_deref(), Some("call_b"));
-}
-
-/// DeepSeek thinking mode (Sentry TAURI-RUST-4KB): an `assistant` turn that
-/// carries `tool_calls` must replay its `reasoning_content` on the follow-up
-/// request, otherwise DeepSeek returns
-/// `400 The reasoning_content in the thinking mode must be passed back to the
-/// API.` The history JSON written by `build_native_assistant_history` carries
-/// `reasoning_content`; `convert_messages_for_native` must lift it back onto
-/// the wire message.
-#[test]
-fn convert_preserves_reasoning_content_on_tool_call_turn() {
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":null,"reasoning_content":"let me think about this","tool_calls":[{"id":"call_x","name":"shell","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_x","content":"result"}"#),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- // First message is the assistant with tool_calls + reasoning.
- assert_eq!(
- converted[0].reasoning_content.as_deref(),
- Some("let me think about this")
- );
- assert!(converted[0].tool_calls.is_some());
-
- // The wire payload must actually carry the field for DeepSeek to accept it.
- let wire = serde_json::to_value(&converted[0]).unwrap();
- assert_eq!(wire["reasoning_content"], "let me think about this");
-}
-
-/// Assistant tool-call turns from non-reasoning models carry no
-/// `reasoning_content`; it must never appear on the wire for them (most
-/// OpenAI-compatible providers don't recognise the field).
-#[test]
-fn convert_omits_reasoning_content_when_absent() {
- let input = vec![ChatMessage::assistant(
- r#"{"content":"sure","tool_calls":[{"id":"call_y","name":"shell","arguments":"{}"}]}"#,
- )];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
-
- assert_eq!(converted.len(), 1);
- assert!(converted[0].reasoning_content.is_none());
-
- let wire = serde_json::to_value(&converted[0]).unwrap();
- assert!(
- wire.get("reasoning_content").is_none(),
- "reasoning_content must be omitted from the wire when absent"
- );
-}
-
-/// Tool-call assistant messages with no narrative text must emit `"content":""`
-/// on the wire (not omit the key) so providers that validate the presence of a
-/// content field alongside reasoning_content don't reject the request.
-#[test]
-fn convert_tool_call_turn_emits_content_key_even_when_empty() {
- let input = vec![
- ChatMessage::assistant(
- r#"{"content":null,"reasoning_content":"thinking","tool_calls":[{"id":"call_a","name":"web_fetch","arguments":"{}"}]}"#,
- ),
- ChatMessage::tool(r#"{"tool_call_id":"call_a","content":"fetched"}"#),
- ];
-
- let converted = OpenAiCompatibleProvider::convert_messages_for_native(&input);
- let wire = serde_json::to_value(&converted[0]).unwrap();
-
- assert!(
- wire.get("content").is_some(),
- "content key must be present on the wire even when the model emitted null/empty content"
- );
- assert_eq!(wire["content"], "");
- assert_eq!(wire["reasoning_content"], "thinking");
-}
-
-/// When `enforce_tool_message_invariants` collapses an assistant tool-call
-/// message to plain text (all tool_calls pruned because no responses matched),
-/// it must also clear `reasoning_content` — leaving stale reasoning on a
-/// non-tool assistant message is a malformed shape for thinking-mode providers.
-#[test]
-fn enforce_invariants_clears_reasoning_when_assistant_collapses_to_text() {
- let messages = vec![
- NativeMessage {
- role: "assistant".to_string(),
- content: Some("partial thought".into()),
- tool_call_id: None,
- tool_calls: Some(vec![ToolCall {
- id: Some("orphan_call".to_string()),
- kind: Some("function".to_string()),
- function: Some(Function {
- name: Some("web_fetch".to_string()),
- arguments: Some(serde_json::Value::String("{}".to_string())),
- }),
- extra_content: None,
- }]),
- reasoning_content: Some("deep reasoning".to_string()),
- },
- // No tool result follows — the tool_calls are orphaned.
- NativeMessage {
- role: "user".to_string(),
- content: Some("next question".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- },
- ];
-
- let sanitized = OpenAiCompatibleProvider::enforce_tool_message_invariants(messages);
-
- // The assistant message should have been collapsed: tool_calls pruned.
- let assistant = &sanitized[0];
- assert!(assistant.tool_calls.is_none());
- // reasoning_content must also be cleared on collapse.
- assert!(
- assistant.reasoning_content.is_none(),
- "reasoning_content must be stripped when tool_calls are pruned to avoid malformed shape"
- );
-}
-
-#[test]
-fn chat_message_identity_metadata_is_not_provider_wire_payload() {
- let message = ChatMessage {
- id: Some("msg_123".to_string()),
- role: "user".to_string(),
- content: "hello".to_string(),
- extra_metadata: Some(serde_json::json!({"citation": "mem-1"})),
- };
-
- let serialized = serde_json::to_value(&message).unwrap();
-
- assert_eq!(
- serialized.get("role").and_then(|v| v.as_str()),
- Some("user")
- );
- assert_eq!(
- serialized.get("content").and_then(|v| v.as_str()),
- Some("hello")
- );
- assert!(
- serialized.get("id").is_none(),
- "provider ChatMessage serialization must not leak UI message ids"
- );
- assert!(
- serialized.get("extra_metadata").is_none(),
- "provider ChatMessage serialization must not leak UI metadata"
- );
-}
-
-#[test]
-fn flatten_system_messages_merges_into_first_user() {
- let input = vec![
- ChatMessage::system("core policy"),
- ChatMessage::assistant("ack"),
- ChatMessage::system("delivery rules"),
- ChatMessage::user("hello"),
- ChatMessage::assistant("post-user"),
- ];
-
- let output = OpenAiCompatibleProvider::flatten_system_messages(&input);
- assert_eq!(output.len(), 3);
- assert_eq!(output[0].role, "assistant");
- assert_eq!(output[0].content, "ack");
- assert_eq!(output[1].role, "user");
- assert_eq!(output[1].content, "core policy\n\ndelivery rules\n\nhello");
- assert_eq!(output[2].role, "assistant");
- assert_eq!(output[2].content, "post-user");
- assert!(output.iter().all(|m| m.role != "system"));
-}
-
-#[test]
-fn flatten_system_messages_inserts_user_when_missing() {
- let input = vec![
- ChatMessage::system("core policy"),
- ChatMessage::assistant("ack"),
- ];
-
- let output = OpenAiCompatibleProvider::flatten_system_messages(&input);
- assert_eq!(output.len(), 2);
- assert_eq!(output[0].role, "user");
- assert_eq!(output[0].content, "core policy");
- assert_eq!(output[1].role, "assistant");
- assert_eq!(output[1].content, "ack");
-}
-
-#[test]
-fn strip_think_tags_drops_unclosed_block_suffix() {
- let input = "visiblehidden";
- assert_eq!(strip_think_tags(input), "visible");
-}
-
-#[test]
-fn native_tool_schema_unsupported_detection_is_precise() {
- assert!(OpenAiCompatibleProvider::is_native_tool_schema_unsupported(
- reqwest::StatusCode::BAD_REQUEST,
- "unknown parameter: tools"
- ));
- assert!(
- !OpenAiCompatibleProvider::is_native_tool_schema_unsupported(
- reqwest::StatusCode::UNAUTHORIZED,
- "unknown parameter: tools"
- )
- );
-}
-
-#[test]
-fn prompt_guided_tool_fallback_injects_system_instruction() {
- let input = vec![ChatMessage::user("check status")];
- let tools = vec![crate::openhuman::tools::ToolSpec {
- name: "shell_exec".to_string(),
- description: "Execute shell command".to_string(),
- parameters: serde_json::json!({
- "type": "object",
- "properties": {
- "command": { "type": "string" }
- },
- "required": ["command"]
- }),
- }];
-
- let output =
- OpenAiCompatibleProvider::with_prompt_guided_tool_instructions(&input, Some(&tools));
- assert!(!output.is_empty());
- assert_eq!(output[0].role, "system");
- assert!(output[0].content.contains("Available Tools"));
- assert!(output[0].content.contains("shell_exec"));
-}
-
-#[tokio::test]
-async fn warmup_without_key_is_noop() {
- let provider = make_provider("test", "https://example.com", None);
- let result = provider.warmup().await;
- assert!(result.is_ok());
-}
-
-// ══════════════════════════════════════════════════════════
-// Native tool calling tests
-// ══════════════════════════════════════════════════════════
-
-#[test]
-fn capabilities_reports_native_tool_calling() {
- let p = make_provider("test", "https://example.com", None);
- let caps = ::capabilities(&p);
- assert!(caps.native_tool_calling);
- assert!(caps.vision);
-}
-
-// Sub-issue 3 of #3098: Ollama's OpenAI-compat endpoint silently rejects the
-// `tools` parameter for many models, so we must let the factory opt the
-// Ollama provider out of native tool calling. The agent harness then falls
-// back to prompt-guided tool specs (embedded in the system prompt) which
-// any chat model can follow. The builder defaults to enabled so cloud
-// providers (OpenAI, BYOK slugs, OpenHuman backend) are unaffected.
-
-#[test]
-fn with_native_tool_calling_false_disables_capability() {
- let p = make_provider("test", "https://example.com", None).with_native_tool_calling(false);
- let caps = ::capabilities(&p);
- assert!(
- !caps.native_tool_calling,
- "capabilities() must mirror the builder override; this is the gate the agent harness uses to decide between native vs prompt-guided tool specs"
- );
-}
-
-#[test]
-fn with_native_tool_calling_true_preserves_default() {
- let p = make_provider("test", "https://example.com", None).with_native_tool_calling(true);
- let caps = ::capabilities(&p);
- assert!(caps.native_tool_calling);
-}
-
-#[test]
-fn with_native_tool_calling_is_idempotent() {
- let p = make_provider("test", "https://example.com", None)
- .with_native_tool_calling(false)
- .with_native_tool_calling(false);
- let caps = ::capabilities(&p);
- assert!(!caps.native_tool_calling);
-}
-
-#[test]
-fn with_vision_false_disables_capability() {
- let p = make_provider("test", "https://example.com", None).with_vision(false);
- let caps = ::capabilities(&p);
- assert!(!caps.vision);
- assert!(!p.supports_vision());
-}
-
-/// `supports_native_tools()` is the gate the agent harness reads
-/// (`traits.rs:415`) when deciding whether to send tools natively or
-/// inject them into the prompt. It MUST agree with
-/// `capabilities().native_tool_calling`; otherwise
-/// `with_native_tool_calling(false)` silently fails to switch to
-/// prompt-guided and Ollama still receives a `tools` array (the exact
-/// regression sub-issue 3 of #3098 was meant to fix).
-#[test]
-fn supports_native_tools_mirrors_capabilities_flag() {
- let default = make_provider("test", "https://example.com", None);
- assert_eq!(
- default.supports_native_tools(),
- ::capabilities(&default).native_tool_calling,
- "default provider: the two capability signals must match"
- );
- assert!(default.supports_native_tools(), "default must remain true");
-
- let opted_out =
- make_provider("test", "https://example.com", None).with_native_tool_calling(false);
- assert_eq!(
- opted_out.supports_native_tools(),
- ::capabilities(&opted_out).native_tool_calling,
- "after with_native_tool_calling(false): the two capability signals must match"
- );
- assert!(
- !opted_out.supports_native_tools(),
- "after with_native_tool_calling(false), supports_native_tools must report false so the harness picks the prompt-guided fallback"
- );
-}
-
-#[test]
-fn tool_specs_convert_to_openai_format() {
- let specs = vec![crate::openhuman::tools::ToolSpec {
- name: "shell".to_string(),
- description: "Run shell command".to_string(),
- parameters: serde_json::json!({
- "type": "object",
- "properties": {"command": {"type": "string"}},
- "required": ["command"]
- }),
- }];
-
- let tools = OpenAiCompatibleProvider::tool_specs_to_openai_format(&specs);
- assert_eq!(tools.len(), 1);
- assert_eq!(tools[0]["type"], "function");
- assert_eq!(tools[0]["function"]["name"], "shell");
- assert_eq!(tools[0]["function"]["description"], "Run shell command");
- assert_eq!(tools[0]["function"]["parameters"]["required"][0], "command");
-}
-
-#[test]
-fn request_serializes_with_tools() {
- let tools = vec![serde_json::json!({
- "type": "function",
- "function": {
- "name": "get_weather",
- "description": "Get weather for a location",
- "parameters": {
- "type": "object",
- "properties": {
- "location": {"type": "string"}
- }
- }
- }
- })];
-
- let req = ApiChatRequest {
- model: "test-model".to_string(),
- messages: vec![Message {
- role: "user".to_string(),
- content: "What is the weather?".into(),
- }],
- temperature: Some(0.7),
- stream: Some(false),
- tools: Some(tools),
- tool_choice: Some("auto".to_string()),
- };
- let json = serde_json::to_string(&req).unwrap();
- assert!(json.contains("\"tools\""));
- assert!(json.contains("get_weather"));
- assert!(json.contains("\"tool_choice\":\"auto\""));
-}
-
-#[test]
-fn response_with_tool_calls_deserializes() {
- let json = r#"{
- "choices": [{
- "message": {
- "content": null,
- "tool_calls": [{
- "type": "function",
- "function": {
- "name": "get_weather",
- "arguments": "{\"location\":\"London\"}"
- }
- }]
- }
- }]
- }"#;
-
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert!(msg.content.is_none());
- let tool_calls = msg.tool_calls.as_ref().unwrap();
- assert_eq!(tool_calls.len(), 1);
- assert_eq!(
- tool_calls[0].function.as_ref().unwrap().name.as_deref(),
- Some("get_weather")
- );
- assert_eq!(
- tool_calls[0].function.as_ref().unwrap().arguments.as_ref(),
- Some(&serde_json::Value::String(
- "{\"location\":\"London\"}".to_string()
- ))
- );
-}
-
-#[test]
-fn response_with_tool_call_object_arguments_deserializes() {
- let json = r#"{
- "choices": [{
- "message": {
- "content": null,
- "tool_calls": [{
- "id": "call_456",
- "type": "function",
- "function": {
- "name": "get_weather",
- "arguments": {"location":"London","unit":"c"}
- }
- }]
- }
- }]
- }"#;
-
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- let tool_calls = msg.tool_calls.as_ref().unwrap();
- assert_eq!(
- tool_calls[0].function.as_ref().unwrap().arguments.as_ref(),
- Some(&serde_json::json!({"location":"London","unit":"c"}))
- );
-
- let parsed = OpenAiCompatibleProvider::parse_native_response(
- wrap_message(ResponseMessage {
- content: None,
- reasoning_content: None,
- tool_calls: Some(vec![ToolCall {
- id: Some("call_456".to_string()),
- kind: Some("function".to_string()),
- function: Some(Function {
- name: Some("get_weather".to_string()),
- arguments: Some(serde_json::json!({"location":"London","unit":"c"})),
- }),
- extra_content: None,
- }]),
- function_call: None,
- }),
- "test",
- )
- .unwrap();
- assert_eq!(parsed.tool_calls.len(), 1);
- assert_eq!(parsed.tool_calls[0].id, "call_456");
- assert_eq!(
- parsed.tool_calls[0].arguments,
- r#"{"location":"London","unit":"c"}"#
- );
-}
-
-#[test]
-fn parse_native_response_recovers_tool_calls_from_json_content() {
- let content = r#"{"content":"Checking files...","tool_calls":[{"id":"call_json_1","function":{"name":"shell","arguments":"{\"command\":\"ls -la\"}"}}]}"#;
- let parsed = OpenAiCompatibleProvider::parse_native_response(
- wrap_message(ResponseMessage {
- content: Some(content.to_string()),
- reasoning_content: None,
- tool_calls: None,
- function_call: None,
- }),
- "test",
- )
- .unwrap();
-
- assert_eq!(parsed.text.as_deref(), Some("Checking files..."));
- assert_eq!(parsed.tool_calls.len(), 1);
- assert_eq!(parsed.tool_calls[0].id, "call_json_1");
- assert_eq!(parsed.tool_calls[0].name, "shell");
- assert_eq!(parsed.tool_calls[0].arguments, r#"{"command":"ls -la"}"#);
-}
-
-#[test]
-fn parse_native_response_supports_legacy_function_call() {
- let parsed = OpenAiCompatibleProvider::parse_native_response(
- wrap_message(ResponseMessage {
- content: Some("Let me check".to_string()),
- reasoning_content: None,
- tool_calls: None,
- function_call: Some(Function {
- name: Some("shell".to_string()),
- arguments: Some(serde_json::Value::String(
- r#"{"command":"pwd"}"#.to_string(),
- )),
- }),
- }),
- "test",
- )
- .unwrap();
-
- assert_eq!(parsed.tool_calls.len(), 1);
- assert_eq!(parsed.tool_calls[0].name, "shell");
- assert_eq!(parsed.tool_calls[0].arguments, r#"{"command":"pwd"}"#);
-}
-
-#[test]
-fn response_with_multiple_tool_calls() {
- let json = r#"{
- "choices": [{
- "message": {
- "content": "I'll check both.",
- "tool_calls": [
- {
- "type": "function",
- "function": {
- "name": "get_weather",
- "arguments": "{\"location\":\"London\"}"
- }
- },
- {
- "type": "function",
- "function": {
- "name": "get_time",
- "arguments": "{\"timezone\":\"UTC\"}"
- }
- }
- ]
- }
- }]
- }"#;
-
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.content.as_deref(), Some("I'll check both."));
- let tool_calls = msg.tool_calls.as_ref().unwrap();
- assert_eq!(tool_calls.len(), 2);
- assert_eq!(
- tool_calls[0].function.as_ref().unwrap().name.as_deref(),
- Some("get_weather")
- );
- assert_eq!(
- tool_calls[1].function.as_ref().unwrap().name.as_deref(),
- Some("get_time")
- );
-}
-
-#[tokio::test]
-async fn chat_with_tools_fails_without_key() {
- let p = make_provider("TestProvider", "https://example.com", None);
- let messages = vec![ChatMessage {
- id: None,
- role: "user".to_string(),
- content: "hello".to_string(),
- extra_metadata: None,
- }];
- let tools = vec![serde_json::json!({
- "type": "function",
- "function": {
- "name": "test_tool",
- "description": "A test tool",
- "parameters": {}
- }
- })];
-
- let result = p.chat_with_tools(&messages, &tools, "model", 0.7).await;
- assert!(result.is_err());
- assert!(result
- .unwrap_err()
- .to_string()
- .contains("TestProvider API key not set"));
-}
-
-#[test]
-fn response_with_no_tool_calls_has_empty_vec() {
- let json = r#"{"choices":[{"message":{"content":"Just text, no tools."}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.content.as_deref(), Some("Just text, no tools."));
- assert!(msg.tool_calls.is_none());
-}
-
-#[test]
-fn flatten_system_messages_merges_into_first_user_and_removes_system_roles() {
- let messages = vec![
- ChatMessage::system("System A"),
- ChatMessage::assistant("Earlier assistant turn"),
- ChatMessage::system("System B"),
- ChatMessage::user("User turn"),
- ChatMessage::tool(r#"{"ok":true}"#),
- ];
-
- let flattened = OpenAiCompatibleProvider::flatten_system_messages(&messages);
- assert_eq!(flattened.len(), 3);
- assert_eq!(flattened[0].role, "assistant");
- assert_eq!(
- flattened[1].content,
- "System A\n\nSystem B\n\nUser turn".to_string()
- );
- assert_eq!(flattened[1].role, "user");
- assert_eq!(flattened[2].role, "tool");
- assert!(!flattened.iter().any(|m| m.role == "system"));
-}
-
-#[test]
-fn flatten_system_messages_inserts_synthetic_user_when_no_user_exists() {
- let messages = vec![
- ChatMessage::assistant("Assistant only"),
- ChatMessage::system("Synthetic system"),
- ];
-
- let flattened = OpenAiCompatibleProvider::flatten_system_messages(&messages);
- assert_eq!(flattened.len(), 2);
- assert_eq!(flattened[0].role, "user");
- assert_eq!(flattened[0].content, "Synthetic system");
- assert_eq!(flattened[1].role, "assistant");
-}
-
-#[test]
-fn strip_think_tags_removes_multiple_blocks_with_surrounding_text() {
- let input = "Answer A hidden 1 and B hidden 2 done";
- let output = strip_think_tags(input);
- assert_eq!(output, "Answer A and B done");
-}
-
-#[test]
-fn strip_think_tags_drops_tail_for_unclosed_block() {
- let input = "Visiblehidden tail";
- let output = strip_think_tags(input);
- assert_eq!(output, "Visible");
-}
-
-// ----------------------------------------------------------
-// Reasoning model fallback tests (reasoning_content)
-// ----------------------------------------------------------
-
-#[test]
-fn reasoning_content_fallback_when_content_empty() {
- // Reasoning models (Qwen3, GLM-4) return content: "" with reasoning_content populated
- let json =
- r#"{"choices":[{"message":{"content":"","reasoning_content":"Thinking output here"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.effective_content(), "Thinking output here");
-}
-
-#[test]
-fn reasoning_content_fallback_when_content_null() {
- // Some models may return content: null with reasoning_content
- let json = r#"{"choices":[{"message":{"content":null,"reasoning_content":"Fallback text"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.effective_content(), "Fallback text");
-}
-
-#[test]
-fn reasoning_content_fallback_when_content_missing() {
- // content field absent entirely, reasoning_content present
- let json = r#"{"choices":[{"message":{"reasoning_content":"Only reasoning"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.effective_content(), "Only reasoning");
-}
-
-#[test]
-fn reasoning_content_not_used_when_content_present() {
- // Normal model: content populated, reasoning_content should be ignored
- let json = r#"{"choices":[{"message":{"content":"Normal response","reasoning_content":"Should be ignored"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.effective_content(), "Normal response");
-}
-
-#[test]
-fn reasoning_content_used_when_content_only_think_tags() {
- let json = r#"{"choices":[{"message":{"content":"secret","reasoning_content":"Fallback text"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.effective_content(), "Fallback text");
- assert_eq!(
- msg.effective_content_optional().as_deref(),
- Some("Fallback text")
- );
-}
-
-#[test]
-fn reasoning_content_both_absent_returns_empty() {
- // Neither content nor reasoning_content - returns empty string
- let json = r#"{"choices":[{"message":{}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.effective_content(), "");
-}
-
-#[test]
-fn reasoning_content_ignored_by_normal_models() {
- // Standard response without reasoning_content still works
- let json = r#"{"choices":[{"message":{"content":"Hello from Venice!"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert!(msg.reasoning_content.is_none());
- assert_eq!(msg.effective_content(), "Hello from Venice!");
-}
-
-// ----------------------------------------------------------
-// `reasoning` field-name alias (issue #3094)
-//
-// DeepSeek/Qwen3/GLM-4 emit chain-of-thought as `reasoning_content`, but
-// OpenRouter and vLLM/SGLang-backed OpenAI-compatible proxies emit it as
-// `reasoning`. If we only deserialize `reasoning_content`, a third-party
-// thinking-mode provider that uses `reasoning` is captured as `None`, so the
-// CoT is never replayed on the follow-up tool-call turn and the provider
-// rejects the request with `400 The reasoning_content in the thinking mode
-// must be passed back to the API`. The `#[serde(alias = "reasoning")]` makes
-// both field names map to the same captured value.
-// ----------------------------------------------------------
-
-#[test]
-fn reasoning_alias_captured_from_response_message() {
- let json = r#"{"choices":[{"message":{"content":null,"reasoning":"weighing the options"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(
- msg.reasoning_content.as_deref(),
- Some("weighing the options")
- );
-}
-
-#[test]
-fn reasoning_content_canonical_field_still_wins_over_alias_absence() {
- // The canonical `reasoning_content` field keeps working unchanged.
- let json = r#"{"choices":[{"message":{"content":null,"reasoning_content":"canonical cot"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let msg = &resp.choices[0].message;
- assert_eq!(msg.reasoning_content.as_deref(), Some("canonical cot"));
-}
-
-#[test]
-fn reasoning_alias_captured_in_stream_delta() {
- let json = r#"{"choices":[{"delta":{"reasoning":"streamed cot"},"finish_reason":null}]}"#;
- let chunk: StreamChunkResponse = serde_json::from_str(json).unwrap();
- assert_eq!(
- chunk.choices[0].delta.reasoning_content.as_deref(),
- Some("streamed cot")
- );
-}
-
-/// Regression for Sentry TAURI-RUST-A5N: a provider that emits BOTH `reasoning`
-/// and `reasoning_content` in the same message object must not fail with
-/// `duplicate field \`reasoning_content\``. Both keys deserialize and fold into
-/// the canonical field, which wins when both are present.
-#[test]
-fn reasoning_and_reasoning_content_both_present_does_not_error() {
- let json = r#"{"choices":[{"message":{"content":null,"reasoning":"alias cot","reasoning_content":"canonical cot"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json)
- .expect("both reasoning keys must parse without a duplicate-field error");
- assert_eq!(
- resp.choices[0].message.reasoning_content.as_deref(),
- Some("canonical cot"),
- "canonical reasoning_content wins when both keys are present"
- );
-}
-
-/// Same regression on the streaming delta path (TAURI-RUST-A5N also hits the
-/// native stream parser at `compatible_stream_native.rs`).
-#[test]
-fn reasoning_and_reasoning_content_both_present_in_stream_delta_does_not_error() {
- let json = r#"{"choices":[{"delta":{"reasoning":"alias cot","reasoning_content":"canonical cot"},"finish_reason":null}]}"#;
- let chunk: StreamChunkResponse = serde_json::from_str(json)
- .expect("both reasoning keys must parse without a duplicate-field error");
- assert_eq!(
- chunk.choices[0].delta.reasoning_content.as_deref(),
- Some("canonical cot"),
- "canonical reasoning_content wins when both keys are present"
- );
-}
-
-/// Regression for Sentry TAURI-RUST-85R: NVIDIA's OpenAI-compat endpoint returns
-/// `reasoning_content` TWICE in the same message object for some thinking models
-/// (e.g. `stepfun-ai/step-3.7-flash`). The derived `Shadow` struct strict-rejected
-/// the repeated key with `duplicate field \`reasoning_content\``, dropping the
-/// whole completion (2,037 events). The map-fold deserializer tolerates it —
-/// the last non-null copy wins.
-#[test]
-fn duplicate_reasoning_content_key_does_not_error() {
- let json = r#"{"choices":[{"message":{"content":null,"reasoning_content":"first cot","reasoning_content":"second cot"}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json)
- .expect("a repeated reasoning_content key must parse without a duplicate-field error");
- assert_eq!(
- resp.choices[0].message.reasoning_content.as_deref(),
- Some("second cot"),
- "the last non-null reasoning_content copy wins"
- );
-}
-
-/// A repeated `reasoning_content` whose second copy is `null` must not clobber
-/// the real first value — the CoT has to survive to be replayed verbatim.
-#[test]
-fn duplicate_reasoning_content_key_null_second_copy_keeps_value() {
- let json = r#"{"choices":[{"message":{"content":null,"reasoning_content":"real cot","reasoning_content":null}}]}"#;
- let resp: ApiChatResponse = serde_json::from_str(json)
- .expect("a repeated reasoning_content key must parse without a duplicate-field error");
- assert_eq!(
- resp.choices[0].message.reasoning_content.as_deref(),
- Some("real cot"),
- "a null second copy must not clobber the real value"
- );
-}
-
-/// Same duplicate-key regression on the streaming delta path (TAURI-RUST-85R
-/// also hits the native stream parser at `compatible_stream_native.rs`).
-#[test]
-fn duplicate_reasoning_content_key_in_stream_delta_does_not_error() {
- let json = r#"{"choices":[{"delta":{"reasoning_content":"first cot","reasoning_content":"second cot"},"finish_reason":null}]}"#;
- let chunk: StreamChunkResponse = serde_json::from_str(json)
- .expect("a repeated reasoning_content key must parse without a duplicate-field error");
- assert_eq!(
- chunk.choices[0].delta.reasoning_content.as_deref(),
- Some("second cot"),
- "the last non-null reasoning_content copy wins"
- );
-}
-
-/// End-to-end: a tool-call turn whose reasoning arrived under the `reasoning`
-/// alias must still be surfaced by `parse_native_response` so the agent loop
-/// can replay it on the follow-up request (the issue #3094 failure path).
-#[test]
-fn parse_native_response_captures_reasoning_from_alias() {
- let json = r#"{
- "choices":[{"message":{
- "content":null,
- "reasoning":" let me think about this ",
- "tool_calls":[{"id":"call_z","type":"function","function":{"name":"web_fetch","arguments":"{}"}}]
- }}]
- }"#;
- let resp: ApiChatResponse = serde_json::from_str(json).unwrap();
- let parsed = OpenAiCompatibleProvider::parse_native_response(resp, "deepseek").unwrap();
- assert_eq!(parsed.tool_calls.len(), 1);
- assert_eq!(
- parsed.reasoning_content.as_deref(),
- Some("let me think about this"),
- "reasoning captured via the `reasoning` alias must be available to replay"
- );
-}
-
-// ----------------------------------------------------------
-// SSE streaming reasoning_content fallback tests
-// ----------------------------------------------------------
-
-#[test]
-fn parse_sse_line_with_content() {
- let line = r#"data: {"choices":[{"delta":{"content":"hello"}}]}"#;
- let result = parse_sse_line(line).unwrap();
- assert_eq!(result, Some("hello".to_string()));
-}
-
-#[test]
-fn parse_sse_line_with_reasoning_content() {
- let line = r#"data: {"choices":[{"delta":{"reasoning_content":"thinking..."}}]}"#;
- let result = parse_sse_line(line).unwrap();
- assert_eq!(result, Some("thinking...".to_string()));
-}
-
-#[test]
-fn parse_sse_line_with_both_prefers_content() {
- let line = r#"data: {"choices":[{"delta":{"content":"real answer","reasoning_content":"thinking..."}}]}"#;
- let result = parse_sse_line(line).unwrap();
- assert_eq!(result, Some("real answer".to_string()));
-}
-
-#[test]
-fn parse_sse_line_with_empty_content_falls_back_to_reasoning_content() {
- let line = r#"data: {"choices":[{"delta":{"content":"","reasoning_content":"thinking..."}}]}"#;
- let result = parse_sse_line(line).unwrap();
- assert_eq!(result, Some("thinking...".to_string()));
-}
-
-#[test]
-fn parse_sse_line_done_sentinel() {
- let line = "data: [DONE]";
- let result = parse_sse_line(line).unwrap();
- assert_eq!(result, None);
-}
-
-#[test]
-fn normalize_function_arguments_valid_json_string_preserved() {
- let v = Some(serde_json::Value::String(r#"{"path":"/tmp"}"#.to_string()));
- assert_eq!(normalize_function_arguments(v), r#"{"path":"/tmp"}"#);
-}
-
-#[test]
-fn normalize_function_arguments_invalid_json_string_falls_back_to_empty_object() {
- // OPENHUMAN-TAURI-6F: model emitted malformed JSON in `function.arguments`.
- // Forwarding the raw string back upstream causes a 400 from the backend's
- // `json.loads`. Substitute `{}` instead.
- for raw in ["{a:1}", "{'k':'v'}", "{\n", "{,}"] {
- let v = Some(serde_json::Value::String(raw.to_string()));
- assert_eq!(normalize_function_arguments(v), "{}", "raw = {raw:?}");
- }
-}
-
-#[test]
-fn normalize_function_arguments_empty_or_null_becomes_empty_object() {
- assert_eq!(
- normalize_function_arguments(Some(serde_json::Value::String(" ".to_string()))),
- "{}"
- );
- assert_eq!(
- normalize_function_arguments(Some(serde_json::Value::Null)),
- "{}"
- );
- assert_eq!(normalize_function_arguments(None), "{}");
-}
-
-#[test]
-fn normalize_function_arguments_object_value_serializes() {
- let v = Some(serde_json::json!({"path": "/tmp"}));
- assert_eq!(normalize_function_arguments(v), r#"{"path":"/tmp"}"#);
-}
-
-#[test]
-fn parse_provider_tool_call_from_value_guards_malformed_arguments() {
- // OPENHUMAN-TAURI-6F: the early-return path in
- // `parse_provider_tool_call_from_value` previously bypassed
- // `normalize_function_arguments`, forwarding malformed JSON strings
- // directly. Verify the guard now applies on both code paths.
- let value = serde_json::json!({
- "id": "call_bad",
- "name": "shell",
- "arguments": "{a:1}"
- });
- let result = parse_provider_tool_call_from_value(&value);
- let call = result.expect("should produce a ToolCall");
- assert_eq!(
- call.arguments, "{}",
- "malformed arguments string must be normalised to {{}} via the first-path guard"
- );
-}
-
-#[test]
-fn custom_openai_provider_has_no_responses_fallback() {
- let p = OpenAiCompatibleProvider::new_no_responses_fallback(
- "custom_openai",
- "http://localhost:11434/v1",
- Some("sk-test"),
- AuthStyle::Bearer,
- );
- assert!(
- !p.supports_responses_fallback,
- "custom_openai must not attempt the /v1/responses fallback"
- );
-}
-
-#[test]
-fn responses_404_disables_fallback_for_endpoint() {
- // TAURI-RUST-FJZ: a custom slug (factory can't classify it, so the static
- // fallback flag is ON) whose endpoint 404s on `/responses` must stop
- // attempting that fallback once the route is known-missing — routing to
- // chat-completions only. Use a unique base_url; the cache is process-global.
- let base_url = "https://responses-404-test.example.com/v1";
- let p =
- OpenAiCompatibleProvider::new("nous-portal", base_url, Some("sk-test"), AuthStyle::Bearer);
- assert!(
- p.responses_fallback_active(),
- "a fresh custom slug starts with the fallback enabled"
- );
-
- super::mark_responses_api_unsupported(base_url);
-
- assert!(
- super::responses_api_known_unsupported(base_url),
- "the endpoint is recorded as Responses-incapable after a 404"
- );
- assert!(
- !p.responses_fallback_active(),
- "the fallback is disabled once `/responses` has 404'd for this endpoint"
- );
-
- // A provider for a different endpoint is unaffected.
- let other = OpenAiCompatibleProvider::new(
- "nous-portal",
- "https://responses-404-test.example.com/v2",
- Some("sk-test"),
- AuthStyle::Bearer,
- );
- assert!(
- other.responses_fallback_active(),
- "the cache is keyed per-endpoint, not globally"
- );
-}
-
-#[test]
-fn responses_404_route_vs_model_disambiguation() {
- // A generic "route missing" 404 → this endpoint has no Responses API.
- assert!(OpenAiCompatibleProvider::responses_404_indicates_missing_route("404 Not Found"));
- assert!(
- OpenAiCompatibleProvider::responses_404_indicates_missing_route(
- "404 page not found"
- )
- );
- // A model/deployment-specific 404 → the route exists; keep the fallback so
- // we don't poison the cache for other models on a Responses-capable endpoint.
- assert!(
- !OpenAiCompatibleProvider::responses_404_indicates_missing_route(
- r#"{"error":{"message":"model 'gpt-x' not found","code":"model_not_found"}}"#
- )
- );
- assert!(
- !OpenAiCompatibleProvider::responses_404_indicates_missing_route(
- r#"{"error":{"message":"The API deployment for this resource does not exist"}}"#
- )
- );
-}
-
-#[test]
-fn enrich_404_message_adds_hint_when_no_fallback() {
- let p = OpenAiCompatibleProvider::new_no_responses_fallback(
- "custom_openai",
- "http://localhost:11434/v1",
- Some("sk-test"),
- AuthStyle::Bearer,
- );
- let base = "custom_openai API error (404 Not Found): model not found".to_string();
- let result = p.enrich_404_message(base.clone(), reqwest::StatusCode::NOT_FOUND);
- assert!(
- result.starts_with(&base),
- "must preserve original error prefix: {result}"
- );
- assert!(
- result.contains("check that your endpoint URL is correct"),
- "must contain user-actionable hint: {result}"
- );
-
- // Non-404 status should NOT add the hint
- let result_200 = p.enrich_404_message(
- "custom_openai API error (503 Service Unavailable): overloaded".to_string(),
- reqwest::StatusCode::SERVICE_UNAVAILABLE,
- );
- assert!(
- !result_200.contains("check that your endpoint URL"),
- "must not add hint for non-404: {result_200}"
- );
-
- // Provider with fallback enabled should NOT add the hint even on 404
- let p2 = OpenAiCompatibleProvider::new(
- "openai",
- "https://api.openai.com/v1",
- Some("sk-real"),
- AuthStyle::Bearer,
- );
- let result_with_fallback = p2.enrich_404_message(
- "openai API error (404 Not Found): model not found".to_string(),
- reqwest::StatusCode::NOT_FOUND,
- );
- assert_eq!(
- result_with_fallback, "openai API error (404 Not Found): model not found",
- "must not add hint when fallback is enabled: {result_with_fallback}"
- );
-}
-
-// ── reasoning_content round-trip tests (issue #2800 / Sentry TAURI-RUST-4WC) ─
-
-/// `parse_native_response` must capture `reasoning_content` from a non-streaming
-/// `ApiChatResponse` and surface it on `ChatResponse`.
-#[test]
-fn parse_native_response_captures_reasoning_content_from_api_response() {
- let api_resp = ApiChatResponse {
- choices: vec![Choice {
- message: ResponseMessage {
- content: Some("Here is my answer.".into()),
- reasoning_content: Some("I thought about it carefully.".into()),
- tool_calls: None,
- function_call: None,
- },
- }],
- usage: None,
- openhuman: None,
- };
- let result = OpenAiCompatibleProvider::parse_native_response(api_resp, "deepseek").unwrap();
- assert_eq!(
- result.reasoning_content.as_deref(),
- Some("I thought about it carefully."),
- "reasoning_content must be propagated to ChatResponse"
- );
- assert_eq!(result.text.as_deref(), Some("Here is my answer."));
-}
-
-/// When a response has no `reasoning_content`, `ChatResponse.reasoning_content`
-/// must be `None` (no spurious field emitted on the next turn).
-#[test]
-fn parse_native_response_no_reasoning_content_stays_none() {
- let api_resp = ApiChatResponse {
- choices: vec![Choice {
- message: ResponseMessage {
- content: Some("Just a plain answer.".into()),
- reasoning_content: None,
- tool_calls: None,
- function_call: None,
- },
- }],
- usage: None,
- openhuman: None,
- };
- let result = OpenAiCompatibleProvider::parse_native_response(api_resp, "gpt-4o").unwrap();
- assert!(
- result.reasoning_content.is_none(),
- "reasoning_content must be None when the provider did not return it"
- );
-}
-
-/// `convert_messages_for_native` must echo `reasoning_content` back in the
-/// `NativeMessage` for assistant turns that have it stored in `extra_metadata`.
-/// This is the load-bearing contract: without it the API returns HTTP 400.
-#[test]
-fn convert_messages_for_native_echoes_reasoning_content_from_extra_metadata() {
- let mut assistant_msg = ChatMessage::assistant("Here is my answer.");
- assistant_msg.extra_metadata =
- Some(serde_json::json!({ "reasoning_content": "I thought carefully." }));
-
- let messages = vec![
- ChatMessage::user("What is 2+2?"),
- assistant_msg,
- ChatMessage::user("Are you sure?"),
- ];
-
- let native = OpenAiCompatibleProvider::convert_messages_for_native(&messages);
-
- // User messages must not carry reasoning_content.
- assert!(
- native[0].reasoning_content.is_none(),
- "user message must not have reasoning_content"
- );
- // The assistant message with extra_metadata must have reasoning_content echoed.
- assert_eq!(
- native[1].reasoning_content.as_deref(),
- Some("I thought carefully."),
- "assistant message must echo reasoning_content from extra_metadata"
- );
- // Second user message must not carry reasoning_content.
- assert!(
- native[2].reasoning_content.is_none(),
- "second user message must not have reasoning_content"
- );
-}
-
-/// Assistant messages without `extra_metadata` (or without a `reasoning_content`
-/// key) must produce a `NativeMessage` with `reasoning_content = None` — the
-/// `skip_serializing_if` attribute then omits the field from the JSON body so
-/// standard providers don't reject the request.
-#[test]
-fn convert_messages_for_native_no_reasoning_content_stays_none() {
- let messages = vec![ChatMessage::user("hello"), ChatMessage::assistant("world")];
-
- let native = OpenAiCompatibleProvider::convert_messages_for_native(&messages);
- assert!(
- native[1].reasoning_content.is_none(),
- "assistant without extra_metadata must produce reasoning_content = None"
- );
-}
-
-/// The `reasoning_content` field must be omitted from the JSON serialized wire
-/// payload when it is `None`, so standard providers that do not understand the
-/// field are not broken.
-#[test]
-fn native_message_reasoning_content_omitted_when_none() {
- let msg = NativeMessage {
- role: "assistant".to_string(),
- content: Some("hello".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- };
- let json = serde_json::to_value(&msg).unwrap();
- assert!(
- json.get("reasoning_content").is_none(),
- "reasoning_content must be absent from the wire payload when None"
- );
-}
-
-/// When `reasoning_content` is present it must appear in the serialized payload
-/// so thinking-model providers receive it.
-#[test]
-fn native_message_reasoning_content_present_when_some() {
- let msg = NativeMessage {
- role: "assistant".to_string(),
- content: Some("hello".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: Some("I thought carefully.".to_string()),
- };
- let json = serde_json::to_value(&msg).unwrap();
- assert_eq!(
- json.get("reasoning_content").and_then(|v| v.as_str()),
- Some("I thought carefully."),
- "reasoning_content must be present in the wire payload when Some"
- );
-}
-
-// ── convert_tool_specs — TAURI-RUST-2E wire-boundary dedup ─────────────
-
-fn spec(name: &str) -> crate::openhuman::tools::ToolSpec {
- crate::openhuman::tools::ToolSpec {
- name: name.to_string(),
- description: format!("{name} desc"),
- parameters: serde_json::json!({"type": "object"}),
- }
-}
-
-#[test]
-fn convert_tool_specs_none_input_returns_none() {
- assert!(OpenAiCompatibleProvider::convert_tool_specs(None).is_none());
-}
-
-#[test]
-fn convert_tool_specs_empty_slice_returns_empty_vec() {
- let out = OpenAiCompatibleProvider::convert_tool_specs(Some(&[])).unwrap();
- assert!(out.is_empty());
-}
-
-#[test]
-fn convert_tool_specs_passes_through_unique_names() {
- let specs = vec![spec("alpha"), spec("beta"), spec("gamma")];
- let out = OpenAiCompatibleProvider::convert_tool_specs(Some(&specs)).unwrap();
- assert_eq!(out.len(), 3);
- let names: Vec<&str> = out
- .iter()
- .map(|t| t["function"]["name"].as_str().unwrap())
- .collect();
- assert_eq!(names, vec!["alpha", "beta", "gamma"]);
-}
-
-#[test]
-fn convert_tool_specs_dedups_duplicate_names_first_wins() {
- // First occurrence of `alpha` (with description "alpha desc") survives;
- // the second is dropped wholesale even though its `parameters` differ.
- let mut second_alpha = spec("alpha");
- second_alpha.description = "should be dropped".to_string();
- second_alpha.parameters = serde_json::json!({"different": true});
- let specs = vec![spec("alpha"), spec("beta"), second_alpha, spec("gamma")];
-
- let out = OpenAiCompatibleProvider::convert_tool_specs(Some(&specs)).unwrap();
- assert_eq!(
- out.len(),
- 3,
- "duplicate `alpha` must be dropped from wire payload"
- );
- let names: Vec<&str> = out
- .iter()
- .map(|t| t["function"]["name"].as_str().unwrap())
- .collect();
- assert_eq!(names, vec!["alpha", "beta", "gamma"]);
- assert_eq!(
- out[0]["function"]["description"].as_str().unwrap(),
- "alpha desc",
- "first occurrence's description must survive (first-wins)"
- );
-}
-
-#[test]
-fn convert_tool_specs_dedups_many_duplicates() {
- let specs = vec![
- spec("x"),
- spec("x"),
- spec("x"),
- spec("y"),
- spec("y"),
- spec("z"),
- ];
- let out = OpenAiCompatibleProvider::convert_tool_specs(Some(&specs)).unwrap();
- assert_eq!(out.len(), 3);
- let names: Vec<&str> = out
- .iter()
- .map(|t| t["function"]["name"].as_str().unwrap())
- .collect();
- assert_eq!(names, vec!["x", "y", "z"]);
-}
-
-// ── #3193: completion-only model 404 detection + actionable message ──────────
-
-#[test]
-fn completion_only_model_404_detected_from_openai_signature() {
- // The exact body OpenAI returns when a completion-only/base model is sent
- // to /v1/chat/completions.
- let body = "This is not a chat model and thus not supported in the \
- v1/chat/completions endpoint. Did you mean to use v1/completions?";
- assert!(OpenAiCompatibleProvider::is_completion_only_model_404(
- reqwest::StatusCode::NOT_FOUND,
- body
- ));
-}
-
-#[test]
-fn completion_only_model_404_ignores_ordinary_not_found() {
- // A "model does not exist" 404 must NOT be misclassified — it should keep
- // its existing fallback / enrich behaviour, not get the completion-only
- // message.
- let body = "The model `gpt-9o` does not exist or you do not have access to it.";
- assert!(!OpenAiCompatibleProvider::is_completion_only_model_404(
- reqwest::StatusCode::NOT_FOUND,
- body
- ));
-}
-
-#[test]
-fn completion_only_model_404_requires_404_status() {
- // Same phrasing under a non-404 status is not the completion-only case.
- let body = "not a chat model";
- assert!(!OpenAiCompatibleProvider::is_completion_only_model_404(
- reqwest::StatusCode::BAD_REQUEST,
- body
- ));
-}
-
-#[test]
-fn completion_only_message_names_model_and_remediation() {
- let p = make_provider("openhuman", "https://api.example.com/v1", Some("k"));
- let msg = p.completion_only_model_message(
- "davinci-002",
- "This is not a chat model ... Did you mean to use v1/completions?",
- );
- assert!(
- msg.contains("davinci-002"),
- "names the offending model: {msg}"
- );
- assert!(
- msg.contains("completion-only") && msg.contains("chat-completions"),
- "explains the capability mismatch: {msg}"
- );
- assert!(
- msg.contains("chat-capable model"),
- "states the remediation: {msg}"
- );
-}
-
-#[test]
-fn completion_only_404_guard_fires_only_on_signature() {
- let p = make_provider("openhuman", "https://api.example.com/v1", Some("k"));
- // Matches → Some(actionable error).
- let hit = p.completion_only_404_guard(
- reqwest::StatusCode::NOT_FOUND,
- "This is not a chat model. Did you mean to use v1/completions?",
- "davinci-002",
- );
- let err = hit.expect("guard should fire on the completion-only signature");
- assert!(err.to_string().contains("davinci-002"));
- // Ordinary not-found → None (normal fallback/enrich path is preserved).
- assert!(p
- .completion_only_404_guard(
- reqwest::StatusCode::NOT_FOUND,
- "The model `gpt-9o` does not exist.",
- "gpt-9o"
- )
- .is_none());
-}
-
-#[tokio::test]
-async fn completion_only_404_fails_fast_without_responses_fallback() {
- // End-to-end over the wire: a completion-only 404 must short-circuit with
- // the actionable message and NOT attempt /v1/responses (not mounted here —
- // if the guard regressed, the error would instead read "responses fallback
- // failed"). Provider has the fallback ENABLED (default `new`), proving the
- // guard pre-empts it. #3193.
- let server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/v1/chat/completions"))
- .respond_with(ResponseTemplate::new(404).set_body_json(serde_json::json!({
- "error": {
- "message": "This is not a chat model and thus not supported in the \
- v1/chat/completions endpoint. Did you mean to use v1/completions?",
- "type": "invalid_request_error"
- }
- })))
- .mount(&server)
- .await;
-
- let provider = OpenAiCompatibleProvider::new(
- "openhuman",
- &format!("{}/v1", server.uri()),
- Some("key"),
- AuthStyle::Bearer,
- );
-
- let err = provider
- .chat_with_history(&[ChatMessage::user("write a file")], "davinci-002", 0.0)
- .await
- .expect_err("completion-only model must error");
- let msg = err.to_string();
- assert!(
- msg.contains("davinci-002") && msg.contains("chat-capable model"),
- "expected actionable completion-only message, got: {msg}"
- );
- assert!(
- !msg.contains("responses fallback failed"),
- "guard must pre-empt the responses fallback, got: {msg}"
- );
-}
-
-// ── TAURI-RUST-4P6: embedding model picked as chat model → 400 ───────────────
-
-#[test]
-fn not_chat_capable_detected_from_ollama_400() {
- // Verbatim Ollama wire body when an embedding model (bge-m3) is used as
- // the chat model. Sentry issue 5338.
- let body = r#"{"error":{"message":"\"bge-m3:latest\" does not support chat","type":"invalid_request_error","param":null,"code":null}}"#;
- assert!(OpenAiCompatibleProvider::is_not_chat_capable_model(
- reqwest::StatusCode::BAD_REQUEST,
- body
- ));
- // Some compatible backends use 422 for the same class.
- assert!(OpenAiCompatibleProvider::is_not_chat_capable_model(
- reqwest::StatusCode::UNPROCESSABLE_ENTITY,
- body
- ));
-}
-
-#[test]
-fn not_chat_capable_requires_4xx_status() {
- // The exact phrase under a non-4xx status is not this case — let other
- // handling deal with 404/5xx so we don't shadow real failures.
- let body = "\"bge-m3:latest\" does not support chat";
- assert!(!OpenAiCompatibleProvider::is_not_chat_capable_model(
- reqwest::StatusCode::NOT_FOUND,
- body
- ));
- assert!(!OpenAiCompatibleProvider::is_not_chat_capable_model(
- reqwest::StatusCode::INTERNAL_SERVER_ERROR,
- body
- ));
-}
-
-#[test]
-fn not_chat_capable_ignores_unrelated_400() {
- // An ordinary 400 with no "does not support chat" phrase must keep its
- // normal enrich/handling path.
- assert!(!OpenAiCompatibleProvider::is_not_chat_capable_model(
- reqwest::StatusCode::BAD_REQUEST,
- "invalid temperature: only 1 is allowed for this model"
- ));
-}
-
-#[test]
-fn not_chat_capable_message_names_model_remediation_and_keeps_phrase() {
- let p = make_provider("ollama", "http://127.0.0.1:11434/v1", None);
- let msg = p.not_chat_capable_model_message(
- "bge-m3:latest",
- r#"{"error":{"message":"\"bge-m3:latest\" does not support chat"}}"#,
- );
- assert!(msg.contains("bge-m3:latest"), "names the model: {msg}");
- assert!(
- msg.contains("chat-capable model"),
- "states the remediation: {msg}"
- );
- // CRITICAL: the actionable rewrite must still carry the upstream phrase so
- // the re-reported error stays demoted by the config-rejection classifier
- // (otherwise the 36.6k Sentry events come back). See TAURI-RUST-4P6.
- assert!(
- msg.to_lowercase().contains("does not support chat"),
- "must preserve the classifier anchor phrase: {msg}"
- );
- assert!(
- super::super::is_provider_config_rejection_message(&msg),
- "enriched message must classify as a provider config-rejection: {msg}"
- );
-}
-
-#[test]
-fn not_chat_capable_guard_fires_only_on_signature() {
- let p = make_provider("ollama", "http://127.0.0.1:11434/v1", None);
- let hit = p.not_chat_capable_guard(
- reqwest::StatusCode::BAD_REQUEST,
- "\"bge-m3:latest\" does not support chat",
- "bge-m3:latest",
- );
- assert!(hit
- .expect("guard should fire on the does-not-support-chat 400")
- .to_string()
- .contains("bge-m3:latest"));
- // Unrelated 400 → None (normal handling preserved).
- assert!(p
- .not_chat_capable_guard(
- reqwest::StatusCode::BAD_REQUEST,
- "rate limit exceeded",
- "bge-m3:latest"
- )
- .is_none());
-}
-
-#[tokio::test]
-async fn not_chat_capable_400_fails_fast_with_actionable_message() {
- // End-to-end over the wire: an embedding model used as chat 400s, and the
- // guard must short-circuit with the actionable message rather than the
- // opaque upstream JSON. TAURI-RUST-4P6.
- let server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/v1/chat/completions"))
- .respond_with(ResponseTemplate::new(400).set_body_json(serde_json::json!({
- "error": {
- "message": "\"bge-m3:latest\" does not support chat",
- "type": "invalid_request_error",
- "param": null,
- "code": null
- }
- })))
- .mount(&server)
- .await;
-
- let provider = OpenAiCompatibleProvider::new(
- "ollama",
- &format!("{}/v1", server.uri()),
- // Dummy key only to clear the pre-flight credential gate; the mock
- // ignores auth. Real Ollama is keyless, but the provider requires a
- // non-empty credential before dispatching.
- Some("x"),
- AuthStyle::Bearer,
- );
-
- let err = provider
- .chat_with_history(&[ChatMessage::user("hello")], "bge-m3:latest", 0.0)
- .await
- .expect_err("embedding-model-as-chat must error");
- let msg = err.to_string();
- assert!(
- msg.contains("bge-m3:latest") && msg.contains("chat-capable model"),
- "expected actionable does-not-support-chat message, got: {msg}"
- );
- // And it must remain demotable — Sentry suppression depends on it.
- assert!(
- super::super::is_provider_config_rejection_message(&msg),
- "bubbled error must classify as config-rejection, got: {msg}"
- );
-}
-
-// ── #3205: multimodal [IMAGE:] markers → OpenAI image_url content parts ─────────
-
-const TEST_PNG_DATA_URI: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
-
-/// Text with no markers stays the plain-string `content` arm — byte-identical
-/// to the legacy wire shape so every non-attachment turn is unaffected.
-#[test]
-fn message_content_text_only_serializes_as_string() {
- let content = MessageContent::from_chat_text("just a normal message");
- let json = serde_json::to_value(&content).unwrap();
- assert_eq!(json, serde_json::json!("just a normal message"));
-}
-
-/// A user message carrying one `[IMAGE:data-uri]` marker is promoted to the
-/// OpenAI `content` array: a `text` part followed by an `image_url` part.
-#[test]
-fn message_content_text_plus_image_serializes_as_parts() {
- let raw = format!("what is in this picture? [IMAGE:{TEST_PNG_DATA_URI}]");
- let json = serde_json::to_value(MessageContent::from_chat_text(&raw)).unwrap();
- assert_eq!(
- json,
- serde_json::json!([
- { "type": "text", "text": "what is in this picture?" },
- { "type": "image_url", "image_url": { "url": TEST_PNG_DATA_URI } },
- ])
- );
-}
-
-/// An image with no accompanying text emits only the `image_url` part.
-#[test]
-fn message_content_image_only_omits_empty_text_part() {
- let raw = format!("[IMAGE:{TEST_PNG_DATA_URI}]");
- let json = serde_json::to_value(MessageContent::from_chat_text(&raw)).unwrap();
- assert_eq!(
- json,
- serde_json::json!([
- { "type": "image_url", "image_url": { "url": TEST_PNG_DATA_URI } },
- ])
- );
-}
-
-/// Multiple markers become multiple `image_url` parts, with the text between
-/// them preserved in authored order (not collapsed before the images).
-#[test]
-fn message_content_multiple_images_serialize_in_order() {
- let raw = format!("compare [IMAGE:{TEST_PNG_DATA_URI}] and [IMAGE:https://example.com/b.jpg]");
- let json = serde_json::to_value(MessageContent::from_chat_text(&raw)).unwrap();
- assert_eq!(
- json,
- serde_json::json!([
- { "type": "text", "text": "compare" },
- { "type": "image_url", "image_url": { "url": TEST_PNG_DATA_URI } },
- { "type": "text", "text": "and" },
- { "type": "image_url", "image_url": { "url": "https://example.com/b.jpg" } },
- ])
- );
-}
-
-/// Interleaved order is preserved exactly — an image-first prompt keeps the
-/// image before the trailing text (CodeRabbit #3268).
-#[test]
-fn message_content_preserves_image_first_then_text_order() {
- let raw = format!("[IMAGE:{TEST_PNG_DATA_URI}] then explain");
- let json = serde_json::to_value(MessageContent::from_chat_text(&raw)).unwrap();
- assert_eq!(
- json,
- serde_json::json!([
- { "type": "image_url", "image_url": { "url": TEST_PNG_DATA_URI } },
- { "type": "text", "text": "then explain" },
- ])
- );
-}
-
-/// Request-level: a chat history with an image-bearing user turn serialises the
-/// full body with a string `system` content and an array `user` content.
-#[test]
-fn api_chat_request_mixes_string_and_array_content() {
- let req = ApiChatRequest {
- model: "gpt-4o".to_string(),
- messages: vec![
- Message {
- role: "system".to_string(),
- content: "You are helpful.".into(),
- },
- Message {
- role: "user".to_string(),
- content: MessageContent::from_chat_text(&format!(
- "describe this [IMAGE:{TEST_PNG_DATA_URI}]"
- )),
- },
- ],
- temperature: None,
- stream: None,
- tools: None,
- tool_choice: None,
- };
- let json = serde_json::to_value(&req).unwrap();
- assert_eq!(
- json["messages"][0]["content"],
- serde_json::json!("You are helpful.")
- );
- assert_eq!(
- json["messages"][1]["content"],
- serde_json::json!([
- { "type": "text", "text": "describe this" },
- { "type": "image_url", "image_url": { "url": TEST_PNG_DATA_URI } },
- ])
- );
-}
-
-/// The agent streaming path runs history through `convert_messages_for_native`;
-/// an image marker must survive into the `NativeMessage` array content while
-/// plain turns stay strings.
-#[test]
-fn convert_messages_for_native_promotes_image_marker() {
- let history = vec![
- ChatMessage::system("be brief"),
- ChatMessage::user(&format!("look [IMAGE:{TEST_PNG_DATA_URI}]")),
- ];
- let native = OpenAiCompatibleProvider::convert_messages_for_native(&history);
- assert_eq!(
- serde_json::to_value(&native[0]).unwrap()["content"],
- serde_json::json!("be brief")
- );
- assert_eq!(
- serde_json::to_value(&native[1]).unwrap()["content"],
- serde_json::json!([
- { "type": "text", "text": "look" },
- { "type": "image_url", "image_url": { "url": TEST_PNG_DATA_URI } },
- ])
- );
-}
-
-#[test]
-fn stream_repeat_detector_trips_at_threshold() {
- let mut d = StreamRepeatDetector::new();
- // The degenerate pattern: one substantial sentence emitted with blank
- // separators, over and over (exactly what we observed, 234×).
- let chunk =
- "Now I have a complete understanding. Let me also check the llm.rs extraction logic.\n\n";
- let mut tripped_at = 0;
- for i in 1..=(STREAM_REPEAT_THRESHOLD + 3) {
- if d.observe(chunk) {
- tripped_at = i;
- break;
- }
- }
- assert_eq!(
- tripped_at, STREAM_REPEAT_THRESHOLD,
- "should trip exactly at the threshold, ignoring blank separators"
- );
-}
-
-#[test]
-fn stream_repeat_detector_ignores_varied_and_short_lines() {
- let mut d = StreamRepeatDetector::new();
- // Distinct substantial lines never trip (real, progressing output).
- for i in 0..20 {
- assert!(
- !d.observe(&format!(
- "This is distinct analysis step number {i} of the task.\n"
- )),
- "varied lines must not trip"
- );
- }
- // Short identical lines (e.g. code braces) are below the min length → no trip.
- for _ in 0..20 {
- assert!(!d.observe("}\n"), "short repeated lines must not trip");
- }
-}
-
-// ── effective_context_window (#3550 / Sentry TAURI-RUST-6V0) ───────────────
-
-#[tokio::test]
-async fn effective_context_window_cloud_uses_static_table() {
- // No local provider kind → static trained-max table, unchanged behavior.
- let p = make_provider("openai", "https://api.openai.com/v1", Some("k"));
- assert_eq!(p.effective_context_window("gpt-4o").await, Some(128_000));
- // Unknown cloud model → None (skip trimming), as before.
- assert_eq!(p.effective_context_window("totally-unknown").await, None);
-}
-
-#[tokio::test]
-async fn effective_context_window_lmstudio_uses_loaded_window() {
- use crate::openhuman::inference::local::profile::LocalProviderKind;
- let server = MockServer::start().await;
- Mock::given(method("GET"))
- .and(path("/api/v0/models"))
- .respond_with(ResponseTemplate::new(200).set_body_raw(
- r#"{"data":[{"id":"qwen2.5-7b","loaded_context_length":4096,"max_context_length":32768}]}"#,
- "application/json",
- ))
- .mount(&server)
- .await;
- let p = OpenAiCompatibleProvider::new("lmstudio", &server.uri(), None, AuthStyle::None)
- .with_local_provider_kind(LocalProviderKind::LmStudio);
- // Trim to the runtime-loaded n_ctx (4096), NOT the model's trained max.
- assert_eq!(p.effective_context_window("qwen2.5-7b").await, Some(4096));
-}
-
-#[tokio::test]
-async fn effective_context_window_lmstudio_falls_back_when_native_unavailable() {
- use crate::openhuman::inference::local::profile::LocalProviderKind;
- let server = MockServer::start().await;
- Mock::given(method("GET"))
- .and(path("/api/v0/models"))
- .respond_with(ResponseTemplate::new(404))
- .mount(&server)
- .await;
- let p = OpenAiCompatibleProvider::new("lmstudio", &server.uri(), None, AuthStyle::None)
- .with_local_provider_kind(LocalProviderKind::LmStudio);
- // Native probe fails → fall back to the LM Studio profile default (8192),
- // so unknown local models still get trimmed instead of skipped.
- assert_eq!(
- p.effective_context_window("unknown-local-model").await,
- Some(8_192)
- );
-}
-
-/// Verbatim TAURI-RUST-4QF DeepSeek 402 body. The demote arms key on the
-/// "insufficient balance" phrase via `body_indicates_insufficient_credits`, so
-/// pinning the exact wire shape makes a provider wording drift fail CI rather
-/// than silently re-flood Sentry (23,970 events from 17 BYO users).
-const DEEPSEEK_4QF_402_BODY: &str = r#"{"error":{"message":"Insufficient Balance","type":"unknown_error","param":null,"code":"invalid_request_error"}}"#;
-
-/// Build a Sentry hub backed by a `TestTransport` and install it for the
-/// current scope, returning the transport so the test can assert no events
-/// were captured. Mirrors the inline setup used by the other
-/// `*_not_reported_to_sentry` guards above.
-fn install_test_sentry_hub() -> (Arc, sentry::HubSwitchGuard) {
- let transport = TestTransport::new();
- let options = sentry::ClientOptions {
- dsn: Some("https://public@sentry.invalid/1".parse().unwrap()),
- transport: Some(Arc::new(transport.clone())),
- ..Default::default()
- };
- let hub = Arc::new(sentry::Hub::new(
- Some(Arc::new(options.into())),
- Arc::new(Default::default()),
- ));
- let guard = sentry::HubSwitchGuard::new(hub);
- (transport, guard)
-}
-
-#[tokio::test]
-async fn chat_with_system_insufficient_balance_402_not_reported_to_sentry() {
- // TAURI-RUST-4QF: a BYO DeepSeek account out of balance 402s on every agent
- // turn. The non-streaming `chat_with_system` path (operation=chat_completions
- // in the Sentry tags) must still propagate the error, but must NOT page
- // Sentry — the user's own provider balance is exhausted, no local lever.
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(402).set_body_string(DEEPSEEK_4QF_402_BODY))
- .mount(&mock_server)
- .await;
-
- let (transport, _guard) = install_test_sentry_hub();
-
- let provider = make_provider("deepseek", &mock_server.uri(), Some("byo-key"));
- let err = provider
- .chat_with_system(None, "hello", "deepseek-v4-flash", 0.7)
- .await
- .expect_err("a 402 insufficient-balance must still propagate as Err");
- assert!(err.to_string().contains("402"), "err: {err}");
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "an exhausted BYO balance 402 must not be reported to Sentry"
- );
-}
-
-#[tokio::test]
-async fn chat_with_history_insufficient_balance_402_not_reported_to_sentry() {
- // Same 402 user-state reached through `chat_with_history`, which routes its
- // non-2xx through the shared `api_error` helper. Guards the api_error arm.
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(402).set_body_string(DEEPSEEK_4QF_402_BODY))
- .mount(&mock_server)
- .await;
-
- let (transport, _guard) = install_test_sentry_hub();
-
- let provider = make_provider("deepseek", &mock_server.uri(), Some("byo-key"));
- let err = provider
- .chat_with_history(&[ChatMessage::user("hello")], "deepseek-v4-flash", 0.0)
- .await
- .expect_err("a 402 insufficient-balance must still propagate as Err");
- assert!(err.to_string().contains("402"), "err: {err}");
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "an exhausted BYO balance 402 (api_error path) must not be reported to Sentry"
- );
-}
-
-#[tokio::test]
-async fn streaming_chat_insufficient_balance_402_not_reported_to_sentry() {
- // The streaming entry (`stream_native_chat`, operation=streaming_chat) has
- // its own non-2xx cascade. A 402 insufficient-balance there must demote too.
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(402).set_body_string(DEEPSEEK_4QF_402_BODY))
- .mount(&mock_server)
- .await;
-
- let (transport, _guard) = install_test_sentry_hub();
-
- let provider =
- OpenAiCompatibleProvider::new("deepseek", &mock_server.uri(), None, AuthStyle::None);
- let request = NativeChatRequest {
- model: "deepseek-v4-flash".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("hello".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- };
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(8);
-
- let err = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect_err("a 402 insufficient-balance must still propagate as Err");
- assert!(
- err.to_string().contains("streaming API error"),
- "err: {err}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "an exhausted BYO balance 402 (streaming path) must not be reported to Sentry"
- );
-}
-
-#[tokio::test]
-async fn responses_api_insufficient_balance_402_not_reported_to_sentry() {
- // The responses-API path (`chat_via_responses`, operation=responses_api) is
- // reached when the provider is configured responses-primary. A 402
- // insufficient-balance there must demote, not page Sentry. This path is
- // awaited inline, so the TestTransport assertion is authoritative.
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .respond_with(ResponseTemplate::new(402).set_body_string(DEEPSEEK_4QF_402_BODY))
- .mount(&mock_server)
- .await;
-
- let (transport, _guard) = install_test_sentry_hub();
-
- let provider = OpenAiCompatibleProvider::new(
- "deepseek",
- &mock_server.uri(),
- Some("byo-key"),
- AuthStyle::Bearer,
- )
- .with_responses_api_primary();
- let err = provider
- .chat_with_history(&[ChatMessage::user("hello")], "deepseek-v4-flash", 0.0)
- .await
- .expect_err("a 402 insufficient-balance must still propagate as Err");
- // The responses-API error message is ` Responses API error: `
- // — note it carries NO "(402" status token, so the message-keyed before_send
- // net (#3913, `is_insufficient_credits_message`) would MISS it. Only the
- // status-based source arm here catches it, which the empty-transport
- // assertion below proves.
- assert!(
- err.to_string().contains("Insufficient Balance"),
- "err: {err}"
- );
- assert!(
- transport.fetch_and_clear_events().is_empty(),
- "an exhausted BYO balance 402 (responses_api path) must not be reported to Sentry"
- );
-}
-
-#[tokio::test]
-async fn stream_chat_with_system_insufficient_balance_402_propagates_error() {
- // Exercises the `stream_chat_with_system` (operation=stream_chat) 402
- // insufficient-balance demote arm. The streaming work runs in a detached
- // tokio task whose Sentry hub is NOT the test hub, so a TestTransport
- // assertion would be vacuous here; instead assert the error still
- // propagates as a terminal Provider chunk (the demote arm and the report
- // fallback bail the same message, so this guards line execution + error
- // shape). The Sentry-suppression behavior for this exact body is proven by
- // the inline-awaited native/api tests above and the
- // `detects_insufficient_balance_402_family` predicate test.
- use crate::openhuman::inference::provider::traits::{StreamError, StreamOptions};
- use futures_util::StreamExt;
-
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(402).set_body_string(DEEPSEEK_4QF_402_BODY))
- .mount(&mock_server)
- .await;
-
- let provider =
- OpenAiCompatibleProvider::new("deepseek", &mock_server.uri(), None, AuthStyle::None);
- let mut stream = provider.stream_chat_with_system(
- None,
- "hello",
- "deepseek-v4-flash",
- 0.7,
- StreamOptions::new(true),
- );
- let mut terminal: Option = None;
- while let Some(item) = stream.next().await {
- if let Err(StreamError::Provider(msg)) = item {
- terminal = Some(msg);
- }
- }
- let msg = terminal.expect("a 402 must yield a terminal Provider error chunk");
- assert!(
- msg.contains("402") && msg.contains("Insufficient Balance"),
- "msg: {msg}"
- );
-}
-
-#[tokio::test]
-async fn stream_chat_with_history_insufficient_balance_402_propagates_error() {
- // Sibling of the above for `stream_chat_with_history`
- // (operation=stream_chat_history). Same detached-task caveat — asserts the
- // 402 path executes and propagates as a terminal Provider error chunk.
- use crate::openhuman::inference::provider::traits::{StreamError, StreamOptions};
- use futures_util::StreamExt;
-
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(402).set_body_string(DEEPSEEK_4QF_402_BODY))
- .mount(&mock_server)
- .await;
-
- let provider =
- OpenAiCompatibleProvider::new("deepseek", &mock_server.uri(), None, AuthStyle::None);
- let mut stream = provider.stream_chat_with_history(
- &[ChatMessage::user("hello")],
- "deepseek-v4-flash",
- 0.7,
- StreamOptions::new(true),
- );
- let mut terminal: Option = None;
- while let Some(item) = stream.next().await {
- if let Err(StreamError::Provider(msg)) = item {
- terminal = Some(msg);
- }
- }
- let msg = terminal.expect("a 402 must yield a terminal Provider error chunk");
- assert!(
- msg.contains("402") && msg.contains("Insufficient Balance"),
- "msg: {msg}"
- );
-}
-
-// ----------------------------------------------------------
-// Prompt-cache capability model (#3939)
-// ----------------------------------------------------------
-
-#[test]
-fn prompt_cache_caps_openai_style_for_known_slugs() {
- for slug in ["openai", "openrouter", "gmi"] {
- let caps = super::prompt_cache_for_compatible_slug(slug);
- assert!(
- caps.automatic_prefix_cache,
- "{slug} should advertise automatic prefix cache"
- );
- assert!(
- caps.usage_reports_cached_input,
- "{slug} should report cached input tokens"
- );
- assert!(
- !caps.explicit_cache_control,
- "OpenAI-compatible chat API has no cache-control field"
- );
- assert!(
- !caps.cache_key_grouping,
- "thread/session grouping is OpenHuman-backend-only"
- );
- }
-}
-
-#[test]
-fn prompt_cache_caps_match_slug_family_variants() {
- // Case-insensitive, leading-segment family match so renamed/suffixed slugs
- // still resolve to the verified family.
- for slug in ["OpenAI", "openai:gpt-5.1", "openai/responses", "openai-eu"] {
- let caps = super::prompt_cache_for_compatible_slug(slug);
- assert!(
- caps.automatic_prefix_cache && caps.usage_reports_cached_input,
- "{slug} should resolve to the openai family"
- );
- }
-}
-
-#[test]
-fn prompt_cache_caps_conservative_for_unknown_or_custom_slugs() {
- // Custom / local / unverified providers must not advertise caching — they
- // get the all-false default so we never send or assume unsupported behaviour.
- let conservative =
- crate::openhuman::inference::provider::traits::PromptCacheCapabilities::default();
- for slug in ["custom_openai", "lmstudio", "deepseek", "mystery-proxy", ""] {
- assert_eq!(
- super::prompt_cache_for_compatible_slug(slug),
- conservative,
- "{slug} must stay conservative"
- );
- }
-}
-
-#[test]
-fn compatible_provider_declares_prompt_cache_from_its_slug() {
- let conservative =
- crate::openhuman::inference::provider::traits::PromptCacheCapabilities::default();
-
- let openai = make_provider("openai", "https://api.openai.com", Some("k"));
- let caps = openai.prompt_cache_capabilities();
- assert!(
- caps.automatic_prefix_cache && caps.usage_reports_cached_input,
- "openai provider must advertise OpenAI-style caching"
- );
-
- let custom = make_provider("custom_openai", "https://proxy.example", Some("k"));
- assert_eq!(
- custom.prompt_cache_capabilities(),
- conservative,
- "unknown custom provider must stay conservative"
- );
-}
-
-#[test]
-fn extract_usage_normalizes_openai_cached_prompt_tokens() {
- // Regression: an OpenAI-compatible usage block carrying cached prefix tokens
- // (`prompt_tokens_details.cached_tokens`) must normalize into
- // `UsageInfo.cached_input_tokens` so cached-prefix cost accounting is exact.
- let json = r#"{
- "choices":[{"message":{"role":"assistant","content":"hi"}}],
- "usage":{"prompt_tokens":1000,"completion_tokens":20,"total_tokens":1020,
- "prompt_tokens_details":{"cached_tokens":768}}
- }"#;
- let resp: ApiChatResponse = serde_json::from_str(json).expect("parse api response");
- let usage = OpenAiCompatibleProvider::extract_usage(&resp).expect("usage present");
- assert_eq!(usage.input_tokens, 1000);
- assert_eq!(usage.output_tokens, 20);
- assert_eq!(
- usage.cached_input_tokens, 768,
- "cached prefix tokens must be normalized into cached_input_tokens"
- );
-}
-
-#[test]
-fn extract_usage_defaults_cached_tokens_to_zero_when_absent() {
- // A provider that omits cache details must yield cached_input_tokens = 0,
- // keeping cost accounting coherent (full prompt charged at the input rate).
- let json = r#"{
- "choices":[{"message":{"role":"assistant","content":"hi"}}],
- "usage":{"prompt_tokens":500,"completion_tokens":10,"total_tokens":510}
- }"#;
- let resp: ApiChatResponse = serde_json::from_str(json).expect("parse api response");
- let usage = OpenAiCompatibleProvider::extract_usage(&resp).expect("usage present");
- assert_eq!(usage.cached_input_tokens, 0);
- assert_eq!(usage.input_tokens, 500);
-}
-
-/// Minimal valid Responses SSE body so the Codex OAuth streamed-aggregate
-/// path returns `Ok("hi")`.
-const CODEX_RESPONSES_SSE_OK: &str =
- "data: {\"type\":\"response.output_text.delta\",\"delta\":\"hi\"}\n\n\
- data: {\"type\":\"response.completed\",\"response\":{\"output_text\":\"hi\"}}\n\n\
- data: [DONE]\n";
-
-/// TAURI-RUST-AHX: the ChatGPT-OAuth Codex Responses endpoint
-/// (`chatgpt.com/backend-api/codex/responses`) rejects the `auto` model
-/// sentinel with a 400 (`The 'auto' model is not supported when using Codex
-/// with a ChatGPT account.`). `chat_via_responses` must remap `auto` to a
-/// concrete Codex-class model before the request leaves, so the provider
-/// never sees `auto`.
-#[tokio::test]
-async fn codex_oauth_responses_remaps_auto_model() {
- let mock_server = MockServer::start().await;
-
- // Codex OAuth base-URL shape: the path carries `backend-api/codex`, so
- // `is_codex_oauth_responses` fires and `responses_url()` resolves to
- // `/responses`.
- let base_url = format!("{}/backend-api/codex", mock_server.uri());
-
- Mock::given(method("POST"))
- .and(path("/backend-api/codex/responses"))
- .respond_with(ResponseTemplate::new(200).set_body_string(CODEX_RESPONSES_SSE_OK))
- .mount(&mock_server)
- .await;
-
- let provider = make_provider("openai", &base_url, Some("oauth-access-token"));
- let messages = vec![ChatMessage {
- id: None,
- role: "user".to_string(),
- content: "hello".to_string(),
- extra_metadata: None,
- }];
-
- let out = provider
- .chat_via_responses(Some("oauth-access-token"), &messages, "auto", None)
- .await
- .expect("codex oauth responses call should succeed");
- assert_eq!(out, "hi");
-
- // The model on the wire must be a concrete Codex-class model, never `auto`.
- let requests = mock_server.received_requests().await.unwrap();
- assert_eq!(requests.len(), 1, "expected exactly one responses request");
- let body: serde_json::Value = serde_json::from_slice(&requests[0].body).unwrap();
- let sent_model = body
- .get("model")
- .and_then(|m| m.as_str())
- .unwrap_or_default();
- assert_ne!(
- sent_model, "auto",
- "auto sentinel must not leak to the Codex OAuth endpoint"
- );
- assert_eq!(
- sent_model,
- super::super::openai_codex::OPENAI_CODEX_MODEL_HINTS[0],
- "auto must be remapped to the preferred concrete Codex model"
- );
-}
-
-/// Scope guard for TAURI-RUST-AHX: only the `auto` sentinel is remapped — a
-/// concrete model the user pinned must pass through to the Codex OAuth
-/// endpoint untouched.
-#[tokio::test]
-async fn codex_oauth_responses_preserves_concrete_model() {
- let mock_server = MockServer::start().await;
- let base_url = format!("{}/backend-api/codex", mock_server.uri());
-
- Mock::given(method("POST"))
- .and(path("/backend-api/codex/responses"))
- .respond_with(ResponseTemplate::new(200).set_body_string(CODEX_RESPONSES_SSE_OK))
- .mount(&mock_server)
- .await;
-
- let provider = make_provider("openai", &base_url, Some("oauth-access-token"));
- let messages = vec![ChatMessage {
- id: None,
- role: "user".to_string(),
- content: "hello".to_string(),
- extra_metadata: None,
- }];
-
- provider
- .chat_via_responses(Some("oauth-access-token"), &messages, "gpt-5.3-codex", None)
- .await
- .expect("codex oauth responses call should succeed");
-
- let requests = mock_server.received_requests().await.unwrap();
- let body: serde_json::Value = serde_json::from_slice(&requests[0].body).unwrap();
- assert_eq!(
- body.get("model").and_then(|m| m.as_str()),
- Some("gpt-5.3-codex"),
- "a concrete pinned model must not be remapped"
- );
-}
-
-// ---------------------------------------------------------------------------
-// #4269: SSE inactivity watchdog on stream_native_chat
-// ---------------------------------------------------------------------------
-
-/// Minimal streaming request for the watchdog tests.
-fn watchdog_request() -> NativeChatRequest {
- NativeChatRequest {
- model: "watchdog-model".to_string(),
- messages: vec![NativeMessage {
- role: "user".to_string(),
- content: Some("hi".into()),
- tool_call_id: None,
- tool_calls: None,
- reasoning_content: None,
- }],
- temperature: Some(0.7),
- stream: Some(true),
- tools: None,
- tool_choice: None,
- thread_id: None,
- stream_options: Some(super::compatible_types::OpenAiStreamOptions {
- include_usage: true,
- }),
- options: None,
- frequency_penalty: None,
- max_tokens: None,
- }
-}
-
-/// Raw TCP server: writes a 200 SSE response head, plays `script` (each entry:
-/// sleep `delay`, then write `bytes`), then either closes the socket
-/// (`close_after`) or holds it open for `hold_open`. wiremock can't stall
-/// mid-body, so this reproduces the #4269 upstream-stall shape deterministically.
-async fn spawn_scripted_sse(
- script: Vec<(std::time::Duration, &'static str)>,
- close_after: bool,
- hold_open: std::time::Duration,
-) -> String {
- use tokio::io::{AsyncReadExt, AsyncWriteExt};
- let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
- let addr = listener.local_addr().unwrap();
- tokio::spawn(async move {
- if let Ok((mut sock, _)) = listener.accept().await {
- // Best-effort drain of the request head so the client's send() completes.
- let mut buf = [0u8; 2048];
- let _ = sock.read(&mut buf).await;
- let head =
- "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\n\r\n";
- if sock.write_all(head.as_bytes()).await.is_err() {
- return;
- }
- let _ = sock.flush().await;
- for (delay, bytes) in script {
- tokio::time::sleep(delay).await;
- if sock.write_all(bytes.as_bytes()).await.is_err() {
- return;
- }
- let _ = sock.flush().await;
- }
- if close_after {
- return;
- }
- tokio::time::sleep(hold_open).await;
- }
- });
- format!("http://{addr}")
-}
-
-#[tokio::test]
-async fn stream_watchdog_trips_on_stalled_read() {
- // Upstream flushes 200 SSE headers then goes silent and holds the socket —
- // the #4269 shape. With a short idle window the read watchdog must abort
- // with a retryable error rather than parking on next().await until the
- // whole-request timeout (which #3856 tells operators to raise up to 1h).
- let url = spawn_scripted_sse(vec![], false, std::time::Duration::from_secs(30)).await;
- let provider = OpenAiCompatibleProvider::new("stalltest", &url, None, AuthStyle::None)
- .with_stream_idle_timeout(std::time::Duration::from_millis(400));
- let request = watchdog_request();
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(8);
- let err = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect_err("a stalled stream must trip the read watchdog");
- let msg = err.to_string();
- assert!(
- msg.contains("streaming watchdog") && msg.contains("no response data"),
- "unexpected error: {msg}"
- );
- // Must classify as retryable so ReliableProvider replays the turn.
- assert!(
- !crate::openhuman::inference::provider::reliable::is_non_retryable(&err),
- "watchdog stall must be retryable, got: {msg}"
- );
-}
-
-#[tokio::test]
-async fn stream_watchdog_resets_on_each_chunk() {
- // Chunks arrive every 150ms — each well under the 500ms idle window — so the
- // watchdog resets on every chunk and never fires: a legitimately long
- // response that keeps emitting tokens is not cut (the #4269 no-regression
- // guarantee).
- let chunk = "data: {\"choices\":[{\"delta\":{\"content\":\"tok \"}}]}\n\n";
- let script = vec![
- (std::time::Duration::from_millis(150), chunk),
- (std::time::Duration::from_millis(150), chunk),
- (std::time::Duration::from_millis(150), chunk),
- (std::time::Duration::from_millis(150), "data: [DONE]\n\n"),
- ];
- let url = spawn_scripted_sse(script, true, std::time::Duration::from_secs(0)).await;
- let provider = OpenAiCompatibleProvider::new("resettest", &url, None, AuthStyle::None)
- .with_stream_idle_timeout(std::time::Duration::from_millis(500));
- let request = watchdog_request();
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(64);
- let resp = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect("chunks within the idle window must not trip the watchdog");
- let text = resp.text.as_deref().unwrap_or_default();
- assert!(
- text.contains("tok tok tok"),
- "all three tokens must stream to completion (watchdog must not fire): {text:?}"
- );
-}
-
-#[tokio::test]
-async fn stream_watchdog_trips_on_wedged_delta_consumer() {
- // The full SSE body arrives at once, but the delta channel is capacity-1 and
- // never drained (receiver held, not polled). The send-side watchdog must
- // trip rather than block the stream forever on a full delta channel — the
- // backpressure-wedge path (#4269).
- let body = "data: {\"choices\":[{\"delta\":{\"content\":\"a\"}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"content\":\"b\"}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"content\":\"c\"}}]}\n\n\
- data: [DONE]\n\n";
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(200).set_body_raw(body, "text/event-stream"))
- .mount(&mock_server)
- .await;
- let provider =
- OpenAiCompatibleProvider::new("wedgetest", &mock_server.uri(), None, AuthStyle::None)
- .with_stream_idle_timeout(std::time::Duration::from_millis(300));
- let request = watchdog_request();
- // Capacity 1, receiver kept alive but never polled -> the second send wedges.
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(1);
- let err = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect_err("a wedged delta consumer must trip the send-side watchdog");
- let msg = err.to_string();
- assert!(
- msg.contains("streaming watchdog") && msg.contains("delta channel"),
- "unexpected error: {msg}"
- );
- assert!(
- !crate::openhuman::inference::provider::reliable::is_non_retryable(&err),
- "watchdog wedge must be retryable, got: {msg}"
- );
-}
-
-#[tokio::test]
-async fn stream_watchdog_tolerates_dropped_delta_receiver() {
- // A dropped receiver is benign, not a stall: forward_delta returns Ok and the
- // loop keeps aggregating, so the response still completes with no watchdog error.
- let body = "data: {\"choices\":[{\"delta\":{\"content\":\"x\"}}]}\n\n\
- data: {\"choices\":[{\"delta\":{\"content\":\"y\"}}]}\n\n\
- data: [DONE]\n\n";
- let mock_server = MockServer::start().await;
- Mock::given(method("POST"))
- .and(path("/chat/completions"))
- .respond_with(ResponseTemplate::new(200).set_body_raw(body, "text/event-stream"))
- .mount(&mock_server)
- .await;
- let provider =
- OpenAiCompatibleProvider::new("droptest", &mock_server.uri(), None, AuthStyle::None)
- .with_stream_idle_timeout(std::time::Duration::from_millis(300));
- let request = watchdog_request();
- let (delta_tx, delta_rx) = tokio::sync::mpsc::channel(8);
- drop(delta_rx); // consumer gone before streaming starts
- let resp = provider
- .stream_native_chat(None, &request, &delta_tx, 0)
- .await
- .expect("a dropped delta receiver must not fail the stream");
- assert_eq!(resp.text.as_deref(), Some("xy"));
-}
-
-#[tokio::test]
-async fn stream_stops_on_done_even_if_socket_lingers() {
- // A provider that sends `[DONE]` then holds the socket open must finalize the
- // (complete) response immediately — the watchdog must NOT re-arm and fail it
- // as a stall. Regression for the watchdog + terminal-sentinel interaction
- // (CodeRabbit review, PR #4393). With the pre-fix `continue`, this stream
- // would trip the 300ms idle watchdog instead of completing.
- let script = vec![
- (
- std::time::Duration::from_millis(0),
- "data: {\"choices\":[{\"delta\":{\"content\":\"done-content\"}}]}\n\n",
- ),
- (std::time::Duration::from_millis(0), "data: [DONE]\n\n"),
- ];
- // close_after = false: hold the socket open for 30s AFTER [DONE].
- let url = spawn_scripted_sse(script, false, std::time::Duration::from_secs(30)).await;
- let provider = OpenAiCompatibleProvider::new("donetest", &url, None, AuthStyle::None)
- .with_stream_idle_timeout(std::time::Duration::from_millis(300));
- let request = watchdog_request();
- let (delta_tx, _delta_rx) = tokio::sync::mpsc::channel(8);
- // Must return well under the 30s socket hold (and without a stall error).
- let resp = tokio::time::timeout(
- std::time::Duration::from_secs(5),
- provider.stream_native_chat(None, &request, &delta_tx, 0),
- )
- .await
- .expect("must complete on [DONE], not wait for the socket to close")
- .expect("[DONE] must finalize the response, not trip the watchdog");
- assert_eq!(resp.text.as_deref(), Some("done-content"));
-}
diff --git a/src/openhuman/inference/provider/compatible_timeout.rs b/src/openhuman/inference/provider/compatible_timeout.rs
deleted file mode 100644
index 869a34a98..000000000
--- a/src/openhuman/inference/provider/compatible_timeout.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-//! Configurable HTTP timeouts for the OpenAI-compatible inference provider.
-//!
-//! The request and connect timeouts used when talking to inference endpoints
-//! were hardcoded (120s / 10s) in [`super::compatible_request`], which cut off
-//! long reasoning/research turns at the two-minute mark (#3856). They are now
-//! resolved from environment variables, with the previous values as defaults so
-//! behaviour is unchanged unless an operator overrides them:
-//!
-//! - `OPENHUMAN_INFERENCE_TIMEOUT_SECS` — whole-request timeout (default 120)
-//! - `OPENHUMAN_INFERENCE_CONNECT_TIMEOUT_SECS` — connection-establishment timeout (default 10)
-//! - `OPENHUMAN_INFERENCE_STREAM_IDLE_TIMEOUT_SECS` — per-chunk stream inactivity timeout (default 90, #4269)
-//!
-//! A missing, non-numeric, or out-of-range value falls back to the default
-//! (logged at debug level by [`resolve`]), so a typo can never disable the
-//! timeout or wedge a turn indefinitely.
-
-use std::sync::OnceLock;
-use std::time::Duration;
-
-/// Default whole-request timeout in seconds (preserves the prior hardcoded value).
-const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 120;
-/// Default connection-establishment timeout in seconds (preserves the prior value).
-const DEFAULT_CONNECT_TIMEOUT_SECS: u64 = 10;
-/// Smallest accepted timeout. `0` would disable the timeout entirely, so it is
-/// rejected and falls back to the default.
-const MIN_TIMEOUT_SECS: u64 = 1;
-/// Largest accepted request timeout (1 hour) — guards against typos that would
-/// let a hung request wedge a session indefinitely.
-const MAX_REQUEST_TIMEOUT_SECS: u64 = 3600;
-/// Largest accepted connect timeout (5 minutes) — establishing a connection
-/// should never legitimately take longer.
-const MAX_CONNECT_TIMEOUT_SECS: u64 = 300;
-/// Default per-chunk stream inactivity timeout in seconds (#4269). Sits
-/// comfortably above normal inter-token gaps — including reasoning-model
-/// thinking pauses, which still stream as `reasoning_content` deltas and so
-/// reset the window — yet below the 120s whole-request default, so a stalled
-/// RESPONSE phase is caught and retried rather than held to the request ceiling
-/// (up to 1 hour). The window RESETS on every received chunk, so a legitimately
-/// long answer that keeps emitting tokens is never cut.
-const DEFAULT_STREAM_IDLE_TIMEOUT_SECS: u64 = 90;
-/// Largest accepted stream-idle timeout (1 hour) — matches the request ceiling.
-const MAX_STREAM_IDLE_TIMEOUT_SECS: u64 = 3600;
-
-const REQUEST_ENV_VAR: &str = "OPENHUMAN_INFERENCE_TIMEOUT_SECS";
-const CONNECT_ENV_VAR: &str = "OPENHUMAN_INFERENCE_CONNECT_TIMEOUT_SECS";
-const STREAM_IDLE_ENV_VAR: &str = "OPENHUMAN_INFERENCE_STREAM_IDLE_TIMEOUT_SECS";
-
-/// Parse a raw env-var value into a bounded timeout in seconds.
-///
-/// Pure (no env / global access) so unit tests can exercise every branch
-/// without mutating the process environment or racing other tests. `None`,
-/// non-numeric, or values outside `min..=max` return `default`.
-fn parse_timeout_secs(raw: Option<&str>, default: u64, min: u64, max: u64) -> u64 {
- raw.and_then(|s| s.trim().parse::().ok())
- .filter(|n| (min..=max).contains(n))
- .unwrap_or(default)
-}
-
-/// Resolve an env-configured timeout. When the var is set, the resolved value
-/// is logged so an operator can tell whether an invalid override silently fell
-/// back to the default.
-fn resolve(env_var: &str, default: u64, max: u64) -> Duration {
- let raw = std::env::var(env_var).ok();
- let secs = parse_timeout_secs(raw.as_deref(), default, MIN_TIMEOUT_SECS, max);
- if let Some(value) = raw.as_deref() {
- tracing::debug!(
- "[inference] {env_var}={value:?} -> {secs}s (allowed {MIN_TIMEOUT_SECS}..={max}, default {default})"
- );
- }
- Duration::from_secs(secs)
-}
-
-/// Whole-request timeout for inference HTTP calls.
-/// Override via `OPENHUMAN_INFERENCE_TIMEOUT_SECS` (default 120s, range 1..=3600).
-///
-/// `http_client()` is rebuilt on every inference request (80+ call sites), so
-/// the value is resolved once per process and cached — env vars don't change at
-/// runtime, and this keeps the hot path off `std::env::var` and avoids logging
-/// the resolution on every request (mirrors `tool_timeout`'s cached value).
-pub(super) fn request_timeout() -> Duration {
- static CACHED: OnceLock = OnceLock::new();
- *CACHED.get_or_init(|| {
- resolve(
- REQUEST_ENV_VAR,
- DEFAULT_REQUEST_TIMEOUT_SECS,
- MAX_REQUEST_TIMEOUT_SECS,
- )
- })
-}
-
-/// Connection-establishment timeout for inference HTTP calls.
-/// Override via `OPENHUMAN_INFERENCE_CONNECT_TIMEOUT_SECS` (default 10s, range 1..=300).
-/// Resolved once per process and cached — see [`request_timeout`].
-pub(super) fn connect_timeout() -> Duration {
- static CACHED: OnceLock = OnceLock::new();
- *CACHED.get_or_init(|| {
- resolve(
- CONNECT_ENV_VAR,
- DEFAULT_CONNECT_TIMEOUT_SECS,
- MAX_CONNECT_TIMEOUT_SECS,
- )
- })
-}
-
-/// Per-chunk inactivity timeout for streaming inference responses (#4269).
-/// Override via `OPENHUMAN_INFERENCE_STREAM_IDLE_TIMEOUT_SECS` (default 90s,
-/// range 1..=3600). The streaming read loop and each downstream delta send are
-/// guarded by this window; it RESETS on every received chunk, so a legitimately
-/// long response that keeps emitting tokens is never cut — only a genuine stall
-/// (no bytes from upstream, or a wedged consumer) for the whole window trips it.
-/// Resolved once per process and cached — see [`request_timeout`].
-pub(super) fn stream_idle_timeout() -> Duration {
- static CACHED: OnceLock = OnceLock::new();
- *CACHED.get_or_init(|| {
- resolve(
- STREAM_IDLE_ENV_VAR,
- DEFAULT_STREAM_IDLE_TIMEOUT_SECS,
- MAX_STREAM_IDLE_TIMEOUT_SECS,
- )
- })
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn falls_back_to_default_when_absent_or_unparseable() {
- assert_eq!(parse_timeout_secs(None, 120, 1, 3600), 120);
- assert_eq!(parse_timeout_secs(Some(""), 120, 1, 3600), 120);
- assert_eq!(parse_timeout_secs(Some(" "), 120, 1, 3600), 120);
- assert_eq!(parse_timeout_secs(Some("abc"), 120, 1, 3600), 120);
- assert_eq!(parse_timeout_secs(Some("12.5"), 120, 1, 3600), 120);
- }
-
- #[test]
- fn rejects_out_of_range_values() {
- assert_eq!(parse_timeout_secs(Some("0"), 120, 1, 3600), 120); // below min disables timeout
- assert_eq!(parse_timeout_secs(Some("99999"), 120, 1, 3600), 120); // above max
- assert_eq!(parse_timeout_secs(Some("301"), 10, 1, 300), 10); // connect ceiling
- }
-
- #[test]
- fn accepts_in_range_values_and_boundaries() {
- assert_eq!(parse_timeout_secs(Some("600"), 120, 1, 3600), 600);
- assert_eq!(parse_timeout_secs(Some(" 45 "), 120, 1, 3600), 45); // surrounding whitespace
- assert_eq!(parse_timeout_secs(Some("1"), 120, 1, 3600), 1); // min boundary
- assert_eq!(parse_timeout_secs(Some("3600"), 120, 1, 3600), 3600); // max boundary
- }
-
- #[test]
- fn default_constants_match_the_prior_hardcoded_values() {
- // The getters must return the exact previous behaviour when nothing is
- // overridden, so an unconfigured install is byte-for-byte unchanged.
- assert_eq!(DEFAULT_REQUEST_TIMEOUT_SECS, 120);
- assert_eq!(DEFAULT_CONNECT_TIMEOUT_SECS, 10);
- }
-
- #[test]
- fn stream_idle_default_fires_before_the_whole_request_timeout() {
- // #4269: the watchdog must trip before the whole-request deadline so a
- // stalled RESPONSE phase is retried, not held to the request ceiling.
- assert_eq!(DEFAULT_STREAM_IDLE_TIMEOUT_SECS, 90);
- assert!(DEFAULT_STREAM_IDLE_TIMEOUT_SECS < DEFAULT_REQUEST_TIMEOUT_SECS);
- }
-
- #[test]
- fn stream_idle_parse_respects_bounds() {
- let (def, min, max) = (DEFAULT_STREAM_IDLE_TIMEOUT_SECS, MIN_TIMEOUT_SECS, 3600);
- assert_eq!(parse_timeout_secs(None, def, min, max), def);
- assert_eq!(parse_timeout_secs(Some("0"), def, min, max), def); // 0 would disable
- assert_eq!(parse_timeout_secs(Some("5"), def, min, max), 5);
- assert_eq!(parse_timeout_secs(Some("3600"), def, min, max), max); // ceiling
- assert_eq!(parse_timeout_secs(Some("3601"), def, min, max), def); // above ceiling
- }
-
- #[test]
- fn stream_idle_getter_returns_a_sane_duration() {
- // Unset (or set) in the env, the cached getter must resolve to a value
- // inside the documented bounds — never 0 (which would disable the guard).
- let d = stream_idle_timeout();
- assert!(d.as_secs() >= MIN_TIMEOUT_SECS && d.as_secs() <= MAX_STREAM_IDLE_TIMEOUT_SECS);
- }
-}
diff --git a/src/openhuman/inference/provider/compatible_types.rs b/src/openhuman/inference/provider/compatible_types.rs
deleted file mode 100644
index 189339c0b..000000000
--- a/src/openhuman/inference/provider/compatible_types.rs
+++ /dev/null
@@ -1,675 +0,0 @@
-//! Serde request/response structs for the OpenAI-compatible provider.
-//!
-//! All types in this module are crate-internal (`pub(crate)` or `pub(crate)`
-//! as appropriate). External code only sees the public API on
-//! [`super::OpenAiCompatibleProvider`].
-
-use serde::{Deserialize, Deserializer, Serialize};
-
-// ── Request bodies ────────────────────────────────────────────────────────────
-
-#[derive(Debug, Serialize)]
-pub(crate) struct ApiChatRequest {
- pub(crate) model: String,
- pub(crate) messages: Vec,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) temperature: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) stream: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) tools: Option>,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) tool_choice: Option,
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct Message {
- pub(crate) role: String,
- pub(crate) content: MessageContent,
-}
-
-/// OpenAI Chat Completions message `content` — a union of a plain string
-/// (text-only, the overwhelming majority of messages) and an array of typed
-/// parts when the message carries image attachments.
-///
-/// Serialises with `#[serde(untagged)]` so the wire shape matches the OpenAI
-/// contract exactly: a bare JSON string for text, or a
-/// `[{ "type": "text", … }, { "type": "image_url", … }]` array for multimodal
-/// messages. Text-only requests stay byte-identical to the legacy wire shape,
-/// so this change is transparent for every non-attachment turn.
-#[derive(Debug, Clone, Serialize)]
-#[serde(untagged)]
-pub(crate) enum MessageContent {
- Text(String),
- Parts(Vec),
-}
-
-/// One element of a multimodal `content` array.
-#[derive(Debug, Clone, Serialize)]
-#[serde(tag = "type")]
-pub(crate) enum ContentPart {
- #[serde(rename = "text")]
- Text { text: String },
- #[serde(rename = "image_url")]
- ImageUrl { image_url: ImageUrl },
-}
-
-/// OpenAI `image_url` payload. `url` accepts either a base64 `data:` URI (what
-/// the chat composer produces) or a remote `https://` link.
-#[derive(Debug, Clone, Serialize)]
-pub(crate) struct ImageUrl {
- pub(crate) url: String,
-}
-
-/// `[IMAGE:]` marker prefix. Mirrors
-/// [`crate::openhuman::agent::multimodal`] — the agent harness embeds image
-/// attachments as these markers inside the message text, and the provider
-/// layer promotes them back into structured `image_url` parts at the wire
-/// boundary. Kept local to avoid a provider→agent dependency cycle.
-const IMAGE_MARKER_PREFIX: &str = "[IMAGE:";
-
-impl MessageContent {
- /// Build message content from a raw chat-message string, promoting any
- /// embedded `[IMAGE:]` markers into structured `image_url`
- /// parts. Returns the plain-string [`MessageContent::Text`] arm when no
- /// markers are present, so text-only messages are unchanged on the wire.
- pub(crate) fn from_chat_text(content: &str) -> Self {
- // Fast path: markerless content stays the plain-string arm, byte-identical.
- if !content.contains(IMAGE_MARKER_PREFIX) {
- return MessageContent::Text(content.to_string());
- }
-
- // Scan left-to-right, emitting `text` and `image_url` parts in the exact
- // order they appear so interleaved prompts (`before [IMAGE:a] after`,
- // `[IMAGE:a] explain`) keep the multimodal sequence the user authored.
- let mut parts: Vec = Vec::new();
- let mut text_buf = String::new();
- let mut cursor = 0usize;
-
- while let Some(rel) = content[cursor..].find(IMAGE_MARKER_PREFIX) {
- let start = cursor + rel;
- text_buf.push_str(&content[cursor..start]);
-
- let marker_start = start + IMAGE_MARKER_PREFIX.len();
- let Some(rel_end) = content[marker_start..].find(']') else {
- // Unterminated marker — keep the remainder as literal text.
- text_buf.push_str(&content[start..]);
- cursor = content.len();
- break;
- };
-
- let end = marker_start + rel_end;
- let candidate = content[marker_start..end].trim();
- if candidate.is_empty() {
- // `[IMAGE:]` with no payload — keep the literal text, no part.
- text_buf.push_str(&content[start..=end]);
- } else {
- flush_text_part(&mut parts, &mut text_buf);
- parts.push(ContentPart::ImageUrl {
- image_url: ImageUrl {
- url: candidate.to_string(),
- },
- });
- }
- cursor = end + 1;
- }
- text_buf.push_str(&content[cursor..]);
- flush_text_part(&mut parts, &mut text_buf);
-
- // Only empty/invalid markers were present (no image parts) — fall back to
- // the plain-string arm rather than emitting a lone text part.
- if !parts
- .iter()
- .any(|p| matches!(p, ContentPart::ImageUrl { .. }))
- {
- return MessageContent::Text(content.to_string());
- }
- MessageContent::Parts(parts)
- }
-}
-
-/// Drain `buf` into a trimmed `ContentPart::Text` when it holds non-whitespace,
-/// then clear it. Whitespace-only spans between markers are dropped.
-fn flush_text_part(parts: &mut Vec, buf: &mut String) {
- let trimmed = buf.trim();
- if !trimmed.is_empty() {
- parts.push(ContentPart::Text {
- text: trimmed.to_string(),
- });
- }
- buf.clear();
-}
-
-impl From for MessageContent {
- fn from(value: String) -> Self {
- MessageContent::Text(value)
- }
-}
-
-impl From<&str> for MessageContent {
- fn from(value: &str) -> Self {
- MessageContent::Text(value.to_string())
- }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub(crate) struct NativeChatRequest {
- pub(crate) model: String,
- pub(crate) messages: Vec,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) temperature: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) stream: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) tools: Option>,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) tool_choice: Option,
- /// OpenHuman backend extension: stable conversation identifier so the
- /// server can group `InferenceLog` entries and align KV-cache keys
- /// with the same logical chat thread the user sees in the UI. Skipped
- /// when serialising for vanilla OpenAI-compatible providers that
- /// don't recognise it (most reject only unknown *required* fields,
- /// but emitting it here is gated on the ambient task-local being
- /// set — see `crate::openhuman::inference::provider::thread_context`).
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) thread_id: Option,
- /// OpenAI streaming `stream_options`. Set to `{"include_usage": true}`
- /// on streaming requests so the server emits a final usage chunk
- /// (carrying token counts and `openhuman.billing.charged_amount_usd`
- /// when the OpenHuman backend is in front). Without this, streaming
- /// responses arrive with `usage = None`, transcript headers lose the
- /// `- Charged: $…` line, and per-message cost annotations vanish for
- /// streamed sessions (typically the orchestrator).
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) stream_options: Option,
- /// Ollama-specific `options` block (e.g. `{"num_ctx": 32768}`).
- /// Injected by the factory when the provider profile declares a
- /// `num_ctx` override. Ignored (skipped) for non-Ollama providers.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) options: Option,
- /// OpenAI-compatible `frequency_penalty`. Set to a small positive value on
- /// real requests to damp degenerate repetition loops — without it a model
- /// that starts repeating a line keeps emitting it until the output-token
- /// cap (self-reinforcing decoding). Skipped when `None` so providers that
- /// don't accept it are unaffected.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) frequency_penalty: Option,
- /// OpenAI-compatible `max_tokens` — upper bound on output tokens.
- /// Set by callers whose output is bounded (memory extraction) so
- /// credit-metered providers don't price the request against the full
- /// model output window during their balance pre-flight (TAURI-RUST-C62).
- /// Skipped when `None` so open-ended generations are unaffected.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) max_tokens: Option,
-}
-
-/// Ollama-specific request options passed in the `options` field.
-#[derive(Debug, Clone, Serialize)]
-pub(crate) struct OllamaOptions {
- /// Context window size override. Ollama defaults to 2048 for many
- /// models; setting this ensures the model allocates enough KV-cache.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) num_ctx: Option,
-}
-
-/// OpenAI-spec `stream_options` payload (sent on the wire). Distinct from
-/// `crate::openhuman::inference::provider::traits::StreamOptions`, which is the
-/// caller-side knob set on `ChatRequest` to toggle agent streaming.
-#[derive(Debug, Clone, Serialize)]
-pub(crate) struct OpenAiStreamOptions {
- pub(crate) include_usage: bool,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub(crate) struct NativeMessage {
- pub(crate) role: String,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) content: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) tool_call_id: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) tool_calls: Option>,
- /// Chain-of-thought reasoning returned by thinking models (DeepSeek-R1,
- /// Qwen3, GLM-4, etc.) in the previous assistant turn. Per the API
- /// contract it **must** be echoed back verbatim in the next request's
- /// assistant message, or the provider returns HTTP 400.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) reasoning_content: Option,
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct ResponsesRequest {
- pub(crate) model: String,
- pub(crate) input: Vec,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) instructions: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) stream: Option,
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) store: Option,
- /// Responses-API output-token cap (`max_output_tokens`). Carries the
- /// caller's `ChatRequest::max_tokens` through the Responses path so a
- /// capped request isn't silently uncapped when `responses_api_primary`
- /// is enabled (TAURI-RUST-C62). Skipped when `None`.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) max_output_tokens: Option,
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct ResponsesInput {
- pub(crate) role: String,
- pub(crate) content: Vec,
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct ResponsesContentPart {
- #[serde(rename = "type")]
- pub(crate) kind: String,
- pub(crate) text: String,
-}
-
-// ── Response bodies ───────────────────────────────────────────────────────────
-
-#[derive(Debug, Deserialize)]
-pub(crate) struct ApiChatResponse {
- pub(crate) choices: Vec,
- /// Standard OpenAI usage block.
- #[serde(default)]
- pub(crate) usage: Option,
- /// OpenHuman backend metadata (usage + billing summary).
- #[serde(default)]
- pub(crate) openhuman: Option,
-}
-
-#[derive(Debug, Deserialize)]
-pub(crate) struct Choice {
- pub(crate) message: ResponseMessage,
-}
-
-/// Standard OpenAI `usage` block on a chat completion response.
-#[derive(Debug, Deserialize, Default)]
-pub(crate) struct ApiUsage {
- #[serde(default)]
- pub(crate) prompt_tokens: u64,
- #[serde(default)]
- pub(crate) completion_tokens: u64,
- #[serde(default)]
- pub(crate) total_tokens: u64,
- #[serde(default)]
- pub(crate) prompt_tokens_details: Option,
-}
-
-#[derive(Debug, Deserialize, Default)]
-pub(crate) struct PromptTokensDetails {
- #[serde(default)]
- pub(crate) cached_tokens: u64,
-}
-
-/// OpenHuman backend metadata appended to the response JSON.
-#[derive(Debug, Deserialize, Default)]
-pub(crate) struct OpenHumanMeta {
- #[serde(default)]
- pub(crate) usage: Option,
- #[serde(default)]
- pub(crate) billing: Option,
-}
-
-#[derive(Debug, Deserialize, Default)]
-pub(crate) struct OpenHumanUsage {
- pub(crate) input_tokens: Option,
- pub(crate) output_tokens: Option,
- #[allow(dead_code)]
- pub(crate) total_tokens: Option,
- pub(crate) cached_input_tokens: Option,
-}
-
-#[derive(Debug, Deserialize, Default)]
-pub(crate) struct OpenHumanBilling {
- #[serde(default)]
- pub(crate) charged_amount_usd: f64,
-}
-
-#[derive(Debug, Serialize)]
-pub(crate) struct ResponseMessage {
- pub(crate) content: Option,
- /// Reasoning/thinking models may return their chain-of-thought in a
- /// dedicated field instead of (or alongside) `content`. DeepSeek, Qwen3 and
- /// GLM-4 name it `reasoning_content`; OpenRouter and vLLM/SGLang-backed
- /// OpenAI-compatible proxies emit it as `reasoning`. Both names fold into
- /// this single field (see the manual `Deserialize` impl below) — the CoT
- /// must be echoed back verbatim on tool-call turns or thinking models reject
- /// the follow-up request with HTTP 400.
- pub(crate) reasoning_content: Option,
- pub(crate) tool_calls: Option>,
- pub(crate) function_call: Option,
-}
-
-// Manual `Deserialize` so that `reasoning` and `reasoning_content` are accepted
-// as DISTINCT wire keys and then folded into the single canonical field.
-//
-// A serde `alias` maps both names onto one field slot, which makes a provider
-// that emits BOTH keys in the same object (some OpenRouter / vLLM-SGLang
-// proxies do) fail with `duplicate field \`reasoning_content\``, dropping the
-// entire response. A derived `Shadow` struct fixes the distinct-name collision
-// but still strict-rejects a key REPEATED in the same object — NVIDIA's compat
-// endpoint returns `reasoning_content` twice for some thinking models
-// (e.g. `stepfun-ai/step-3.7-flash`), which dropped the whole completion
-// (TAURI-RUST-85R: 2,037 events). So fold over the map by hand: each known key
-// overwrites (last non-null wins), duplicates are tolerated, and the canonical
-// `reasoning_content` still wins over the `reasoning` alias.
-impl<'de> Deserialize<'de> for ResponseMessage {
- fn deserialize(deserializer: D) -> Result
- where
- D: Deserializer<'de>,
- {
- use serde::de::{IgnoredAny, MapAccess, Visitor};
-
- struct ResponseMessageVisitor;
-
- impl<'de> Visitor<'de> for ResponseMessageVisitor {
- type Value = ResponseMessage;
-
- fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
- f.write_str("an OpenAI-compatible chat completion message object")
- }
-
- fn visit_map(self, mut map: A) -> Result
- where
- A: MapAccess<'de>,
- {
- let mut content: Option = None;
- let mut reasoning_content: Option = None;
- let mut reasoning: Option = None;
- let mut tool_calls: Option> = None;
- let mut function_call: Option = None;
-
- // A repeated key overwrites rather than erroring (last non-null
- // wins) — a `null` second copy must not clobber a real value.
- while let Some(key) = map.next_key::()? {
- match key.as_str() {
- "content" => {
- if let Some(v) = map.next_value::>()? {
- content = Some(v);
- }
- }
- "reasoning_content" => {
- if let Some(v) = map.next_value::>()? {
- reasoning_content = Some(v);
- }
- }
- "reasoning" => {
- if let Some(v) = map.next_value::>()? {
- reasoning = Some(v);
- }
- }
- "tool_calls" => {
- if let Some(v) = map.next_value::>>()? {
- tool_calls = Some(v);
- }
- }
- "function_call" => {
- if let Some(v) = map.next_value::>()? {
- function_call = Some(v);
- }
- }
- _ => {
- map.next_value::()?;
- }
- }
- }
-
- Ok(ResponseMessage {
- content,
- reasoning_content: reasoning_content.or(reasoning),
- tool_calls,
- function_call,
- })
- }
- }
-
- deserializer.deserialize_map(ResponseMessageVisitor)
- }
-}
-
-impl ResponseMessage {
- /// Extract text content, falling back to `reasoning_content` when `content`
- /// is missing or empty. Reasoning/thinking models (Qwen3, GLM-4, etc.)
- /// often return their output solely in `reasoning_content`.
- /// Strips `...` blocks that some models (e.g. MiniMax) embed
- /// inline in `content` instead of using a separate field.
- pub(crate) fn effective_content(&self) -> String {
- if let Some(content) = self.content.as_ref().filter(|c| !c.is_empty()) {
- let stripped = super::compatible_parse::strip_think_tags(content);
- if !stripped.is_empty() {
- return stripped;
- }
- }
-
- self.reasoning_content
- .as_ref()
- .map(|c| super::compatible_parse::strip_think_tags(c))
- .filter(|c| !c.is_empty())
- .unwrap_or_default()
- }
-
- pub(crate) fn effective_content_optional(&self) -> Option {
- if let Some(content) = self.content.as_ref().filter(|c| !c.is_empty()) {
- let stripped = super::compatible_parse::strip_think_tags(content);
- if !stripped.is_empty() {
- return Some(stripped);
- }
- }
-
- self.reasoning_content
- .as_ref()
- .map(|c| super::compatible_parse::strip_think_tags(c))
- .filter(|c| !c.is_empty())
- }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub(crate) struct ToolCall {
- #[serde(skip_serializing_if = "Option::is_none")]
- pub(crate) id: Option,
- #[serde(rename = "type")]
- pub(crate) kind: Option,
- pub(crate) function: Option,
- /// Provider-specific passthrough metadata attached to a tool call.
- ///
- /// Google's Gemini OpenAI-compat endpoint returns a cryptographically
- /// signed reasoning token here as
- /// `extra_content.google.thought_signature`, and **requires** it echoed
- /// back verbatim on the assistant tool-call turn of every subsequent
- /// request — otherwise it 400s with "Function call is missing a
- /// thought_signature" (TAURI-RUST-4PK). Captured on the response and
- /// re-emitted on the request as an opaque value so any future
- /// `extra_content.*` keys round-trip unchanged. `skip_serializing_if`
- /// keeps the wire body byte-identical for every provider that doesn't
- /// send it.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub(crate) extra_content: Option,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub(crate) struct Function {
- pub(crate) name: Option,
- pub(crate) arguments: Option,
-}
-
-#[derive(Debug, Deserialize)]
-pub(crate) struct ResponsesResponse {
- #[serde(default)]
- pub(crate) output: Vec,
- #[serde(default)]
- pub(crate) output_text: Option