@mmmbuto/masix 0.4.0 → 0.4.1

package/packages/plugin-base/codex-backend/source/src/http_backend.rs

@@ -0,0 +1,1198 @@
+use crate::policy::AdminPolicy;
+use crate::{
+    CodingBackend, CodingError, CodingEvent, CodingMode, CodingResult, CodingTask, DryRunInfo,
+    ExitStatus, ProviderType, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_MAX_TOKENS, DEFAULT_TIMEOUT_SECS,
+    MAX_LOG_ENTRIES,
+};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant};
+use tracing::debug;
+
+const OPENAI_DEFAULT_URL: &str = "https://api.openai.com";
+const ANTHROPIC_DEFAULT_URL: &str = "https://api.anthropic.com";
+const TRUNCATION_MARKER: &str = "\n...[TRUNCATED]";
+
+#[derive(Debug, Clone)]
+pub struct HttpBackendConfig {
+    pub provider_type: ProviderType,
+    pub api_key: String,
+    pub base_url: Option<String>,
+    pub model: Option<String>,
+    pub max_tokens: u32,
+    pub timeout: Duration,
+    pub max_output_bytes: usize,
+    pub max_log_bytes: usize,
+    pub legacy_fallback: bool,
+}
+
+impl Default for HttpBackendConfig {
+    fn default() -> Self {
+        Self {
+            provider_type: ProviderType::OpenAI,
+            api_key: String::new(),
+            base_url: None,
+            model: None,
+            max_tokens: DEFAULT_MAX_TOKENS,
+            timeout: Duration::from_secs(DEFAULT_TIMEOUT_SECS),
+            max_output_bytes: DEFAULT_MAX_OUTPUT_BYTES,
+            max_log_bytes: 64 * 1024,
+            legacy_fallback: false,
+        }
+    }
+}
+
+pub struct HttpBackend {
+    client: reqwest::Client,
+    config: HttpBackendConfig,
+}
+
+impl HttpBackend {
+    pub fn new(config: HttpBackendConfig) -> Result<Self, CodingError> {
+        if config.api_key.is_empty() {
+            return Err(CodingError::MissingApiKey);
+        }
+        let client = reqwest::Client::builder()
+            .timeout(config.timeout)
+            .build()
+            .map_err(|e| CodingError::IoError(e.to_string()))?;
+        Ok(Self { client, config })
+    }
+
+    pub fn new_openai(
+        api_key: String,
+        base_url: Option<String>,
+        model: Option<String>,
+    ) -> Result<Self, CodingError> {
+        Self::new(HttpBackendConfig {
+            provider_type: ProviderType::OpenAI,
+            api_key,
+            base_url,
+            model,
+            ..Default::default()
+        })
+    }
+
+    pub fn new_anthropic(
+        api_key: String,
+        base_url: Option<String>,
+        model: Option<String>,
+    ) -> Result<Self, CodingError> {
+        Self::new(HttpBackendConfig {
+            provider_type: ProviderType::Anthropic,
+            api_key,
+            base_url,
+            model: model.or_else(|| Some("claude-3-5-sonnet-latest".to_string())),
+            ..Default::default()
+        })
+    }
+
+    fn normalize_base_url(&self) -> String {
+        let base = match (&self.config.base_url, &self.config.provider_type) {
+            (Some(url), _) => url.as_str(),
+            (None, ProviderType::OpenAI) | (None, ProviderType::OpenAICompatible) => {
+                OPENAI_DEFAULT_URL
+            }
+            (None, ProviderType::Anthropic) => ANTHROPIC_DEFAULT_URL,
+        };
+        base.trim_end_matches('/')
+            .trim_end_matches("/v1")
+            .to_string()
+    }
+
+    fn get_model(&self) -> &str {
+        match (&self.config.model, &self.config.provider_type) {
+            (Some(m), _) => m,
+            (None, ProviderType::OpenAI) => "gpt-4.1",
+            (None, ProviderType::Anthropic) => "claude-3-5-sonnet-latest",
+            (None, ProviderType::OpenAICompatible) => "default",
+        }
+    }
+
+    fn build_system_prompt(&self, task: &CodingTask) -> String {
+        match task.mode {
+            CodingMode::ReadOnly => format!(
+                "You are a coding assistant analyzing the repository at {}.\nAvailable tools: read_file, list_dir.\n\nRequest: {}",
+                task.repo_path.display(), task.instructions
+            ),
+            CodingMode::WorkspaceWrite => format!(
+                "You are a coding assistant with write access to the repository at {}.\nAvailable tools: read_file, write_file, list_dir.\n\nRequest: {}",
+                task.repo_path.display(), task.instructions
+            ),
+        }
+    }
+
+    fn safe_path(&self, relative: &str, repo_root: &Path) -> Result<PathBuf, CodingError> {
+        let normalized = relative.replace('\\', "/");
+        if normalized.starts_with('/') || normalized.starts_with('~') {
+            return Err(CodingError::PathSecurityViolation(
+                "Absolute/home paths not allowed".into(),
+            ));
+        }
+        for component in normalized.split('/') {
+            if component == ".." {
+                return Err(CodingError::PathSecurityViolation(
+                    "Path traversal not allowed".into(),
+                ));
+            }
+        }
+        let resolved = repo_root.join(&normalized);
+        let canonical_root = repo_root
+            .canonicalize()
+            .map_err(|e| CodingError::IoError(format!("Cannot canonicalize repo root: {}", e)))?;
+        let mut check_path = resolved.clone();
+        while !check_path.exists() {
+            if !check_path.pop() {
+                break;
+            }
+        }
+        let canonical_check = check_path
+            .canonicalize()
+            .unwrap_or_else(|_| check_path.clone());
+        if !canonical_check.starts_with(&canonical_root) {
+            return Err(CodingError::PathSecurityViolation(
+                "Path escapes repository root".into(),
+            ));
+        }
+        if resolved.exists() {
+            if let Ok(metadata) = std::fs::symlink_metadata(&resolved) {
+                if metadata.file_type().is_symlink() {
+                    let canonical_resolved = resolved.canonicalize().map_err(|_| {
+                        CodingError::PathSecurityViolation("Cannot resolve symlink".into())
+                    })?;
+                    if !canonical_resolved.starts_with(&canonical_root) {
+                        return Err(CodingError::PathSecurityViolation(
+                            "Symlink escapes repository root".into(),
+                        ));
+                    }
+                }
+            }
+        }
+        Ok(resolved)
+    }
+
+    fn truncate_output(&self, output: &str) -> String {
+        let bytes = output.as_bytes();
+        if bytes.len() <= self.config.max_output_bytes {
+            output.to_string()
+        } else {
+            let truncated = String::from_utf8_lossy(&bytes[..self.config.max_output_bytes]);
+            format!("{}{}", truncated, TRUNCATION_MARKER)
+        }
+    }
+
+    fn truncate_log_entry(&self, entry: &str) -> String {
+        if entry.len() <= self.config.max_log_bytes {
+            entry.to_string()
+        } else {
+            format!(
+                "{}{}",
+                &entry[..self.config.max_log_bytes],
+                TRUNCATION_MARKER
+            )
+        }
+    }
+
+    fn get_openai_endpoints(&self) -> Vec<(&'static str, String)> {
+        let base = self.normalize_base_url();
+        if self.config.legacy_fallback {
+            vec![
+                ("responses", format!("{}/v1/responses", base)),
+                ("chat", format!("{}/v1/chat/completions", base)),
+                ("chat_legacy", format!("{}/chat/completions", base)),
+                ("chat_minimal", format!("{}/chat", base)),
+            ]
+        } else {
+            vec![("chat", format!("{}/v1/chat/completions", base))]
+        }
+    }
+
+    fn get_anthropic_endpoints(&self) -> Vec<(&'static str, String)> {
+        let base = self.normalize_base_url();
+        if self.config.legacy_fallback {
+            vec![
+                ("messages", format!("{}/v1/messages", base)),
+                ("messages_legacy", format!("{}/messages", base)),
+            ]
+        } else {
+            vec![("messages", format!("{}/v1/messages", base))]
+        }
+    }
+
+    fn is_terminal_error(status: u16, body: &str) -> bool {
+        matches!(status, 401 | 403) || (status == 400 && body.contains("invalid_api_key"))
+    }
+
+    fn is_retriable_status(status: u16) -> bool {
+        matches!(status, 408 | 429 | 500 | 502 | 503 | 504)
+    }
+
+    async fn call_openai_chat(
+        &self,
+        messages: Vec<serde_json::Value>,
+        tools: Vec<serde_json::Value>,
+        remaining_timeout: Duration,
+    ) -> Result<ChatResponse, CodingError> {
+        let endpoints = self.get_openai_endpoints();
+        let mut last_error = None;
+        for (endpoint_type, url) in endpoints {
+            debug!("Trying OpenAI endpoint: {} ({})", url, endpoint_type);
+            let body = match endpoint_type {
+                "responses" => self.build_responses_body(&messages, &tools),
+                _ => self.build_chat_body(&messages, &tools),
+            };
+            let result = tokio::time::timeout(
+                remaining_timeout,
+                self.client
+                    .post(&url)
+                    .header("Authorization", format!("Bearer {}", self.config.api_key))
+                    .header("Content-Type", "application/json")
+                    .json(&body)
+                    .send(),
+            )
+            .await;
+            match result {
+                Ok(Ok(response)) => {
+                    let status = response.status();
+                    let body_text = response
+                        .text()
+                        .await
+                        .map_err(|e| CodingError::HttpError(e.to_string()))?;
+                    if status.is_success() {
+                        return self.parse_endpoint_response(endpoint_type, &body_text);
+                    }
+                    if Self::is_terminal_error(status.as_u16(), &body_text) {
+                        return Err(CodingError::ApiError(format!(
+                            "Auth error HTTP {}: {}",
+                            status,
+                            &body_text.chars().take(200).collect::<String>()
+                        )));
+                    }
+                    let is_404_or_schema = status == 404
+                        || body_text.contains("not_found")
+                        || body_text.contains("invalid_request");
+                    if !Self::is_retriable_status(status.as_u16()) && !is_404_or_schema {
+                        return Err(CodingError::ApiError(format!(
+                            "HTTP {}: {}",
+                            status,
+                            &body_text.chars().take(200).collect::<String>()
+                        )));
+                    }
+                    last_error = Some(format!(
+                        "HTTP {}: {}",
+                        status,
+                        &body_text.chars().take(100).collect::<String>()
+                    ));
+                }
+                Ok(Err(e)) => {
+                    last_error = Some(format!("Network error: {}", e));
+                }
+                Err(_) => {
+                    last_error = Some("Timeout".to_string());
+                }
+            }
+        }
+        Err(CodingError::ApiError(
+            last_error.unwrap_or_else(|| "All endpoints failed".to_string()),
+        ))
+    }
+
+    fn build_chat_body(
+        &self,
+        messages: &[serde_json::Value],
+        tools: &[serde_json::Value],
+    ) -> serde_json::Value {
+        let mut body = serde_json::json!({ "model": self.get_model(), "messages": messages, "max_tokens": self.config.max_tokens });
+        if !tools.is_empty() {
+            body["tools"] = serde_json::json!(tools);
+            body["tool_choice"] = serde_json::json!("auto");
+        }
+        body
+    }
+
+    fn build_responses_body(
+        &self,
+        messages: &[serde_json::Value],
+        tools: &[serde_json::Value],
+    ) -> serde_json::Value {
+        let user_content = messages
+            .iter()
+            .filter_map(|m| m.get("content").and_then(|c| c.as_str()))
+            .last()
+            .unwrap_or("");
+        let mut body = serde_json::json!({ "model": self.get_model(), "input": user_content });
+        if !tools.is_empty() {
+            body["tools"] = serde_json::json!(tools);
+        }
+        body
+    }
+
+    fn parse_endpoint_response(
+        &self,
+        endpoint_type: &str,
+        body: &str,
+    ) -> Result<ChatResponse, CodingError> {
+        let json: serde_json::Value =
+            serde_json::from_str(body).map_err(|e| CodingError::InvalidResponse(e.to_string()))?;
+        match endpoint_type {
+            "responses" => parse_responses_response(&json),
+            _ => parse_openai_response(&json),
+        }
+    }
+
+    async fn call_anthropic_chat(
+        &self,
+        messages: Vec<serde_json::Value>,
+        tools: Vec<serde_json::Value>,
+        remaining_timeout: Duration,
+    ) -> Result<ChatResponse, CodingError> {
+        let endpoints = self.get_anthropic_endpoints();
+        let mut last_error = None;
+        let system = messages
+            .iter()
+            .find(|m| m["role"] == "system")
+            .and_then(|m| m["content"].as_str())
+            .unwrap_or("");
+        let other_messages: Vec<_> = messages
+            .iter()
+            .filter(|m| m["role"] != "system")
+            .cloned()
+            .collect();
+        for (_, url) in endpoints {
+            debug!("Trying Anthropic endpoint: {}", url);
+            let mut body = serde_json::json!({ "model": self.get_model(), "max_tokens": self.config.max_tokens, "messages": other_messages.clone() });
+            if !system.is_empty() {
+                body["system"] = serde_json::json!(system);
+            }
+            if !tools.is_empty() {
+                body["tools"] = serde_json::json!(crate::tools::tools_to_anthropic_format(&tools));
+            }
+            let result = tokio::time::timeout(
+                remaining_timeout,
+                self.client
+                    .post(&url)
+                    .header("x-api-key", &self.config.api_key)
+                    .header("anthropic-version", "2023-06-01")
+                    .header("Content-Type", "application/json")
+                    .json(&body)
+                    .send(),
+            )
+            .await;
+            match result {
+                Ok(Ok(response)) => {
+                    let status = response.status();
+                    let body_text = response
+                        .text()
+                        .await
+                        .map_err(|e| CodingError::HttpError(e.to_string()))?;
+                    if status.is_success() {
+                        return parse_anthropic_response(
+                            &serde_json::from_str(&body_text)
+                                .map_err(|e| CodingError::InvalidResponse(e.to_string()))?,
+                        );
+                    }
+                    if Self::is_terminal_error(status.as_u16(), &body_text) {
+                        return Err(CodingError::ApiError(format!(
+                            "Auth error HTTP {}: {}",
+                            status,
+                            &body_text.chars().take(200).collect::<String>()
+                        )));
+                    }
+                    last_error = Some(format!(
+                        "HTTP {}: {}",
+                        status,
+                        &body_text.chars().take(100).collect::<String>()
+                    ));
+                }
+                Ok(Err(e)) => {
+                    last_error = Some(format!("Network error: {}", e));
+                }
+                Err(_) => {
+                    last_error = Some("Timeout".to_string());
+                }
+            }
+        }
+        Err(CodingError::ApiError(
+            last_error.unwrap_or_else(|| "All endpoints failed".to_string()),
+        ))
+    }
+
+    async fn execute_tool(
+        &self,
+        name: &str,
+        args: &str,
+        task: &CodingTask,
+    ) -> Result<String, CodingError> {
+        match name {
+            "read_file" => {
+                let args: ReadFileArgs = serde_json::from_str(args)
+                    .map_err(|e| CodingError::ToolError(format!("Invalid args: {}", e)))?;
+                let path = self.safe_path(&args.path, &task.repo_path)?;
+                let content = std::fs::read_to_string(&path).map_err(|e| {
+                    CodingError::IoError(format!("Failed to read {}: {}", path.display(), e))
+                })?;
+                Ok(self.truncate_output(&content))
+            }
+            "list_dir" => {
+                let args: ListDirArgs = serde_json::from_str(args)
+                    .map_err(|e| CodingError::ToolError(format!("Invalid args: {}", e)))?;
+                let path = self.safe_path(&args.path, &task.repo_path)?;
+                let entries = std::fs::read_dir(&path).map_err(|e| {
+                    CodingError::IoError(format!("Failed to list {}: {}", path.display(), e))
+                })?;
+                Ok(entries
+                    .filter_map(|e| e.ok())
+                    .map(|e| e.file_name().to_string_lossy().to_string())
+                    .collect::<Vec<_>>()
+                    .join("\n"))
+            }
+            "write_file" if matches!(task.mode, CodingMode::WorkspaceWrite) => {
+                let args: WriteFileArgs = serde_json::from_str(args)
+                    .map_err(|e| CodingError::ToolError(format!("Invalid args: {}", e)))?;
+                let path = self.safe_path(&args.path, &task.repo_path)?;
+                if let Some(parent) = path.parent() {
+                    std::fs::create_dir_all(parent).map_err(|e| {
+                        CodingError::IoError(format!("Failed to create dir: {}", e))
+                    })?;
+                }
+                std::fs::write(&path, &args.content).map_err(|e| {
+                    CodingError::IoError(format!("Failed to write {}: {}", path.display(), e))
+                })?;
+                Ok(format!("Written to {}", path.display()))
+            }
+            _ => Err(CodingError::ToolError(format!("Unknown tool: {}", name))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ReadFileArgs {
+    path: String,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ListDirArgs {
+    path: String,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct WriteFileArgs {
+    path: String,
+    content: String,
+}
+
+#[derive(Debug, Clone)]
+struct ChatResponse {
+    content: Option<String>,
+    tool_calls: Vec<ToolCall>,
+}
+#[derive(Debug, Clone)]
+struct ToolCall {
+    id: String,
+    name: String,
+    arguments: String,
+}
+
+fn parse_openai_response(json: &serde_json::Value) -> Result<ChatResponse, CodingError> {
+    let choice = json
+        .get("choices")
+        .and_then(|c| c.as_array())
+        .and_then(|c| c.first())
+        .ok_or_else(|| CodingError::InvalidResponse("No choices".into()))?;
+    let message = choice
+        .get("message")
+        .ok_or_else(|| CodingError::InvalidResponse("No message".into()))?;
+    let content = message
+        .get("content")
+        .and_then(|c| c.as_str())
+        .map(|s| s.to_string());
+    let tool_calls = message
+        .get("tool_calls")
+        .and_then(|tc| tc.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|tc| {
+                    let id = tc.get("id")?.as_str()?.to_string();
+                    let func = tc.get("function")?;
+                    Some(ToolCall {
+                        id,
+                        name: func.get("name")?.as_str()?.to_string(),
+                        arguments: func.get("arguments")?.as_str()?.to_string(),
+                    })
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    Ok(ChatResponse {
+        content,
+        tool_calls,
+    })
+}
+
+fn parse_responses_response(json: &serde_json::Value) -> Result<ChatResponse, CodingError> {
+    let content = json
+        .get("output")
+        .and_then(|o| o.as_str())
+        .map(|s| s.to_string())
+        .or_else(|| {
+            json.get("content")
+                .and_then(|c| c.as_array())
+                .and_then(|arr| arr.first())
+                .and_then(|b| b.get("text"))
+                .and_then(|t| t.as_str())
+                .map(|s| s.to_string())
+        });
+    let tool_calls = json
+        .get("tool_calls")
+        .and_then(|tc| tc.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|tc| {
+                    Some(ToolCall {
+                        id: tc.get("id")?.as_str()?.to_string(),
+                        name: tc.get("name")?.as_str()?.to_string(),
+                        arguments: tc
+                            .get("arguments")
+                            .and_then(|a| a.as_str())
+                            .unwrap_or("{}")
+                            .to_string(),
+                    })
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    Ok(ChatResponse {
+        content,
+        tool_calls,
+    })
+}
+
+fn parse_anthropic_response(json: &serde_json::Value) -> Result<ChatResponse, CodingError> {
+    let content_blocks = json
+        .get("content")
+        .and_then(|c| c.as_array())
+        .ok_or_else(|| CodingError::InvalidResponse("No content".into()))?;
+    let mut content = None;
+    let mut tool_calls = Vec::new();
+    for block in content_blocks {
+        match block.get("type").and_then(|t| t.as_str()).unwrap_or("") {
+            "text" => {
+                content = block
+                    .get("text")
+                    .and_then(|t| t.as_str())
+                    .map(|s| s.to_string());
+            }
+            "tool_use" => {
+                tool_calls.push(ToolCall {
+                    id: block
+                        .get("id")
+                        .and_then(|i| i.as_str())
+                        .unwrap_or("")
+                        .to_string(),
+                    name: block
+                        .get("name")
+                        .and_then(|n| n.as_str())
+                        .unwrap_or("")
+                        .to_string(),
+                    arguments: serde_json::to_string(
+                        &block.get("input").cloned().unwrap_or(serde_json::json!({})),
+                    )
+                    .unwrap_or_default(),
+                });
+            }
+            _ => {}
+        }
+    }
+    Ok(ChatResponse {
+        content,
+        tool_calls,
+    })
+}
+
+fn build_anthropic_assistant_message(tool_calls: &[ToolCall]) -> serde_json::Value {
+    let content: Vec<_> = tool_calls.iter().map(|tc| {
+        serde_json::json!({ "type": "tool_use", "id": tc.id, "name": tc.name, "input": serde_json::from_str::<serde_json::Value>(&tc.arguments).unwrap_or(serde_json::json!({})) })
+    }).collect();
+    serde_json::json!({ "role": "assistant", "content": content })
+}
+
+fn build_openai_assistant_message(tool_calls: &[ToolCall]) -> serde_json::Value {
+    serde_json::json!({
+        "role": "assistant",
+        "tool_calls": tool_calls.iter().map(|tc| {
+            serde_json::json!({ "id": tc.id, "type": "function", "function": { "name": tc.name, "arguments": tc.arguments } })
+        }).collect::<Vec<_>>()
+    })
+}
+
+fn build_openai_tool_result(tc: &ToolCall, result: &str) -> serde_json::Value {
+    serde_json::json!({ "role": "tool", "tool_call_id": tc.id, "content": result })
+}
+
+#[async_trait]
+impl CodingBackend for HttpBackend {
+    async fn run(&self, task: CodingTask) -> Result<CodingResult, CodingError> {
+        // Check admin policy before execution
+        self.check_policy(&task)?;
+
+        let start_time = Instant::now();
+        let task_timeout = task.timeout.unwrap_or(self.config.timeout);
+        let tools = match task.mode {
+            CodingMode::ReadOnly => crate::tools::get_read_tools(),
+            CodingMode::WorkspaceWrite => crate::tools::get_write_tools(),
+        };
+        let mut messages: Vec<serde_json::Value> = vec![
+            serde_json::json!({ "role": "system", "content": self.build_system_prompt(&task) }),
+            serde_json::json!({ "role": "user", "content": task.instructions }),
+        ];
+        let mut logs = Vec::new();
+        let mut events = Vec::new();
+        let max_iterations = task.max_steps.unwrap_or(50);
+        let mut iterations = 0u32;
+
+        // Record start event
+        events.push(CodingEvent::start(&task.repo_path));
+
+        loop {
+            let elapsed = start_time.elapsed();
+            if elapsed >= task_timeout {
+                let summary = format!("Timeout after {:?}", task_timeout);
+                events.push(CodingEvent::final_event("timeout", &summary));
+                return Ok(CodingResult {
+                    patch: None,
+                    summary,
+                    logs,
+                    exit_status: ExitStatus::Timeout,
+                    events,
+                });
+            }
+            if iterations >= max_iterations {
+                let summary = "Max iterations exceeded".to_string();
+                events.push(CodingEvent::final_event("max_iterations", &summary));
+                return Ok(CodingResult {
+                    patch: None,
+                    summary,
+                    logs,
+                    exit_status: ExitStatus::MaxIterations,
+                    events,
+                });
+            }
+            if logs.len() >= MAX_LOG_ENTRIES {
+                logs.push(format!("{}[MAX_LOG_ENTRIES]", TRUNCATION_MARKER));
+                let summary = "Log limit exceeded".to_string();
+                events.push(CodingEvent::final_event("log_limit", &summary));
+                return Ok(CodingResult {
+                    patch: None,
+                    summary,
+                    logs,
+                    exit_status: ExitStatus::Error("Log limit".into()),
+                    events,
+                });
+            }
+
+            // Record iteration event
+            iterations += 1;
+            events.push(CodingEvent::iteration(iterations));
+
+            let remaining = task_timeout - elapsed;
+            let response = match self.config.provider_type {
+                ProviderType::OpenAI | ProviderType::OpenAICompatible => {
+                    self.call_openai_chat(messages.clone(), tools.clone(), remaining)
+                        .await?
+                }
+                ProviderType::Anthropic => {
+                    self.call_anthropic_chat(messages.clone(), tools.clone(), remaining)
+                        .await?
+                }
+            };
+
+            if response.tool_calls.is_empty() {
+                let summary = response
+                    .content
+                    .clone()
+                    .unwrap_or_else(|| "Task completed".into());
+                events.push(CodingEvent::final_event("success", &summary));
+                return Ok(CodingResult {
+                    patch: None,
+                    summary,
+                    logs,
+                    exit_status: ExitStatus::Success,
+                    events,
+                });
+            }
+
+            // Process ALL tool calls in this batch (collect results first)
+            let mut tool_results: Vec<(&ToolCall, String, bool)> = Vec::new();
+            for tc in &response.tool_calls {
+                events.push(CodingEvent::tool_call(&tc.id, &tc.name, &tc.arguments));
+
+                let result = self.execute_tool(&tc.name, &tc.arguments, &task).await;
+                let (result_text, success) = match result {
+                    Ok(r) => (r, true),
+                    Err(e) => (format!("Error: {}", e), false),
+                };
+                let truncated = self.truncate_log_entry(&result_text);
+                logs.push(format!("[{}] {}", tc.name, truncated));
+
+                events.push(CodingEvent::tool_result(
+                    &tc.id, &tc.name, success, &truncated,
+                ));
+                tool_results.push((tc, truncated, success));
+            }
+
+            // Push messages per provider protocol
+            match self.config.provider_type {
+                ProviderType::Anthropic => {
+                    messages.push(build_anthropic_assistant_message(&response.tool_calls));
+                    // Anthropic protocol: ALL tool_results in SINGLE user message
+                    let blocks: Vec<_> = tool_results
+                        .iter()
+                        .map(|(tc, result, _)| {
+                            serde_json::json!({
+                                "type": "tool_result",
+                                "tool_use_id": tc.id,
+                                "content": result
+                            })
+                        })
+                        .collect();
+                    messages.push(serde_json::json!({"role": "user", "content": blocks}));
+                }
+                ProviderType::OpenAI | ProviderType::OpenAICompatible => {
+                    messages.push(build_openai_assistant_message(&response.tool_calls));
+                    for (tc, result, _) in &tool_results {
+                        messages.push(build_openai_tool_result(tc, result));
+                    }
+                }
+            }
+        }
+    }
+
+    fn dry_run(&self, task: &CodingTask) -> DryRunInfo {
+        let policy_allowed = task
+            .policy
+            .as_ref()
+            .map(|p| p.permission_level.is_admin())
+            .unwrap_or(false);
+        DryRunInfo {
+            backend: "http",
+            provider_type: self.config.provider_type.as_str(),
+            base_url: Some(self.normalize_base_url()),
+            model: Some(self.get_model().to_string()),
+            timeout_secs: self.config.timeout.as_secs(),
+            mode: match task.mode {
+                CodingMode::ReadOnly => "read-only",
+                CodingMode::WorkspaceWrite => "workspace-write",
+            },
+            repo_path: task.repo_path.clone(),
+            policy_allowed,
+            requires_admin: true,
+        }
+    }
+
+    fn check_policy(&self, task: &CodingTask) -> Result<(), CodingError> {
+        let policy = AdminPolicy::new();
+        policy.check(task.policy.as_ref())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::policy::PolicyContext;
+    use mockito::Server;
+    use serde_json::json;
+
+    fn test_backend() -> HttpBackend {
+        HttpBackend::new(HttpBackendConfig {
+            api_key: "test".into(),
+            ..Default::default()
+        })
+        .unwrap()
+    }
+
+    #[test]
+    fn test_safe_path_rejects_traversal() {
+        let b = test_backend();
+        let root = std::env::temp_dir();
+        assert!(b.safe_path("../etc/passwd", &root).is_err());
+        assert!(b.safe_path("foo/../../etc", &root).is_err());
+        assert!(b.safe_path("~/secret", &root).is_err());
+        assert!(b.safe_path("/etc/passwd", &root).is_err());
+    }
+
+    #[test]
+    fn test_safe_path_accepts_valid() {
+        let b = test_backend();
+        let root = std::env::temp_dir();
+        assert!(b.safe_path("src/lib.rs", &root).is_ok());
+        assert!(b.safe_path("foo/bar/baz.txt", &root).is_ok());
+    }
+
+    #[test]
+    fn test_truncate_output() {
+        let b = HttpBackend::new(HttpBackendConfig {
+            api_key: "test".into(),
+            max_output_bytes: 10,
+            ..Default::default()
+        })
+        .unwrap();
+        let t = b.truncate_output("This is a very long string");
+        assert!(t.ends_with(TRUNCATION_MARKER));
+    }
+
+    #[test]
+    fn test_normalize_base_url() {
+        let b = HttpBackend::new(HttpBackendConfig {
+            api_key: "test".into(),
+            base_url: Some("https://api.example.com/v1".into()),
+            ..Default::default()
+        })
+        .unwrap();
+        assert_eq!(b.normalize_base_url(), "https://api.example.com");
+    }
+
+    #[test]
+    fn test_truncate_log_entry() {
+        let b = HttpBackend::new(HttpBackendConfig {
+            api_key: "test".into(),
+            max_log_bytes: 5,
+            ..Default::default()
+        })
+        .unwrap();
+        let t = b.truncate_log_entry("hello world");
+        assert!(t.ends_with(TRUNCATION_MARKER));
+    }
+
+    #[tokio::test]
+    async fn test_run_denies_without_admin_policy_context() {
+        let backend = test_backend();
+        let task = CodingTask {
+            repo_path: std::env::temp_dir(),
+            instructions: "noop".to_string(),
+            mode: CodingMode::ReadOnly,
+            timeout: Some(Duration::from_secs(2)),
+            max_steps: Some(1),
+            policy: None,
+        };
+
+        let result = backend.run(task).await;
+        match result {
+            Err(CodingError::PolicyError(msg)) => {
+                assert!(msg.contains("Policy context required"));
+            }
+            other => panic!("Expected PolicyError, got {:?}", other),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_openai_fallback_from_responses_to_chat() {
+        let mut server = Server::new_async().await;
+
+        let m1 = server
+            .mock("POST", "/v1/responses")
+            .with_status(404)
+            .with_body(r#"{"error":"not_found"}"#)
+            .create_async()
+            .await;
+
+        let m2 = server
+            .mock("POST", "/v1/chat/completions")
+            .with_status(200)
+            .with_body(r#"{"choices":[{"message":{"content":"ok-from-chat"}}]}"#)
+            .create_async()
+            .await;
+
+        let backend = HttpBackend::new(HttpBackendConfig {
+            provider_type: ProviderType::OpenAI,
+            api_key: "test-key".into(),
+            base_url: Some(server.url()),
+            legacy_fallback: true,
+            timeout: Duration::from_secs(2),
+            ..Default::default()
+        })
+        .unwrap();
+
+        let response = backend
+            .call_openai_chat(
+                vec![json!({"role":"user","content":"hello"})],
+                vec![],
+                Duration::from_secs(2),
+            )
+            .await
+            .expect("openai fallback should succeed");
+
+        assert_eq!(response.content.as_deref(), Some("ok-from-chat"));
+        m1.assert_async().await;
+        m2.assert_async().await;
+    }
+
+    #[tokio::test]
+    async fn test_anthropic_fallback_from_v1_messages_to_messages() {
+        let mut server = Server::new_async().await;
+
+        let m1 = server
+            .mock("POST", "/v1/messages")
+            .with_status(404)
+            .with_body(r#"{"error":"not_found"}"#)
+            .create_async()
+            .await;
+
+        let m2 = server
+            .mock("POST", "/messages")
+            .with_status(200)
+            .with_body(r#"{"content":[{"type":"text","text":"ok-from-messages"}]}"#)
+            .create_async()
+            .await;
+
+        let backend = HttpBackend::new(HttpBackendConfig {
+            provider_type: ProviderType::Anthropic,
+            api_key: "test-key".into(),
+            base_url: Some(server.url()),
+            legacy_fallback: true,
+            timeout: Duration::from_secs(2),
+            ..Default::default()
+        })
+        .unwrap();
+
+        let response = backend
+            .call_anthropic_chat(
+                vec![
+                    json!({"role":"system","content":"sys"}),
+                    json!({"role":"user","content":"hello"}),
+                ],
+                vec![],
+                Duration::from_secs(2),
+            )
+            .await
+            .expect("anthropic fallback should succeed");
+
+        assert_eq!(response.content.as_deref(), Some("ok-from-messages"));
+        m1.assert_async().await;
+        m2.assert_async().await;
+    }
+
+    #[test]
+    fn test_dry_run_policy_allowed_for_admin() {
+        let backend = test_backend();
+        let task = CodingTask {
+            repo_path: std::env::temp_dir(),
+            instructions: "noop".to_string(),
+            mode: CodingMode::ReadOnly,
+            timeout: None,
+            max_steps: None,
+            policy: Some(PolicyContext::admin()),
+        };
+
+        let info = backend.dry_run(&task);
+        assert!(info.policy_allowed);
+        assert!(info.requires_admin);
+    }
+
+    #[tokio::test]
+    async fn test_openai_multi_tool_batch() {
+        let mut server = Server::new_async().await;
+
+        // First call: returns 2 tool_calls
+        let m1 = server
+            .mock("POST", "/v1/chat/completions")
+            .with_status(200)
+            .with_body(r#"{"choices":[{"message":{"content":null,"tool_calls":[
+                {"id":"tc1","type":"function","function":{"name":"read_file","arguments":"{\"path\":\"a.txt\"}"}},
+                {"id":"tc2","type":"function","function":{"name":"read_file","arguments":"{\"path\":\"b.txt\"}"}}
+            ]}}]}"#)
+            .expect(1)
+            .create_async()
+            .await;
+
+        // Second call: final text response
+        let m2 = server
+            .mock("POST", "/v1/chat/completions")
+            .with_status(200)
+            .with_body(r#"{"choices":[{"message":{"content":"done"}}]}"#)
+            .expect(1)
+            .create_async()
+            .await;
+
+        // Create temp workspace with test files
+        let tmp = std::env::temp_dir().join("masix_batch_test_oai");
+        let _ = std::fs::create_dir_all(&tmp);
+        std::fs::write(tmp.join("a.txt"), "file-a-content").unwrap();
+        std::fs::write(tmp.join("b.txt"), "file-b-content").unwrap();
+
+        let backend = HttpBackend::new(HttpBackendConfig {
+            provider_type: ProviderType::OpenAI,
+            api_key: "test-key".into(),
+            base_url: Some(server.url()),
+            legacy_fallback: false,
+            timeout: Duration::from_secs(5),
+            ..Default::default()
+        })
+        .unwrap();
+
+        let task = CodingTask {
+            repo_path: tmp.clone(),
+            instructions: "read both files".into(),
+            mode: CodingMode::ReadOnly,
+            timeout: Some(Duration::from_secs(5)),
+            max_steps: Some(5),
+            policy: Some(PolicyContext::admin()),
+        };
+
+        let result = backend.run(task).await.expect("should succeed");
+
+        // Verify both tool calls were executed (2 tool_call + 2 tool_result events)
+        let tool_call_events: Vec<_> = result
+            .events
+            .iter()
+            .filter(|e| e.event == "tool_call")
+            .collect();
+        let tool_result_events: Vec<_> = result
+            .events
+            .iter()
+            .filter(|e| e.event == "tool_result")
+            .collect();
+        assert_eq!(tool_call_events.len(), 2, "Expected 2 tool_call events");
+        assert_eq!(tool_result_events.len(), 2, "Expected 2 tool_result events");
+
+        // Verify logs contain both tool executions
+        assert_eq!(
+            result.logs.len(),
+            2,
+            "Expected 2 log entries, got {:?}",
+            result.logs
+        );
+
+        m1.assert_async().await;
+        m2.assert_async().await;
+
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+
+    #[tokio::test]
+    async fn test_anthropic_multi_tool_batch() {
+        let mut server = Server::new_async().await;
+
+        // First call: returns 2 tool_use blocks
+        let m1 = server
+            .mock("POST", "/v1/messages")
+            .with_status(200)
+            .with_body(
+                r#"{"content":[
+                {"type":"tool_use","id":"tu1","name":"read_file","input":{"path":"a.txt"}},
+                {"type":"tool_use","id":"tu2","name":"read_file","input":{"path":"b.txt"}}
+            ]}"#,
+            )
+            .expect(1)
+            .create_async()
+            .await;
+
+        // Second call: final text response
+        let m2 = server
+            .mock("POST", "/v1/messages")
+            .with_status(200)
+            .with_body(r#"{"content":[{"type":"text","text":"done"}]}"#)
+            .expect(1)
+            .create_async()
+            .await;
+
+        let tmp = std::env::temp_dir().join("masix_batch_test_ant");
+        let _ = std::fs::create_dir_all(&tmp);
+        std::fs::write(tmp.join("a.txt"), "file-a-content").unwrap();
+        std::fs::write(tmp.join("b.txt"), "file-b-content").unwrap();
+
+        let backend = HttpBackend::new(HttpBackendConfig {
+            provider_type: ProviderType::Anthropic,
+            api_key: "test-key".into(),
+            base_url: Some(server.url()),
+            legacy_fallback: false,
+            timeout: Duration::from_secs(5),
+            ..Default::default()
+        })
+        .unwrap();
+
+        let task = CodingTask {
+            repo_path: tmp.clone(),
+            instructions: "read both files".into(),
+            mode: CodingMode::ReadOnly,
+            timeout: Some(Duration::from_secs(5)),
+            max_steps: Some(5),
+            policy: Some(PolicyContext::admin()),
+        };
+
+        let result = backend.run(task).await.expect("should succeed");
+
+        // Verify both tool calls were executed
+        let tool_call_events: Vec<_> = result
+            .events
+            .iter()
+            .filter(|e| e.event == "tool_call")
+            .collect();
+        let tool_result_events: Vec<_> = result
+            .events
+            .iter()
+            .filter(|e| e.event == "tool_result")
+            .collect();
+        assert_eq!(tool_call_events.len(), 2, "Expected 2 tool_call events");
+        assert_eq!(tool_result_events.len(), 2, "Expected 2 tool_result events");
+
+        m1.assert_async().await;
+        m2.assert_async().await;
+
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+
+    #[tokio::test]
+    async fn test_single_tool_regression() {
+        let mut server = Server::new_async().await;
+
+        // Single tool call - regression test after batch fix
+        let m1 = server
+            .mock("POST", "/v1/chat/completions")
+            .with_status(200)
+            .with_body(r#"{"choices":[{"message":{"content":null,"tool_calls":[
+                {"id":"tc1","type":"function","function":{"name":"read_file","arguments":"{\"path\":\"test.txt\"}"}}
+            ]}}]}"#)
+            .expect(1)
+            .create_async()
+            .await;
+
+        let m2 = server
+            .mock("POST", "/v1/chat/completions")
+            .with_status(200)
+            .with_body(r#"{"choices":[{"message":{"content":"single tool ok"}}]}"#)
+            .expect(1)
+            .create_async()
+            .await;
+
+        let tmp = std::env::temp_dir().join("masix_single_tool_test");
+        let _ = std::fs::create_dir_all(&tmp);
+        std::fs::write(tmp.join("test.txt"), "hello").unwrap();
+
+        let backend = HttpBackend::new(HttpBackendConfig {
+            provider_type: ProviderType::OpenAI,
+            api_key: "test-key".into(),
+            base_url: Some(server.url()),
+            legacy_fallback: false,
+            timeout: Duration::from_secs(5),
+            ..Default::default()
+        })
+        .unwrap();
+
+        let task = CodingTask {
+            repo_path: tmp.clone(),
+            instructions: "read file".into(),
+            mode: CodingMode::ReadOnly,
+            timeout: Some(Duration::from_secs(5)),
+            max_steps: Some(5),
+            policy: Some(PolicyContext::admin()),
+        };
+
+        let result = backend.run(task).await.expect("should succeed");
+        assert_eq!(result.summary, "single tool ok");
+        assert_eq!(result.logs.len(), 1);
+
+        m1.assert_async().await;
+        m2.assert_async().await;
+
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}