refactor(llm)!: introduce wire format adapters replacing HF endpoints

- Remove `forward_to_hf_endpoint.rs` and deprecate HF endpoint style
- Add pluggable LLM wire adapters (OpenAI Chat, OpenAI Responses, Anthropic)
- Introduce canonical `LlmRequest`/`LlmResponse`/`LlmStreamDelta` types
- Add `WireFormat` enum to model capabilities with provider defaults
- Migrate chat preparation/generation to new adapter system
- Add new conversation modes: ask, plan, review, debug, learn, shell, past_work, quick_agent
- Improve streaming parsing, logging, and error handling
- Enhance tool call safety with pending call verification
- Add `CacheControl`, `ResponseFormat` support and usage token parsing
- Add xAI Responses provider config

BREAKING CHANGE: HuggingFace endpoint style removed - use OpenAI-compatible endpoints instead

Author: JegernOUTT

refact-agent/engine/src/call_validation.rs

@@ -174,7 +174,11 @@ impl Default for ChatContent {
 pub struct ChatUsage {
     pub prompt_tokens: usize,
     pub completion_tokens: usize,
-    pub total_tokens: usize, // TODO: remove (can produce self-contradictory data when prompt+completion != total)
+    pub total_tokens: usize,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cache_creation_tokens: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cache_read_tokens: Option<usize>,
 }
 
 #[derive(Debug, Serialize, Clone, Default)]

refact-agent/engine/src/caps/caps.rs

@@ -46,6 +46,8 @@ pub struct BaseModelRecord {
     #[serde(default, skip_serializing)]
     pub support_metadata: bool,
     #[serde(default, skip_serializing)]
+    pub extra_headers: std::collections::HashMap<String, String>,
+    #[serde(default, skip_serializing)]
     pub similar_models: Vec<String>,
     #[serde(default)]
     pub tokenizer: String,
@@ -54,6 +56,11 @@ pub struct BaseModelRecord {
     pub enabled: bool,
     #[serde(default)]
     pub experimental: bool,
+
+    /// Use max_completion_tokens instead of max_tokens (required for OpenAI o1/o3 models)
+    #[serde(default)]
+    pub supports_max_completion_tokens: bool,
+
     // Fields used for Config/UI management
     #[serde(skip_deserializing)]
     pub removable: bool,

refact-agent/engine/src/caps/providers.rs

@@ -45,6 +45,9 @@ pub struct CapsProvider {
     #[serde(default)]
     pub tokenizer_api_key: String,
 
+    #[serde(default)]
+    pub extra_headers: std::collections::HashMap<String, String>,
+
     #[serde(default)]
     pub code_completion_n_ctx: usize,
 
@@ -263,6 +266,10 @@ const PROVIDER_TEMPLATES: &[(&str, &str)] = &[
         "openai",
         include_str!("../yaml_configs/default_providers/openai.yaml"),
     ),
+    (
+        "openai_responses",
+        include_str!("../yaml_configs/default_providers/openai_responses.yaml"),
+    ),
     (
         "openrouter",
         include_str!("../yaml_configs/default_providers/openrouter.yaml"),
@@ -271,6 +278,10 @@ const PROVIDER_TEMPLATES: &[(&str, &str)] = &[
         "xai",
         include_str!("../yaml_configs/default_providers/xai.yaml"),
     ),
+    (
+        "xai_responses",
+        include_str!("../yaml_configs/default_providers/xai_responses.yaml"),
+    ),
 ];
 static PARSED_PROVIDERS: OnceLock<IndexMap<String, CapsProvider>> = OnceLock::new();
 static PARSED_MODEL_DEFAULTS: OnceLock<IndexMap<String, ModelDefaultSettingsUI>> = OnceLock::new();
@@ -513,6 +524,7 @@ pub fn add_models_to_caps(caps: &mut CodeAssistantCaps, providers: Vec<CapsProvi
         base_model_rec.support_metadata = provider.support_metadata;
         base_model_rec.endpoint_style = provider.endpoint_style.clone();
         base_model_rec.wire_format = provider.wire_format;
+        base_model_rec.extra_headers = provider.extra_headers.clone();
     }
 
     for mut provider in providers {

refact-agent/engine/src/caps/self_hosted.rs

@@ -11,11 +11,15 @@ use crate::caps::{
     default_rejection_threshold, relative_to_full_url, normalize_string, resolve_relative_urls,
 };
 use crate::caps::providers;
+use crate::llm::WireFormat;
 
 #[derive(Debug, Deserialize, Clone, Default)]
 pub struct SelfHostedCapsModelRecord {
     pub n_ctx: usize,
 
+    #[serde(default)]
+    pub wire_format: WireFormat,
+
     #[serde(default)]
     pub supports_scratchpads: HashMap<String, serde_json::Value>,
 
@@ -218,22 +222,16 @@ impl SelfHostedCapsModelRecord {
         let mut base = BaseModelRecord {
             n_ctx: self.n_ctx,
             enabled: true,
+            wire_format: self.wire_format,
             ..Default::default()
         };
 
         let (scratchpad, scratchpad_patch) = self.get_chat_scratchpad();
 
-        // Non passthrough models, don't support endpoints of `/v1/chat/completions` in openai style, only `/v1/completions`
-        let endpoint_to_use = if scratchpad == "PASSTHROUGH" {
-            &self_hosted_caps.chat.endpoint
-        } else {
-            &self_hosted_caps.completion.endpoint
-        };
-
         configure_base_model(
             &mut base,
             model_name,
-            endpoint_to_use,
+            &self_hosted_caps.chat.endpoint,
             &self_hosted_caps.cloud_name,
             &self_hosted_caps.tokenizer_endpoints,
             caps_url,
@@ -385,6 +383,7 @@ impl SelfHostedCaps {
             embedding_endpoint: self.embedding.endpoint.clone(),
             api_key: cmdline_api_key.to_string(),
             tokenizer_api_key: cmdline_api_key.to_string(),
+            extra_headers: std::collections::HashMap::new(),
             code_completion_n_ctx: 0,
             support_metadata: self.support_metadata,
             completion_models: IndexMap::new(),

refact-agent/engine/src/chat/openai_merge.rs

@@ -68,7 +68,11 @@ pub fn merge_tool_call(accumulated: &mut Vec<serde_json::Value>, new_tc: serde_j
 
             if let Some(args) = func.get("arguments") {
                 if !args.is_null() {
-                    let new_args = args.as_str().unwrap_or("");
+                    let new_args = if let Some(s) = args.as_str() {
+                        s.to_string()
+                    } else {
+                        serde_json::to_string(args).unwrap_or_default()
+                    };
                     let prev_args = existing["function"]["arguments"].as_str().unwrap_or("");
                     existing["function"]["arguments"] = json!(format!("{}{}", prev_args, new_args));
                 }
@@ -264,7 +268,7 @@ mod tests {
     }
 
     #[test]
-    fn test_merge_tool_calls_arguments_object_treated_as_empty() {
+    fn test_merge_tool_calls_arguments_object_stringified() {
         let mut accumulated = Vec::new();
         merge_tool_call(
             &mut accumulated,
@@ -275,11 +279,11 @@ mod tests {
             }),
         );
 
-        assert_eq!(accumulated[0]["function"]["arguments"], "");
+        assert_eq!(accumulated[0]["function"]["arguments"], r#"{"key":"value"}"#);
     }
 
     #[test]
-    fn test_merge_tool_calls_arguments_number_treated_as_empty() {
+    fn test_merge_tool_calls_arguments_number_stringified() {
         let mut accumulated = Vec::new();
         merge_tool_call(
             &mut accumulated,
@@ -290,7 +294,7 @@ mod tests {
             }),
         );
 
-        assert_eq!(accumulated[0]["function"]["arguments"], "");
+        assert_eq!(accumulated[0]["function"]["arguments"], "123");
     }
 
     #[test]

refact-agent/engine/src/chat/prepare.rs

@@ -236,6 +236,8 @@ pub async fn prepare_chat_passthrough(
         tool_choice,
         parallel_tool_calls: options.parallel_tool_calls.unwrap_or(false),
         stream: true,
+        response_format: None,
+        cache_control: Default::default(),
         extra_body: None,
     };
 

refact-agent/engine/src/chat/queue.rs

@@ -611,15 +611,16 @@ fn is_allowed_role_for_restore(role: &str) -> bool {
     matches!(role, "user" | "assistant" | "system" | "tool")
 }
 
-/// Sanitize message for branching - preserves conversation structure (tool_calls, tool results)
-/// but strips transient metadata (usage, checkpoints, citations, etc.)
+/// Sanitize message for branching - preserves conversation structure but strips:
+/// - tool_calls from assistant messages (security: prevents prerun of injected tool calls)
+/// - transient metadata (usage, checkpoints, citations, etc.)
 fn sanitize_message_for_restore(msg: &ChatMessage) -> ChatMessage {
     ChatMessage {
         message_id: Uuid::new_v4().to_string(),
         role: msg.role.clone(),
         content: msg.content.clone(),
-        tool_calls: msg.tool_calls.clone(),  // Preserve tool calls for conversation context
-        tool_call_id: msg.tool_call_id.clone(),  // Preserve for tool messages
+        tool_calls: None,  // Security: strip tool_calls to prevent prerun of restored messages
+        tool_call_id: msg.tool_call_id.clone(),  // Preserve for tool result messages
         tool_failed: msg.tool_failed,  // Preserve tool execution status
         usage: None,  // Strip metering data
         checkpoints: vec![],  // Strip checkpoint data

refact-agent/engine/src/chat/stream_core.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Instant;
@@ -55,6 +54,10 @@ pub async fn run_llm_stream<C: StreamCollector>(
     params: StreamRunParams,
     collector: &mut C,
 ) -> Result<Vec<ChoiceFinal>, String> {
+    if params.llm_request.params.n.unwrap_or(1) != 1 {
+        return Err("Streaming with n > 1 is not supported".to_string());
+    }
+
     let (client, slowdown_arc) = {
         let gcx_locked = gcx.read().await;
         (
@@ -72,10 +75,11 @@ pub async fn run_llm_stream<C: StreamCollector>(
     let adapter_settings = AdapterSettings {
         api_key: params.model_rec.api_key.clone(),
         endpoint: params.model_rec.endpoint.clone(),
-        extra_headers: HashMap::new(),
+        extra_headers: params.model_rec.extra_headers.clone(),
         model_name: params.model_rec.name.clone(),
         supports_tools: params.supports_tools,
         supports_reasoning: params.supports_reasoning,
+        supports_max_completion_tokens: params.model_rec.supports_max_completion_tokens,
     };
 
     // Build HTTP request using adapter

refact-agent/engine/src/llm/adapter.rs

@@ -42,6 +42,7 @@ pub struct AdapterSettings {
     pub model_name: String,
     pub supports_tools: bool,
     pub supports_reasoning: bool,
+    pub supports_max_completion_tokens: bool,
 }
 
 pub trait LlmWireAdapter: Send + Sync {