Add files using upload-large-folder tool

crates/forge_app/src/dto/anthropic/error.rs

@@ -0,0 +1,8 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone, PartialEq, thiserror::Error)]
+#[serde(rename_all = "snake_case", tag = "type")]
+pub enum Error {
+    #[error("Overload error: {message}")]
+    OverloadedError { message: String },
+}

crates/forge_app/src/dto/anthropic/mod.rs

@@ -0,0 +1,9 @@
+mod error;
+mod request;
+mod response;
+mod transforms;
+
+pub use error::*;
+pub use request::*;
+pub use response::*;
+pub use transforms::*;

crates/forge_app/src/dto/anthropic/request.rs

@@ -0,0 +1,872 @@
+use derive_setters::Setters;
+use forge_domain::{ContextMessage, Image};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Default, Setters)]
+#[setters(into, strip_option)]
+pub struct Request {
+    pub max_tokens: u64,
+    pub messages: Vec<Message>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<Metadata>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop_sequence: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stream: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system: Option<Vec<SystemMessage>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_choice: Option<ToolChoice>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub tools: Vec<ToolDefinition>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_k: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<Thinking>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_config: Option<OutputConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_format: Option<OutputFormat>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub anthropic_version: Option<String>,
+}
+
+#[derive(Serialize, Default)]
+pub struct SystemMessage {
+    pub r#type: String,
+    pub text: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cache_control: Option<CacheControl>,
+}
+
+impl SystemMessage {
+    pub fn cached(mut self, cached: bool) -> Self {
+        self.cache_control = if cached {
+            Some(CacheControl::Ephemeral)
+        } else {
+            None
+        };
+        self
+    }
+
+    pub fn is_cached(&self) -> bool {
+        self.cache_control.is_some()
+    }
+}
+
+/// Anthropic's `thinking` request field. Opus 4.7 rejects the `Enabled` shape
+/// and the orchestrator applies model-specific reasoning normalization before
+/// request conversion.
+#[derive(Serialize, Debug, PartialEq, Eq)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum Thinking {
+    Enabled {
+        budget_tokens: u64,
+    },
+    Adaptive {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        display: Option<ThinkingDisplay>,
+    },
+    Disabled,
+}
+
+/// On Opus 4.7 adaptive thinking content is omitted from responses unless
+/// `Summarized` is requested explicitly.
+#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ThinkingDisplay {
+    Summarized,
+    Omitted,
+}
+
+#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum OutputEffort {
+    Low,
+    Medium,
+    High,
+    XHigh,
+    Max,
+}
+
+#[derive(Serialize, Debug, PartialEq, Eq)]
+pub struct OutputConfig {
+    pub effort: OutputEffort,
+}
+
+#[derive(Serialize, Debug, PartialEq)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum OutputFormat {
+    #[serde(rename = "json_schema")]
+    JsonSchema { schema: schemars::Schema },
+}
+
+impl TryFrom<forge_domain::Context> for Request {
+    type Error = anyhow::Error;
+    fn try_from(request: forge_domain::Context) -> std::result::Result<Self, Self::Error> {
+        let system_messages = request
+            .messages
+            .iter()
+            .filter_map(|msg| match &**msg {
+                ContextMessage::Text(msg) if msg.has_role(forge_domain::Role::System) => {
+                    Some(SystemMessage {
+                        r#type: "text".to_string(),
+                        text: msg.content.clone(),
+                        cache_control: None,
+                    })
+                }
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        // Gate on the domain rule so inherited configs with `enabled: None` but
+        // a positive effort / `max_tokens` still emit reasoning on the wire.
+        let reasoning_on = request.is_reasoning_supported();
+        let (thinking, output_config) = if reasoning_on && let Some(reasoning) = request.reasoning {
+            // Adaptive thinking on 4.7 hides reasoning content by default; opting
+            // into reasoning should surface it unless the caller set `exclude`.
+            let adaptive_display = if reasoning.exclude == Some(true) {
+                Some(ThinkingDisplay::Omitted)
+            } else {
+                Some(ThinkingDisplay::Summarized)
+            };
+
+            let thinking = if let Some(budget) = reasoning.max_tokens {
+                Thinking::Enabled { budget_tokens: budget as u64 }
+            } else {
+                Thinking::Adaptive { display: adaptive_display }
+            };
+
+            // `Effort::None` is an explicit opt-out; `is_reasoning_supported`
+            // already filters it, but guard here so it can never become a stray
+            // `output_config.effort`.
+            let output_config = reasoning.effort.and_then(|effort| {
+                let output_effort = match effort {
+                    forge_domain::Effort::None => return None,
+                    forge_domain::Effort::Minimal | forge_domain::Effort::Low => OutputEffort::Low,
+                    forge_domain::Effort::Medium => OutputEffort::Medium,
+                    forge_domain::Effort::High => OutputEffort::High,
+                    forge_domain::Effort::XHigh => OutputEffort::XHigh,
+                    forge_domain::Effort::Max => OutputEffort::Max,
+                };
+                Some(OutputConfig { effort: output_effort })
+            });
+
+            (Some(thinking), output_config)
+        } else {
+            (None, None)
+        };
+
+        Ok(Self {
+            messages: request
+                .messages
+                .into_iter()
+                .filter(|message| !message.has_role(forge_domain::Role::System))
+                .map(|msg| Message::try_from(msg.message))
+                .collect::<std::result::Result<Vec<_>, _>>()?,
+            tools: request
+                .tools
+                .into_iter()
+                .map(ToolDefinition::try_from)
+                .collect::<std::result::Result<Vec<_>, _>>()?,
+            system: Some(system_messages),
+            temperature: request.temperature.map(|t| t.value()),
+            top_p: request.top_p.map(|t| t.value()),
+            top_k: request.top_k.map(|t| t.value() as u64),
+            tool_choice: request.tool_choice.map(ToolChoice::from),
+            stream: Some(request.stream.unwrap_or(true)),
+            thinking,
+            output_config,
+            output_format: request.response_format.and_then(|rf| match rf {
+                forge_domain::ResponseFormat::Text => {
+                    // Anthropic doesn't have a "text" output format, so we skip it
+                    None
+                }
+                forge_domain::ResponseFormat::JsonSchema(schema) => {
+                    Some(OutputFormat::JsonSchema { schema: *schema })
+                }
+            }),
+            ..Default::default()
+        })
+    }
+}
+
+impl Request {
+    /// Get a reference to the messages
+    pub fn get_messages(&self) -> &[Message] {
+        &self.messages
+    }
+
+    /// Get a mutable reference to the messages
+    pub fn get_messages_mut(&mut self) -> &mut Vec<Message> {
+        &mut self.messages
+    }
+}
+
+#[derive(Serialize)]
+pub struct Metadata {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<String>,
+}
+
+#[derive(Serialize)]
+pub struct Message {
+    pub content: Vec<Content>,
+    pub role: Role,
+}
+
+impl TryFrom<ContextMessage> for Message {
+    type Error = anyhow::Error;
+    fn try_from(value: ContextMessage) -> std::result::Result<Self, Self::Error> {
+        Ok(match value {
+            ContextMessage::Text(chat_message) => {
+                let mut content = Vec::with_capacity(
+                    chat_message
+                        .tool_calls
+                        .as_ref()
+                        .map(|tc| tc.len())
+                        .unwrap_or_default()
+                        + 1,
+                );
+
+                if let Some(reasoning) = chat_message.reasoning_details
+                    && let Some((sig, text)) = reasoning.into_iter().find_map(|reasoning| {
+                        match (reasoning.signature, reasoning.text) {
+                            (Some(sig), Some(text)) => Some((sig, text)),
+                            _ => None,
+                        }
+                    })
+                {
+                    content.push(Content::Thinking { signature: Some(sig), thinking: Some(text) });
+                }
+
+                if !chat_message.content.is_empty() {
+                    // NOTE: Anthropic does not allow empty text content.
+                    content.push(Content::Text { text: chat_message.content, cache_control: None });
+                }
+                if let Some(tool_calls) = chat_message.tool_calls {
+                    for tool_call in tool_calls {
+                        content.push(tool_call.try_into()?);
+                    }
+                }
+
+                match chat_message.role {
+                    forge_domain::Role::User => Message { role: Role::User, content },
+                    forge_domain::Role::Assistant => Message { role: Role::Assistant, content },
+                    forge_domain::Role::System => {
+                        // note: Anthropic doesn't support system role messages and they're already
+                        // filtered out. so this state is unreachable.
+                        return Err(
+                            forge_domain::Error::UnsupportedRole("System".to_string()).into()
+                        );
+                    }
+                }
+            }
+            ContextMessage::Tool(tool_result) => {
+                Message { role: Role::User, content: vec![tool_result.try_into()?] }
+            }
+            ContextMessage::Image(img) => {
+                Message { content: vec![Content::from(img)], role: Role::User }
+            }
+        })
+    }
+}
+
+impl Message {
+    pub fn cached(mut self, enable_cache: bool) -> Self {
+        // Reset cache control on all content items first
+        for content in &mut self.content {
+            *content = std::mem::take(content).cached(false);
+        }
+
+        // If enabling cache, set cache control on the last cacheable content item
+        if enable_cache
+            && let Some(last_cacheable_idx) =
+                self.content
+                    .iter()
+                    .enumerate()
+                    .rev()
+                    .find_map(|(idx, content)| match content {
+                        Content::Text { .. }
+                        | Content::Image { .. }
+                        | Content::ToolUse { .. }
+                        | Content::ToolResult { .. } => Some(idx),
+                        _ => None,
+                    })
+            && let Some(content) = self.content.get_mut(last_cacheable_idx)
+        {
+            *content = std::mem::take(content).cached(true);
+        }
+
+        self
+    }
+
+    pub fn is_cached(&self) -> bool {
+        self.content.iter().any(|content| content.is_cached())
+    }
+}
+
+impl Default for Message {
+    fn default() -> Self {
+        Message { content: vec![], role: Role::User }
+    }
+}
+
+impl From<Image> for Content {
+    fn from(value: Image) -> Self {
+        Content::Image {
+            source: ImageSource {
+                type_: "base64".to_string(),
+                media_type: Some(value.mime_type().to_string()),
+                data: Some(value.data().into()),
+                url: None,
+            },
+            cache_control: None,
+        }
+    }
+}
+
+#[derive(Serialize)]
+pub struct ImageSource {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub media_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case", tag = "type")]
+pub enum Content {
+    Image {
+        source: ImageSource,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+    Text {
+        text: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+    ToolUse {
+        id: String,
+        input: Option<serde_json::Value>,
+        name: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+    ToolResult {
+        tool_use_id: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        content: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        is_error: Option<bool>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+    Thinking {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        signature: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        thinking: Option<String>,
+    },
+}
+
+impl Default for Content {
+    fn default() -> Self {
+        Content::Thinking { signature: None, thinking: None }
+    }
+}
+
+impl Content {
+    pub fn cached(self, enable_cache: bool) -> Self {
+        let cache_control = enable_cache.then_some(CacheControl::Ephemeral);
+
+        match self {
+            Content::Text { text, .. } => Content::Text { text, cache_control },
+            Content::ToolUse { id, input, name, .. } => {
+                Content::ToolUse { id, input, name, cache_control }
+            }
+            Content::ToolResult { tool_use_id, content, is_error, .. } => {
+                Content::ToolResult { tool_use_id, content, is_error, cache_control }
+            }
+            Content::Image { source, .. } => Content::Image { source, cache_control },
+            // TODO: verify this Thinking variants don't support cache control
+            Content::Thinking { signature, thinking } => Content::Thinking { signature, thinking },
+        }
+    }
+
+    pub fn is_cached(&self) -> bool {
+        match self {
+            Content::Text { cache_control, .. } => cache_control.is_some(),
+            Content::ToolUse { cache_control, .. } => cache_control.is_some(),
+            Content::ToolResult { cache_control, .. } => cache_control.is_some(),
+            Content::Image { cache_control, .. } => cache_control.is_some(),
+            Content::Thinking { .. } => false,
+        }
+    }
+}
+
+impl TryFrom<forge_domain::ToolCallFull> for Content {
+    type Error = anyhow::Error;
+    fn try_from(value: forge_domain::ToolCallFull) -> std::result::Result<Self, Self::Error> {
+        let call_id = value
+            .call_id
+            .as_ref()
+            .ok_or(forge_domain::Error::ToolCallMissingId)?;
+
+        Ok(Content::ToolUse {
+            id: call_id.as_str().to_string(),
+            input: serde_json::to_value(value.arguments).ok(),
+            name: value.name.to_string(),
+            cache_control: None,
+        })
+    }
+}
+
+impl TryFrom<forge_domain::ToolResult> for Content {
+    type Error = anyhow::Error;
+    fn try_from(value: forge_domain::ToolResult) -> std::result::Result<Self, Self::Error> {
+        let call_id = value
+            .call_id
+            .as_ref()
+            .ok_or(forge_domain::Error::ToolCallMissingId)?;
+        Ok(Content::ToolResult {
+            tool_use_id: call_id.as_str().to_string(),
+            cache_control: None,
+            content: value
+                .output
+                .values
+                .iter()
+                .filter_map(|item| item.as_str().map(|s| s.to_string()))
+                .next(),
+            is_error: Some(value.is_error()),
+        })
+    }
+}
+
+#[derive(Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum CacheControl {
+    Ephemeral,
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum Role {
+    User,
+    Assistant,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case", tag = "type")]
+pub enum ToolChoice {
+    Auto {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        disable_parallel_tool_use: Option<bool>,
+    },
+    Any {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        disable_parallel_tool_use: Option<bool>,
+    },
+    Tool {
+        name: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        disable_parallel_tool_use: Option<bool>,
+    },
+}
+
+// To understand the mappings refer: https://docs.anthropic.com/en/docs/build-with-claude/tool-use#controlling-claudes-output
+impl From<forge_domain::ToolChoice> for ToolChoice {
+    fn from(value: forge_domain::ToolChoice) -> Self {
+        match value {
+            forge_domain::ToolChoice::Auto => ToolChoice::Auto { disable_parallel_tool_use: None },
+            forge_domain::ToolChoice::Call(tool_name) => {
+                ToolChoice::Tool { name: tool_name.to_string(), disable_parallel_tool_use: None }
+            }
+            forge_domain::ToolChoice::Required => {
+                ToolChoice::Any { disable_parallel_tool_use: None }
+            }
+            forge_domain::ToolChoice::None => ToolChoice::Auto { disable_parallel_tool_use: None },
+        }
+    }
+}
+
+#[derive(Serialize)]
+pub struct ToolDefinition {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cache_control: Option<CacheControl>,
+    pub input_schema: serde_json::Value,
+}
+
+impl TryFrom<forge_domain::ToolDefinition> for ToolDefinition {
+    type Error = anyhow::Error;
+    fn try_from(value: forge_domain::ToolDefinition) -> std::result::Result<Self, Self::Error> {
+        Ok(ToolDefinition {
+            name: value.name.to_string(),
+            description: Some(value.description),
+            cache_control: None,
+            input_schema: serde_json::to_value(value.input_schema)?,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{Context, ReasoningConfig};
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_thinking_enabled_serializes_with_budget() {
+        let thinking = Thinking::Enabled { budget_tokens: 5000 };
+        let actual = serde_json::to_value(&thinking).unwrap();
+        let expected = serde_json::json!({
+            "type": "enabled",
+            "budget_tokens": 5000
+        });
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_thinking_adaptive_serializes_without_display_when_none() {
+        let thinking = Thinking::Adaptive { display: None };
+        let actual = serde_json::to_value(&thinking).unwrap();
+        let expected = serde_json::json!({"type": "adaptive"});
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_thinking_adaptive_serializes_with_summarized_display() {
+        let thinking = Thinking::Adaptive { display: Some(ThinkingDisplay::Summarized) };
+        let actual = serde_json::to_value(&thinking).unwrap();
+        let expected = serde_json::json!({
+            "type": "adaptive",
+            "display": "summarized"
+        });
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_thinking_disabled_serializes() {
+        let thinking = Thinking::Disabled;
+        let actual = serde_json::to_value(&thinking).unwrap();
+        let expected = serde_json::json!({"type": "disabled"});
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_reasoning_enabled_with_max_tokens_creates_enabled_thinking() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: Some(true),
+            max_tokens: Some(8000),
+            effort: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Enabled { budget_tokens: 8000 })
+        );
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_reasoning_max_tokens_and_effort_emit_both() {
+        // Effort and budget are independent knobs — neither should hide the other.
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            effort: Some(forge_domain::Effort::Low),
+            enabled: Some(true),
+            max_tokens: Some(8000),
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Enabled { budget_tokens: 8000 })
+        );
+        assert_eq!(
+            actual.output_config,
+            Some(OutputConfig { effort: OutputEffort::Low })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_max_tokens_alone_emits_enabled_only() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            effort: None,
+            enabled: Some(true),
+            max_tokens: Some(8000),
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Enabled { budget_tokens: 8000 })
+        );
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_reasoning_effort_without_budget_creates_output_config_and_adaptive() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            effort: Some(forge_domain::Effort::Low),
+            enabled: Some(true),
+            max_tokens: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.output_config,
+            Some(OutputConfig { effort: OutputEffort::Low })
+        );
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Adaptive { display: Some(ThinkingDisplay::Summarized) })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_effort_with_exclude_emits_adaptive_omitted() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            effort: Some(forge_domain::Effort::High),
+            enabled: Some(true),
+            max_tokens: None,
+            exclude: Some(true),
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Adaptive { display: Some(ThinkingDisplay::Omitted) })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_xhigh_effort_maps_to_xhigh() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            effort: Some(forge_domain::Effort::XHigh),
+            enabled: Some(true),
+            max_tokens: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.output_config,
+            Some(OutputConfig { effort: OutputEffort::XHigh })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_enabled_without_budget_or_effort_defaults_to_adaptive_summarized() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: Some(true),
+            max_tokens: None,
+            effort: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Adaptive { display: Some(ThinkingDisplay::Summarized) })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_enabled_with_exclude_uses_omitted_display() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: Some(true),
+            max_tokens: None,
+            effort: None,
+            exclude: Some(true),
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Adaptive { display: Some(ThinkingDisplay::Omitted) })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_disabled_does_not_create_thinking() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: Some(false),
+            max_tokens: Some(8000),
+            effort: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.thinking, None);
+    }
+
+    #[test]
+    fn test_reasoning_enabled_none_with_max_tokens_still_emits_thinking() {
+        // Matches the domain's `is_reasoning_supported` rule: enabled: None with a
+        // positive budget counts as on, so inherited/merged configs don't silently
+        // disable reasoning on the wire.
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: None,
+            max_tokens: Some(8000),
+            effort: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Enabled { budget_tokens: 8000 })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_enabled_none_with_effort_still_emits_output_config() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: None,
+            max_tokens: None,
+            effort: Some(forge_domain::Effort::High),
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(
+            actual.output_config,
+            Some(OutputConfig { effort: OutputEffort::High })
+        );
+        assert_eq!(
+            actual.thinking,
+            Some(Thinking::Adaptive { display: Some(ThinkingDisplay::Summarized) })
+        );
+    }
+
+    #[test]
+    fn test_reasoning_enabled_none_with_zero_max_tokens_does_not_emit() {
+        // Matches `is_reasoning_supported`: max_tokens > 0 is required.
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: None,
+            max_tokens: Some(0),
+            effort: None,
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.thinking, None);
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_reasoning_effort_none_does_not_emit_anything() {
+        // Effort::None is an explicit opt-out — no thinking, no output_config.
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: None,
+            max_tokens: None,
+            effort: Some(forge_domain::Effort::None),
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.thinking, None);
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_reasoning_effort_none_overrides_enabled_and_max_tokens() {
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: Some(true),
+            max_tokens: Some(8000),
+            effort: Some(forge_domain::Effort::None),
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.thinking, None);
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_reasoning_enabled_false_overrides_effort() {
+        // Explicit opt-out beats inferred enablement.
+        let fixture = Context::default().reasoning(ReasoningConfig {
+            enabled: Some(false),
+            max_tokens: None,
+            effort: Some(forge_domain::Effort::High),
+            exclude: None,
+        });
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.thinking, None);
+        assert_eq!(actual.output_config, None);
+    }
+
+    #[test]
+    fn test_no_reasoning_config_does_not_create_thinking() {
+        let fixture = Context::default();
+
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.thinking, None);
+    }
+
+    #[test]
+    fn test_context_conversion_stream_defaults_to_true() {
+        let fixture = Context::default();
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.stream, Some(true));
+    }
+
+    #[test]
+    fn test_context_conversion_stream_explicit_true() {
+        let fixture = Context::default().stream(true);
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.stream, Some(true));
+    }
+
+    #[test]
+    fn test_context_conversion_stream_explicit_false() {
+        let fixture = Context::default().stream(false);
+        let actual = Request::try_from(fixture).unwrap();
+
+        assert_eq!(actual.stream, Some(false));
+    }
+}

crates/forge_app/src/dto/anthropic/response.rs

@@ -0,0 +1,881 @@
+use forge_domain::{
+    ChatCompletionMessage, Content, ModelId, Reasoning, ReasoningPart, TokenCount, ToolCallId,
+    ToolCallPart, ToolName,
+};
+use serde::{Deserialize, Serialize};
+
+/// Represents a value that may be either a JSON number or a numeric string.
+#[derive(Deserialize, Debug, Clone, PartialEq, derive_more::TryInto, Serialize)]
+#[serde(untagged)]
+pub enum StringOrF64 {
+    Number(f64),
+    String(String),
+}
+
+use super::request::Role;
+use crate::dto::anthropic::Error;
+
+#[derive(Deserialize)]
+pub struct ListModelResponse {
+    pub data: Vec<Model>,
+}
+
+#[derive(Deserialize)]
+pub struct Model {
+    pub id: String,
+    pub display_name: Option<String>,
+}
+
+impl From<Model> for forge_domain::Model {
+    fn from(value: Model) -> Self {
+        let context_length = get_context_length(&value.id);
+        let input_modalities = if value.id.contains("claude-3")
+            || value.id.contains("claude-4")
+            || value.id.contains("claude-sonnet")
+            || value.id.contains("claude-opus")
+            || value.id.contains("claude-haiku")
+            || value.id.contains("claude-mythos")
+            || value.id.contains("claude-fable")
+        {
+            vec![
+                forge_domain::InputModality::Text,
+                forge_domain::InputModality::Image,
+            ]
+        } else {
+            vec![forge_domain::InputModality::Text]
+        };
+
+        Self {
+            id: ModelId::new(value.id),
+            name: value.display_name,
+            description: None,
+            context_length,
+            tools_supported: Some(true),
+            supports_parallel_tool_calls: None,
+            supports_reasoning: None,
+            input_modalities,
+        }
+    }
+}
+
+/// Returns the context window size for a given Claude model ID.
+///
+/// Context lengths are based on official Claude documentation:
+/// <https://docs.claude.com/en/docs/about-claude/models/overview>
+///
+/// # Arguments
+///
+/// * `model_id` - The Claude model identifier (e.g.,
+///   "claude-sonnet-4-5-20250929")
+///
+/// # Returns
+///
+/// Returns `Some(tokens)` for known models, `None` for unknown models.
+///
+/// # Notes
+///
+/// - Most current models support 200K tokens
+/// - Claude Sonnet 4.5 supports 1M tokens with the `context-1m-2025-08-07` beta
+///   header
+/// - Legacy models may have different context lengths
+fn get_context_length(model_id: &str) -> Option<u64> {
+    // Claude Mythos / Fable models (1M context)
+    if model_id.starts_with("claude-mythos") || model_id.starts_with("claude-fable") {
+        return Some(1_000_000);
+    }
+
+    // Claude Sonnet 5 and Opus 5 (1M context)
+    if model_id.starts_with("claude-sonnet-5") || model_id.starts_with("claude-opus-5") {
+        return Some(1_000_000);
+    }
+
+    // Current models (200K context)
+    if model_id.starts_with("claude-sonnet-4-5-")
+        || model_id.starts_with("claude-haiku-4-5-")
+        || model_id.starts_with("claude-opus-4-1-")
+    {
+        return Some(200_000);
+    }
+
+    // Legacy Claude 4 models (200K context)
+    if model_id.starts_with("claude-sonnet-4-")
+        || model_id.starts_with("claude-opus-4-")
+        || model_id.starts_with("claude-3-7-sonnet-")
+    {
+        return Some(200_000);
+    }
+
+    // Claude 3.5 models (200K context)
+    if model_id.starts_with("claude-3-5-sonnet-") || model_id.starts_with("claude-3-5-haiku-") {
+        return Some(200_000);
+    }
+
+    // Claude 3 Opus and Sonnet (200K context)
+    if model_id.starts_with("claude-3-opus-") || model_id.starts_with("claude-3-sonnet-") {
+        return Some(200_000);
+    }
+
+    // Claude 3 Haiku (200K context)
+    if model_id.starts_with("claude-3-haiku-") {
+        return Some(200_000);
+    }
+
+    // Claude 2.1 (200K context)
+    if model_id.starts_with("claude-2.1") {
+        return Some(200_000);
+    }
+
+    // Claude 2.0 (100K context)
+    if model_id.starts_with("claude-2.0") {
+        return Some(100_000);
+    }
+
+    // Claude Instant (100K context)
+    if model_id.starts_with("claude-instant-") {
+        return Some(100_000);
+    }
+
+    // Unknown model
+    None
+}
+
+#[derive(Deserialize, PartialEq, Clone, Debug)]
+pub struct MessageStart {
+    pub id: String,
+    pub r#type: String,
+    pub role: Role,
+    pub content: Vec<ContentBlock>,
+    pub model: String,
+    pub stop_reason: Option<StopReason>,
+    pub stop_sequence: Option<String>,
+    pub usage: Usage,
+}
+
+#[derive(Deserialize, PartialEq, Clone, Debug)]
+pub struct Usage {
+    pub input_tokens: Option<usize>,
+    pub output_tokens: Option<usize>,
+
+    pub cache_read_input_tokens: Option<usize>,
+    pub cache_creation_input_tokens: Option<usize>,
+}
+
+impl From<Usage> for forge_domain::Usage {
+    fn from(usage: Usage) -> Self {
+        // Anthropic token breakdown:
+        // - input_tokens: tokens NOT from cache (billed at full price)
+        // - cache_creation_input_tokens: tokens written to cache (billed at full price
+        //   + write cost)
+        // - cache_read_input_tokens: tokens read from cache (billed at 90% discount)
+        // Total input = input_tokens + cache_creation_input_tokens +
+        // cache_read_input_tokens
+
+        let input_tokens = usage.input_tokens.unwrap_or_default();
+        let cache_creation = usage.cache_creation_input_tokens.unwrap_or_default();
+        let cache_read = usage.cache_read_input_tokens.unwrap_or_default();
+
+        // prompt_tokens should include ALL input tokens
+        let prompt_tokens = TokenCount::Actual(input_tokens + cache_creation + cache_read);
+
+        let completion_tokens = usage
+            .output_tokens
+            .map(TokenCount::Actual)
+            .unwrap_or_default();
+
+        // cached_tokens represents tokens that benefited from caching
+        // This includes both cache creation and cache reads
+        let cached_tokens = TokenCount::Actual(cache_read);
+
+        let total_tokens = prompt_tokens + completion_tokens;
+
+        forge_domain::Usage {
+            prompt_tokens,
+            completion_tokens,
+            total_tokens,
+            cached_tokens,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum StopReason {
+    EndTurn,
+    MaxTokens,
+    StopSequence,
+    ToolUse,
+    Refusal,
+}
+
+impl From<StopReason> for forge_domain::FinishReason {
+    fn from(value: StopReason) -> Self {
+        match value {
+            StopReason::EndTurn => forge_domain::FinishReason::Stop,
+            StopReason::MaxTokens => forge_domain::FinishReason::Length,
+            StopReason::StopSequence => forge_domain::FinishReason::Stop,
+            StopReason::ToolUse => forge_domain::FinishReason::ToolCalls,
+            StopReason::Refusal => forge_domain::FinishReason::ContentFilter,
+        }
+    }
+}
+
+#[derive(Deserialize, PartialEq, Clone, Debug)]
+#[serde(rename_all = "snake_case", tag = "type")]
+pub enum Event {
+    Error {
+        error: Error,
+    },
+    MessageStart {
+        message: MessageStart,
+    },
+    ContentBlockStart {
+        index: u32,
+        content_block: ContentBlock,
+    },
+    Ping {
+        cost: Option<StringOrF64>,
+    },
+    ContentBlockDelta {
+        index: u32,
+        delta: ContentBlock,
+    },
+    ContentBlockStop {
+        index: u32,
+    },
+    MessageDelta {
+        delta: MessageDelta,
+        usage: Usage,
+    },
+    MessageStop,
+}
+
+#[derive(Deserialize, PartialEq, Clone, Debug)]
+#[serde(untagged)]
+pub enum EventData {
+    KnownEvent(Event),
+    // To handle any unknown events:
+    // ref: https://docs.anthropic.com/en/api/messages-streaming#other-events
+    Unknown(serde_json::Value),
+}
+
+#[derive(Deserialize, Clone, PartialEq, Debug)]
+pub struct MessageDelta {
+    pub stop_reason: StopReason,
+    pub stop_sequence: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Clone, PartialEq)]
+#[serde(tag = "type")]
+#[serde(rename_all = "snake_case")]
+pub enum ContentBlock {
+    Text {
+        text: String,
+    },
+    TextDelta {
+        text: String,
+    },
+    ToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+    InputJsonDelta {
+        partial_json: String,
+    },
+    Thinking {
+        thinking: Option<String>,
+        signature: Option<String>,
+    },
+    ThinkingDelta {
+        thinking: Option<String>,
+    },
+    SignatureDelta {
+        signature: Option<String>,
+    },
+    RedactedThinking {
+        data: Option<String>,
+    },
+}
+
+impl TryFrom<EventData> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+    fn try_from(value: EventData) -> Result<Self, Self::Error> {
+        match value {
+            EventData::KnownEvent(event) => ChatCompletionMessage::try_from(event),
+            EventData::Unknown(_) => {
+                // Ignore any unknown events
+                Ok(ChatCompletionMessage::assistant(Content::part("")))
+            }
+        }
+    }
+}
+
+impl TryFrom<Event> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+    fn try_from(value: Event) -> Result<Self, Self::Error> {
+        let result = match value {
+            Event::ContentBlockStart { content_block, .. }
+            | Event::ContentBlockDelta { delta: content_block, .. } => {
+                ChatCompletionMessage::try_from(content_block)?
+            }
+            Event::MessageStart { message } => {
+                // Extract usage from MessageStart - this contains input token counts
+                ChatCompletionMessage::assistant(Content::part("")).usage(message.usage)
+            }
+            Event::MessageDelta { delta, usage } => {
+                ChatCompletionMessage::assistant(Content::part(""))
+                    .finish_reason(delta.stop_reason)
+                    .usage(usage)
+            }
+            Event::Error { error } => {
+                return Err(error.into());
+            }
+            Event::Ping { cost: Some(cost) } => {
+                // OpenCode Zen sends cost in a ping event at the end of the stream
+                let cost_value = match cost {
+                    StringOrF64::Number(n) => n,
+                    StringOrF64::String(s) => s.parse().unwrap_or(0.0),
+                };
+                ChatCompletionMessage::assistant(Content::part(""))
+                    .usage(forge_domain::Usage { cost: Some(cost_value), ..Default::default() })
+            }
+            _ => ChatCompletionMessage::assistant(Content::part("")),
+        };
+
+        Ok(result)
+    }
+}
+
+impl TryFrom<ContentBlock> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+    fn try_from(value: ContentBlock) -> Result<Self, Self::Error> {
+        let result = match value {
+            ContentBlock::Text { text } | ContentBlock::TextDelta { text } => {
+                ChatCompletionMessage::assistant(Content::part(text))
+            }
+            ContentBlock::Thinking { thinking, signature } => {
+                if let Some(thinking) = thinking {
+                    ChatCompletionMessage::assistant(Content::part(""))
+                        .reasoning(Content::part(thinking.clone()))
+                        .add_reasoning_detail(Reasoning::Part(vec![
+                            ReasoningPart::default()
+                                .text(Some(thinking))
+                                .signature(signature),
+                        ]))
+                } else {
+                    ChatCompletionMessage::assistant(Content::part(""))
+                }
+            }
+            ContentBlock::RedactedThinking { data } => {
+                if let Some(data) = data {
+                    ChatCompletionMessage::assistant(Content::part(""))
+                        .reasoning(Content::part(data.clone()))
+                        .add_reasoning_detail(Reasoning::Part(vec![
+                            ReasoningPart::default().text(Some(data)),
+                        ]))
+                } else {
+                    ChatCompletionMessage::assistant(Content::part(""))
+                }
+            }
+            ContentBlock::ThinkingDelta { thinking } => {
+                if let Some(thinking) = thinking {
+                    ChatCompletionMessage::assistant(Content::part(""))
+                        .reasoning(Content::part(thinking.clone()))
+                        .add_reasoning_detail(Reasoning::Part(vec![
+                            ReasoningPart::default().text(Some(thinking)),
+                        ]))
+                } else {
+                    ChatCompletionMessage::assistant(Content::part(""))
+                }
+            }
+            ContentBlock::SignatureDelta { signature } => {
+                ChatCompletionMessage::assistant(Content::part("")).add_reasoning_detail(
+                    Reasoning::Part(vec![ReasoningPart::default().signature(signature)]),
+                )
+            }
+            ContentBlock::ToolUse { id, name, input } => {
+                // note: We've to check if the input is empty or null. else we end up adding
+                // empty object `{}` as prefix to tool args.
+                let is_empty =
+                    input.is_null() || input.as_object().is_some_and(|map| map.is_empty());
+                ChatCompletionMessage::assistant(Content::part("")).add_tool_call(ToolCallPart {
+                    call_id: Some(ToolCallId::new(id)),
+                    name: Some(ToolName::new(name)),
+                    arguments_part: if is_empty {
+                        "".to_string()
+                    } else {
+                        serde_json::to_string(&input)?
+                    },
+                    thought_signature: None,
+                })
+            }
+            ContentBlock::InputJsonDelta { partial_json } => {
+                ChatCompletionMessage::assistant(Content::part("")).add_tool_call(ToolCallPart {
+                    call_id: None,
+                    name: None,
+                    arguments_part: partial_json,
+                    thought_signature: None,
+                })
+            }
+        };
+
+        Ok(result)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_unknow_event() {
+        let event = r#"{"type": "random_error", "error": {"type": "overloaded_error", "message": "Overloaded"}}"#;
+        let event_data = serde_json::from_str::<EventData>(event).unwrap();
+        assert!(matches!(event_data, EventData::Unknown(_)));
+    }
+
+    #[test]
+    fn test_event_deser() {
+        let tests = vec![
+            (
+                "error",
+                r#"{"type": "error", "error": {"type": "overloaded_error", "message": "Overloaded"}}"#,
+                Event::Error {
+                    error: Error::OverloadedError { message: "Overloaded".to_string() },
+                },
+            ),
+            (
+                "message_start",
+                r#"{"type":"message_start","message":{"id":"msg_019LBLYFJ7fG3fuAqzuRQbyi","type":"message","role":"assistant","content":[],"model":"claude-3-opus-20240229","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":10,"output_tokens":1}}}"#,
+                Event::MessageStart {
+                    message: MessageStart {
+                        id: "msg_019LBLYFJ7fG3fuAqzuRQbyi".to_string(),
+                        r#type: "message".to_string(),
+                        role: Role::Assistant,
+                        content: vec![],
+                        model: "claude-3-opus-20240229".to_string(),
+                        stop_reason: None,
+                        stop_sequence: None,
+                        usage: Usage {
+                            input_tokens: Some(10),
+                            output_tokens: Some(1),
+                            cache_creation_input_tokens: None,
+                            cache_read_input_tokens: None,
+                        },
+                    },
+                },
+            ),
+            (
+                "content_block_start",
+                r#"{"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}"#,
+                Event::ContentBlockStart {
+                    index: 0,
+                    content_block: ContentBlock::Text { text: "".to_string() },
+                },
+            ),
+            ("ping", r#"{"type": "ping"}"#, Event::Ping { cost: None }),
+            (
+                "content_block_delta",
+                r#"{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}"#,
+                Event::ContentBlockDelta {
+                    index: 0,
+                    delta: ContentBlock::TextDelta { text: "Hello".to_string() },
+                },
+            ),
+            (
+                "content_block_delta",
+                r#"{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"!"}}"#,
+                Event::ContentBlockDelta {
+                    index: 0,
+                    delta: ContentBlock::TextDelta { text: "!".to_string() },
+                },
+            ),
+            (
+                "content_block_stop",
+                r#"{"type":"content_block_stop","index":0}"#,
+                Event::ContentBlockStop { index: 0 },
+            ),
+            (
+                "message_delta",
+                r#"{"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":12}}"#,
+                Event::MessageDelta {
+                    delta: MessageDelta { stop_reason: StopReason::EndTurn, stop_sequence: None },
+                    usage: Usage {
+                        input_tokens: None,
+                        output_tokens: Some(12),
+                        cache_creation_input_tokens: None,
+                        cache_read_input_tokens: None,
+                    },
+                },
+            ),
+            (
+                "message_stop",
+                r#"{"type":"message_stop"}"#,
+                Event::MessageStop,
+            ),
+        ];
+        for (name, input, expected) in tests {
+            let actual: Event = serde_json::from_str(input).unwrap();
+            assert_eq!(actual, expected, "test failed for event data: {name}");
+        }
+    }
+
+    #[test]
+    fn test_model_deser() {
+        let input = r#"{
+            "data": [
+                {
+                    "type": "model",
+                    "id": "claude-3-5-sonnet-20241022",
+                    "display_name": "Claude 3.5 Sonnet (New)",
+                    "created_at": "2024-10-22T00:00:00Z"
+                },
+                {
+                    "type": "model",
+                    "id": "claude-3-5-haiku-20241022",
+                    "display_name": "Claude 3.5 Haiku",
+                    "created_at": "2024-10-22T00:00:00Z"
+                }
+            ],
+            "has_more": false,
+            "first_id": "claude-3-5-sonnet-20241022",
+            "last_id": "claude-3-opus-20240229"
+        }"#;
+        let response = serde_json::from_str::<ListModelResponse>(input);
+        assert!(response.is_ok());
+        assert!(response.unwrap().data.len() == 2);
+    }
+
+    #[test]
+    fn test_usage_conversion_with_cache_read_tokens() {
+        use forge_domain::TokenCount;
+
+        // Simulate a response with cache reads
+        let fixture = Usage {
+            input_tokens: Some(100),
+            output_tokens: Some(50),
+            cache_creation_input_tokens: Some(200),
+            cache_read_input_tokens: Some(300),
+        };
+
+        let actual: forge_domain::Usage = fixture.into();
+
+        // prompt_tokens should include ALL input tokens
+        let expected_prompt = TokenCount::Actual(100 + 200 + 300);
+        assert_eq!(actual.prompt_tokens, expected_prompt);
+
+        // cached_tokens should only include cache reads (tokens that benefited from
+        // caching)
+        let expected_cached = TokenCount::Actual(300);
+        assert_eq!(actual.cached_tokens, expected_cached);
+
+        // completion_tokens should be output tokens
+        let expected_completion = TokenCount::Actual(50);
+        assert_eq!(actual.completion_tokens, expected_completion);
+
+        // total_tokens should be prompt + completion
+        let expected_total = TokenCount::Actual(600 + 50);
+        assert_eq!(actual.total_tokens, expected_total);
+    }
+
+    #[test]
+    fn test_usage_conversion_without_cache() {
+        use forge_domain::TokenCount;
+
+        let fixture = Usage {
+            input_tokens: Some(100),
+            output_tokens: Some(50),
+            cache_creation_input_tokens: None,
+            cache_read_input_tokens: None,
+        };
+
+        let actual: forge_domain::Usage = fixture.into();
+
+        let expected_prompt = TokenCount::Actual(100);
+        assert_eq!(actual.prompt_tokens, expected_prompt);
+
+        let expected_cached = TokenCount::Actual(0);
+        assert_eq!(actual.cached_tokens, expected_cached);
+
+        let expected_completion = TokenCount::Actual(50);
+        assert_eq!(actual.completion_tokens, expected_completion);
+
+        let expected_total = TokenCount::Actual(150);
+        assert_eq!(actual.total_tokens, expected_total);
+    }
+
+    #[test]
+    fn test_usage_conversion_cache_read_only() {
+        use forge_domain::TokenCount;
+
+        // Scenario: All tokens came from cache (cache hit)
+        let fixture = Usage {
+            input_tokens: Some(0),
+            output_tokens: Some(50),
+            cache_creation_input_tokens: Some(0),
+            cache_read_input_tokens: Some(500),
+        };
+
+        let actual: forge_domain::Usage = fixture.into();
+
+        let expected_prompt = TokenCount::Actual(500);
+        assert_eq!(actual.prompt_tokens, expected_prompt);
+
+        let expected_cached = TokenCount::Actual(500);
+        assert_eq!(actual.cached_tokens, expected_cached);
+
+        // Cache percentage should be 100%
+        let cache_percentage = (*actual.cached_tokens * 100) / *actual.prompt_tokens;
+        assert_eq!(cache_percentage, 100);
+    }
+
+    #[test]
+    fn test_vertex_ai_streaming_usage() {
+        use forge_domain::TokenCount;
+
+        // Simulate Vertex AI Anthropic streaming response
+        // message_start event with initial usage
+        let message_start_json = r#"{"type":"message_start","message":{"id":"msg_test","type":"message","role":"assistant","content":[],"model":"claude-3-5-sonnet-v2@20241022","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":100,"cache_creation_input_tokens":0,"cache_read_input_tokens":50,"output_tokens":0}}}"#;
+
+        let message_start_event: Event = serde_json::from_str(message_start_json).unwrap();
+
+        // Extract usage from message_start
+        let initial_usage = match message_start_event {
+            Event::MessageStart { message } => message.usage,
+            _ => panic!("Expected MessageStart event"),
+        };
+
+        // message_delta event with final usage (includes output tokens)
+        let message_delta_json = r#"{"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":75}}"#;
+
+        let message_delta_event: Event = serde_json::from_str(message_delta_json).unwrap();
+
+        // Extract usage from message_delta
+        let delta_usage = match message_delta_event {
+            Event::MessageDelta { usage, .. } => usage,
+            _ => panic!("Expected MessageDelta event"),
+        };
+
+        // Convert both to domain Usage
+        let initial_domain: forge_domain::Usage = initial_usage.into();
+        let delta_domain: forge_domain::Usage = delta_usage.into();
+
+        // Verify initial usage
+        assert_eq!(initial_domain.prompt_tokens, TokenCount::Actual(150)); // 100 + 0 + 50
+        assert_eq!(initial_domain.completion_tokens, TokenCount::Actual(0));
+        assert_eq!(initial_domain.cached_tokens, TokenCount::Actual(50));
+
+        // Verify delta usage (only has output_tokens)
+        assert_eq!(delta_domain.prompt_tokens, TokenCount::Actual(0));
+        assert_eq!(delta_domain.completion_tokens, TokenCount::Actual(75));
+        assert_eq!(delta_domain.cached_tokens, TokenCount::Actual(0));
+
+        // Merge usage (simulating how we'd combine them in practice)
+        // Using merge (max) instead of accumulate (sum) since Anthropic
+        // usage values are cumulative, not incremental deltas.
+        let merged = initial_domain.merge(&delta_domain);
+        assert_eq!(merged.prompt_tokens, TokenCount::Actual(150));
+        assert_eq!(merged.completion_tokens, TokenCount::Actual(75));
+        assert_eq!(merged.cached_tokens, TokenCount::Actual(50));
+        assert_eq!(merged.total_tokens, TokenCount::Actual(150)); // max(150, 75)
+    }
+
+    #[test]
+    fn test_message_start_event_includes_usage() {
+        use forge_domain::TokenCount;
+
+        // Test that MessageStart event properly extracts usage
+        let message_start_json = r#"{"type":"message_start","message":{"id":"msg_test","type":"message","role":"assistant","content":[],"model":"claude-3-5-sonnet-v2@20241022","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":1000,"cache_creation_input_tokens":200,"cache_read_input_tokens":300,"output_tokens":0}}}"#;
+
+        let event: Event = serde_json::from_str(message_start_json).unwrap();
+        let message: ChatCompletionMessage = event.try_into().unwrap();
+
+        // Verify usage was extracted from MessageStart
+        let usage = message.usage.expect("Usage should be present");
+        assert_eq!(usage.prompt_tokens, TokenCount::Actual(1500)); // 1000 + 200 + 300
+        assert_eq!(usage.completion_tokens, TokenCount::Actual(0));
+        assert_eq!(usage.cached_tokens, TokenCount::Actual(300));
+        assert_eq!(usage.total_tokens, TokenCount::Actual(1500));
+    }
+
+    #[test]
+    fn test_get_context_length_current_models() {
+        // Current models (200K context)
+        assert_eq!(
+            get_context_length("claude-sonnet-4-5-20250929"),
+            Some(200_000)
+        );
+        assert_eq!(
+            get_context_length("claude-haiku-4-5-20251001"),
+            Some(200_000)
+        );
+        assert_eq!(
+            get_context_length("claude-opus-4-1-20250805"),
+            Some(200_000)
+        );
+    }
+
+    #[test]
+    fn test_get_context_length_legacy_claude_4() {
+        // Legacy Claude 4 models (200K context)
+        assert_eq!(
+            get_context_length("claude-sonnet-4-20250514"),
+            Some(200_000)
+        );
+        assert_eq!(get_context_length("claude-opus-4-20250514"), Some(200_000));
+        assert_eq!(
+            get_context_length("claude-3-7-sonnet-20250219"),
+            Some(200_000)
+        );
+    }
+
+    #[test]
+    fn test_get_context_length_claude_3_5() {
+        // Claude 3.5 models (200K context)
+        assert_eq!(
+            get_context_length("claude-3-5-sonnet-20241022"),
+            Some(200_000)
+        );
+        assert_eq!(
+            get_context_length("claude-3-5-haiku-20241022"),
+            Some(200_000)
+        );
+    }
+
+    #[test]
+    fn test_get_context_length_claude_3() {
+        // Claude 3 models (200K context)
+        assert_eq!(get_context_length("claude-3-opus-20240229"), Some(200_000));
+        assert_eq!(
+            get_context_length("claude-3-sonnet-20240229"),
+            Some(200_000)
+        );
+        assert_eq!(get_context_length("claude-3-haiku-20240307"), Some(200_000));
+    }
+
+    #[test]
+    fn test_get_context_length_claude_2() {
+        // Claude 2.1 (200K context)
+        assert_eq!(get_context_length("claude-2.1"), Some(200_000));
+
+        // Claude 2.0 (100K context)
+        assert_eq!(get_context_length("claude-2.0"), Some(100_000));
+    }
+
+    #[test]
+    fn test_get_context_length_claude_instant() {
+        // Claude Instant (100K context)
+        assert_eq!(get_context_length("claude-instant-1.2"), Some(100_000));
+    }
+
+    #[test]
+    fn test_get_context_length_unknown_model() {
+        // Unknown models should return None
+        assert_eq!(get_context_length("unknown-model"), None);
+        assert_eq!(get_context_length("claude-future-5-0"), None);
+        assert_eq!(get_context_length(""), None);
+    }
+
+    #[test]
+    fn test_model_conversion_includes_context_length() {
+        let fixture = Model {
+            id: "claude-sonnet-4-5-20250929".to_string(),
+            display_name: Some("Claude 3.5 Sonnet (New)".to_string()),
+        };
+
+        let actual: forge_domain::Model = fixture.into();
+
+        assert_eq!(actual.context_length, Some(200_000));
+        assert_eq!(actual.id.as_str(), "claude-sonnet-4-5-20250929");
+        assert_eq!(actual.name, Some("Claude 3.5 Sonnet (New)".to_string()));
+    }
+
+    #[test]
+    fn test_model_conversion_unknown_model_no_context() {
+        let fixture = Model {
+            id: "unknown-claude-model".to_string(),
+            display_name: Some("Unknown Model".to_string()),
+        };
+
+        let actual: forge_domain::Model = fixture.into();
+
+        assert_eq!(actual.context_length, None);
+        assert_eq!(actual.id.as_str(), "unknown-claude-model");
+    }
+
+    #[test]
+    fn test_ping_event_with_string_cost() {
+        // Fixture: OpenCode Zen sends cost as a string in a ping event
+        let fixture = r#"{"type":"ping","cost":"0.00724710"}"#;
+
+        let actual: Event = serde_json::from_str(fixture).unwrap();
+
+        let expected = Event::Ping { cost: Some(StringOrF64::String("0.00724710".into())) };
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_ping_event_with_numeric_cost() {
+        // Fixture: Cost as a numeric value
+        let fixture = r#"{"type":"ping","cost":0.05}"#;
+
+        let actual: Event = serde_json::from_str(fixture).unwrap();
+
+        let expected = Event::Ping { cost: Some(StringOrF64::Number(0.05)) };
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_ping_event_with_cost_produces_usage() {
+        // Fixture: Ping event with cost should produce a usage with cost
+        let fixture = Event::Ping { cost: Some(StringOrF64::Number(0.00724710)) };
+
+        let actual = ChatCompletionMessage::try_from(fixture).unwrap();
+
+        let expected_usage = forge_domain::Usage { cost: Some(0.00724710), ..Default::default() };
+        assert_eq!(actual.usage, Some(expected_usage));
+    }
+
+    #[test]
+    fn test_ping_event_without_cost_produces_empty_message() {
+        // Fixture: Standard ping without cost should produce empty message
+        let fixture = Event::Ping { cost: None };
+
+        let actual = ChatCompletionMessage::try_from(fixture).unwrap();
+
+        assert_eq!(actual.usage, None);
+    }
+
+    #[test]
+    fn test_message_delta_refusal_stop_reason() {
+        // Fable returns HTTP 200 with stop_reason "refusal" when safety
+        // classifiers decline a request. This must parse as a known event,
+        // not fall through to EventData::Unknown (which silently drops the
+        // finish reason and triggers an empty-completion retry loop).
+        let fixture = r#"{"type":"message_delta","delta":{"stop_reason":"refusal","stop_sequence":null},"usage":{"output_tokens":0}}"#;
+
+        let actual = serde_json::from_str::<EventData>(fixture).unwrap();
+
+        let expected = EventData::KnownEvent(Event::MessageDelta {
+            delta: MessageDelta { stop_reason: StopReason::Refusal, stop_sequence: None },
+            usage: Usage {
+                input_tokens: None,
+                output_tokens: Some(0),
+                cache_creation_input_tokens: None,
+                cache_read_input_tokens: None,
+            },
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_refusal_maps_to_content_filter() {
+        let fixture = StopReason::Refusal;
+
+        let actual = forge_domain::FinishReason::from(fixture);
+
+        let expected = forge_domain::FinishReason::ContentFilter;
+        assert_eq!(actual, expected);
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/auth_system_message.rs

@@ -0,0 +1,187 @@
+use forge_domain::Transformer;
+
+use crate::dto::anthropic::{Request, SystemMessage};
+
+/// Adds authentication system message when OAuth is enabled.
+pub struct AuthSystemMessage {
+    message: String,
+}
+
+impl AuthSystemMessage {
+    const AUTH_MESSAGE: &'static str = include_str!("claude_code.md");
+
+    /// Creates a new AuthSystemMessage with the provided message.
+    pub fn new(message: String) -> Self {
+        Self { message }
+    }
+}
+
+impl Default for AuthSystemMessage {
+    fn default() -> Self {
+        Self::new(Self::AUTH_MESSAGE.to_string())
+    }
+}
+
+impl Transformer for AuthSystemMessage {
+    type Value = Request;
+
+    /// Prepends auth system message when enabled.
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        let auth_system_message = SystemMessage {
+            r#type: "text".to_string(),
+            text: self.message.trim().to_string(),
+            cache_control: None,
+        };
+
+        // Get or create the system messages vector
+        let mut system_messages = request.system.take().unwrap_or_default();
+
+        // Prepend the auth message at the beginning
+        system_messages.insert(0, auth_system_message);
+
+        request.system = Some(system_messages);
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{Context, ContextMessage, ModelId, Role, TextMessage};
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    async fn load_auth_message() -> String {
+        forge_test_kit::fixture!("/src/dto/anthropic/transforms/claude_code.md").await
+    }
+
+    fn create_request_with_system_messages(system_count: usize) -> Request {
+        let mut messages = Vec::new();
+
+        // Add system messages
+        for i in 0..system_count {
+            messages.push(
+                ContextMessage::Text(TextMessage::new(
+                    Role::System,
+                    format!("System message {}", i),
+                ))
+                .into(),
+            );
+        }
+
+        // Add at least one user message
+        messages.push(
+            ContextMessage::Text(
+                TextMessage::new(Role::User, "Hello")
+                    .model(ModelId::new("claude-3-5-sonnet-20241022")),
+            )
+            .into(),
+        );
+
+        let context = Context {
+            conversation_id: None,
+            messages,
+            tools: vec![],
+            tool_choice: None,
+            max_tokens: None,
+            temperature: None,
+            top_p: None,
+            top_k: None,
+            reasoning: None,
+            stream: None,
+            response_format: None,
+            initiator: None,
+        };
+
+        Request::try_from(context).unwrap()
+    }
+
+    #[tokio::test]
+    async fn test_enabled_adds_auth_message() {
+        let auth_message = load_auth_message().await;
+        let fixture = create_request_with_system_messages(0);
+        let mut transformer = AuthSystemMessage::new(auth_message.clone()).when(|_| true);
+
+        let actual = transformer.transform(fixture);
+
+        let system_messages = actual.system.unwrap();
+        assert_eq!(system_messages.len(), 1);
+        assert_eq!(system_messages[0].text, auth_message.trim());
+        assert_eq!(system_messages[0].r#type, "text");
+    }
+
+    #[tokio::test]
+    async fn test_disabled_does_not_add_auth_message() {
+        let auth_message = load_auth_message().await;
+        let fixture = create_request_with_system_messages(0);
+        let mut transformer = AuthSystemMessage::new(auth_message).when(|_| false);
+
+        let actual = transformer.transform(fixture);
+
+        // Should have no system messages or empty vector
+        let system_messages = actual.system.unwrap_or_default();
+        assert_eq!(system_messages.len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_prepends_to_existing_system_messages() {
+        let auth_message = load_auth_message().await;
+        let fixture = create_request_with_system_messages(2);
+        let mut transformer = AuthSystemMessage::new(auth_message.clone()).when(|_| true);
+
+        let actual = transformer.transform(fixture);
+
+        let system_messages = actual.system.unwrap();
+        assert_eq!(system_messages.len(), 3);
+
+        // Auth message should be first
+        assert_eq!(system_messages[0].text, auth_message.trim());
+        assert_eq!(system_messages[0].r#type, "text");
+
+        // Existing messages should follow
+        assert_eq!(system_messages[1].text, "System message 0");
+        assert_eq!(system_messages[2].text, "System message 1");
+    }
+
+    #[tokio::test]
+    async fn test_auth_message_content_matches_file() {
+        let auth_message = load_auth_message().await;
+        let fixture = create_request_with_system_messages(0);
+        let mut transformer = AuthSystemMessage::new(auth_message).when(|_| true);
+
+        let actual = transformer.transform(fixture);
+
+        let system_messages = actual.system.unwrap();
+        let expected_content = "You are Claude Code, Anthropic's official CLI for Claude.";
+        assert_eq!(system_messages[0].text, expected_content);
+    }
+
+    #[tokio::test]
+    async fn test_with_one_existing_system_message() {
+        let auth_message = load_auth_message().await;
+        let fixture = create_request_with_system_messages(1);
+        let mut transformer = AuthSystemMessage::new(auth_message.clone()).when(|_| true);
+
+        let actual = transformer.transform(fixture);
+
+        let system_messages = actual.system.unwrap();
+        assert_eq!(system_messages.len(), 2);
+        assert_eq!(system_messages[0].text, auth_message.trim());
+        assert_eq!(system_messages[1].text, "System message 0");
+    }
+
+    #[tokio::test]
+    async fn test_disabled_preserves_existing_system_messages() {
+        let auth_message = load_auth_message().await;
+        let fixture = create_request_with_system_messages(2);
+        let expected_count = fixture.system.as_ref().unwrap().len();
+
+        let mut transformer = AuthSystemMessage::new(auth_message).when(|_| false);
+        let actual = transformer.transform(fixture);
+
+        let system_messages = actual.system.unwrap();
+        assert_eq!(system_messages.len(), expected_count);
+        assert_eq!(system_messages[0].text, "System message 0");
+        assert_eq!(system_messages[1].text, "System message 1");
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/capitalize_tool_names.rs

@@ -0,0 +1,116 @@
+use forge_domain::Transformer;
+
+use crate::dto::anthropic::Request;
+
+/// Transformer that capitalizes specific tool names for Anthropic
+/// compatibility.
+///
+/// This transformer modifies tool names to use PascalCase for certain tools:
+/// - `read` -> `Read`
+/// - `write` -> `Write`
+///
+/// When the LLM sends back tool calls, both the capitalized and lowercase
+/// versions are supported through alias handling in the deserialization logic.
+pub struct CapitalizeToolNames;
+
+impl Transformer for CapitalizeToolNames {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        for tool in &mut request.tools {
+            tool.name = match tool.name.as_str() {
+                "read" => "Read".to_string(),
+                "write" => "Write".to_string(),
+                "task" => "Task".to_string(),
+                _ => tool.name.clone(),
+            };
+        }
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{Context, ContextMessage, ModelId, ToolDefinition, Transformer};
+
+    use super::*;
+
+    #[test]
+    fn test_capitalizes_read_tool() {
+        let fixture = Context::default()
+            .add_tool(ToolDefinition::new("read").description("Read a file"))
+            .add_message(ContextMessage::user(
+                "test",
+                Some(ModelId::new("claude-3-5-sonnet-20241022")),
+            ));
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = CapitalizeToolNames.transform(request);
+
+        assert_eq!(request.tools[0].name, "Read");
+    }
+
+    #[test]
+    fn test_capitalizes_write_tool() {
+        let fixture = Context::default()
+            .add_tool(ToolDefinition::new("write").description("Write a file"))
+            .add_message(ContextMessage::user(
+                "test",
+                Some(ModelId::new("claude-3-5-sonnet-20241022")),
+            ));
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = CapitalizeToolNames.transform(request);
+
+        assert_eq!(request.tools[0].name, "Write");
+    }
+
+    #[test]
+    fn test_leaves_other_tools_unchanged() {
+        let fixture = Context::default()
+            .add_tool(ToolDefinition::new("shell").description("Execute shell command"))
+            .add_tool(ToolDefinition::new("fs_search").description("Search files"))
+            .add_message(ContextMessage::user(
+                "test",
+                Some(ModelId::new("claude-3-5-sonnet-20241022")),
+            ));
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = CapitalizeToolNames.transform(request);
+
+        assert_eq!(request.tools[0].name, "shell");
+        assert_eq!(request.tools[1].name, "fs_search");
+    }
+
+    #[test]
+    fn test_handles_multiple_tools_including_read_and_write() {
+        let fixture = Context::default()
+            .add_tool(ToolDefinition::new("read").description("Read a file"))
+            .add_tool(ToolDefinition::new("write").description("Write a file"))
+            .add_tool(ToolDefinition::new("shell").description("Execute shell command"))
+            .add_message(ContextMessage::user(
+                "test",
+                Some(ModelId::new("claude-3-5-sonnet-20241022")),
+            ));
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = CapitalizeToolNames.transform(request);
+
+        assert_eq!(request.tools[0].name, "Read");
+        assert_eq!(request.tools[1].name, "Write");
+        assert_eq!(request.tools[2].name, "shell");
+    }
+
+    #[test]
+    fn test_handles_empty_tools_list() {
+        let fixture = Context::default().add_message(ContextMessage::user(
+            "test",
+            Some(ModelId::new("claude-3-5-sonnet-20241022")),
+        ));
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = CapitalizeToolNames.transform(request);
+
+        assert!(request.tools.is_empty());
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/claude_code.md

@@ -0,0 +1 @@
+You are Claude Code, Anthropic's official CLI for Claude.

crates/forge_app/src/dto/anthropic/transforms/drop_invalid_toolcalls.rs

@@ -0,0 +1,136 @@
+use forge_domain::Transformer;
+use serde_json::json;
+
+use crate::dto::anthropic::{Content, Request};
+
+/// Transformer that normalizes ToolUse content to ensure inputs are always
+/// objects.
+/// - Preserves `Content::Text` and other content types as-is
+/// - For `Content::ToolUse`:
+///   - If input is already an object, keeps it unchanged
+///   - If input is None, keeps it as None
+///   - If input is non-object (string, array, number, etc.), wraps it in
+///     `{"json": value}`
+pub struct DropInvalidToolUse;
+
+impl Transformer for DropInvalidToolUse {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        for message in request.get_messages_mut() {
+            for content in &mut message.content {
+                if let Content::ToolUse { input, .. } = content {
+                    *input = match input.take() {
+                        Some(value) if value.is_object() => Some(value),
+                        Some(value) => Some(json!({ "json": value })),
+                        None => None,
+                    };
+                }
+            }
+        }
+
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{
+        Context, ContextMessage, ModelId, Role, TextMessage, ToolCallArguments, ToolCallFull,
+        Transformer,
+    };
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+
+    use super::*;
+    use crate::dto::anthropic::Request;
+
+    fn transform_tool_call(json_args: &str) -> Request {
+        let fixture = Context::default().messages(vec![
+            ContextMessage::Text(
+                TextMessage::new(Role::User, "Hello")
+                    .tool_calls(vec![
+                        ToolCallFull::new("test_tool")
+                            .call_id("call_123")
+                            .arguments(ToolCallArguments::from_json(json_args)),
+                    ])
+                    .model(ModelId::new("claude-3-5-sonnet-20241022")),
+            )
+            .into(),
+        ]);
+        DropInvalidToolUse.transform(Request::try_from(fixture).unwrap())
+    }
+
+    fn get_tool_input(request: &Request) -> &Option<serde_json::Value> {
+        if let Content::ToolUse { input, .. } = &request.messages[0].content[1] {
+            input
+        } else {
+            panic!("Expected ToolUse content")
+        }
+    }
+
+    #[test]
+    fn test_preserves_tool_use_with_object_input() {
+        let actual = transform_tool_call(r#"{"key": "value"}"#);
+        assert_eq!(get_tool_input(&actual), &Some(json!({"key": "value"})));
+    }
+
+    #[test]
+    fn test_wraps_tool_use_with_string_input() {
+        let actual = transform_tool_call(r#""string_value""#);
+        assert_eq!(
+            get_tool_input(&actual),
+            &Some(json!({"json": "string_value"}))
+        );
+    }
+
+    #[test]
+    fn test_wraps_tool_use_with_array_input() {
+        let actual = transform_tool_call(r#"[1, 2, 3]"#);
+        assert_eq!(get_tool_input(&actual), &Some(json!({"json": [1, 2, 3]})));
+    }
+
+    #[test]
+    fn test_wraps_tool_use_with_number_input() {
+        let actual = transform_tool_call(r#"42"#);
+        assert_eq!(get_tool_input(&actual), &Some(json!({"json": 42})));
+    }
+
+    #[test]
+    fn test_wraps_tool_use_with_none_input() {
+        let request = Request::default().messages(vec![crate::dto::anthropic::Message {
+            role: crate::dto::anthropic::Role::User,
+            content: vec![Content::ToolUse {
+                id: "call_123".to_string(),
+                name: "test_tool".to_string(),
+                input: None,
+                cache_control: None,
+            }],
+        }]);
+        let actual = DropInvalidToolUse.transform(request);
+
+        if let Content::ToolUse { input, .. } = &actual.messages[0].content[0] {
+            assert_eq!(input, &None);
+        }
+    }
+
+    #[test]
+    fn test_empty_messages_remain_empty() {
+        let actual = DropInvalidToolUse.transform(Request::try_from(Context::default()).unwrap());
+        assert_eq!(actual.messages.len(), 0);
+    }
+
+    #[test]
+    fn test_preserves_text_content() {
+        let fixture = Context::default().messages(vec![
+            ContextMessage::Text(TextMessage::new(Role::User, "Hello")).into(),
+        ]);
+        let actual = DropInvalidToolUse.transform(Request::try_from(fixture).unwrap());
+
+        assert_eq!(actual.messages.len(), 1);
+        assert!(matches!(
+            actual.messages[0].content[0],
+            Content::Text { .. }
+        ));
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/enforce_schema.rs

@@ -0,0 +1,138 @@
+use forge_domain::Transformer;
+
+use crate::dto::anthropic::{OutputFormat, Request};
+use crate::utils::enforce_strict_schema;
+
+/// Transformer that normalizes output_format schema to meet Anthropic API
+/// requirements.
+///
+/// Anthropic requires that all object types in JSON schemas must explicitly set
+/// `additionalProperties: false`. This transformer recursively processes the
+/// schema to add this requirement.
+///
+/// # Example
+///
+/// Before normalization:
+/// ```json
+/// {
+///   "type": "object",
+///   "properties": { "name": { "type": "string" } }
+/// }
+/// ```
+///
+/// After normalization:
+/// ```json
+/// {
+///   "type": "object",
+///   "properties": { "name": { "type": "string" } },
+///   "additionalProperties": false
+/// }
+/// ```
+pub struct EnforceStrictObjectSchema;
+
+impl Transformer for EnforceStrictObjectSchema {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        if let Some(OutputFormat::JsonSchema { schema }) = request.output_format.take() {
+            // Convert schema to JSON value for normalization
+            if let Ok(mut schema_value) = serde_json::to_value(&schema) {
+                // Use non-strict mode (false) for Anthropic - only adds additionalProperties
+                enforce_strict_schema(&mut schema_value, false);
+
+                // Convert back to RootSchema
+                if let Ok(normalized_schema) = serde_json::from_value(schema_value) {
+                    request.output_format =
+                        Some(OutputFormat::JsonSchema { schema: normalized_schema });
+                } else {
+                    // If deserialization fails, keep the original schema
+                    request.output_format = Some(OutputFormat::JsonSchema { schema });
+                }
+            } else {
+                // If serialization fails, keep the original schema
+                request.output_format = Some(OutputFormat::JsonSchema { schema });
+            }
+        }
+
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+    use schemars::JsonSchema;
+    use serde::Deserialize;
+
+    use super::*;
+
+    #[derive(Deserialize, JsonSchema)]
+    #[schemars(title = "test_response")]
+    #[allow(dead_code)]
+    struct TestResponse {
+        name: String,
+        nested: NestedObject,
+    }
+
+    #[derive(Deserialize, JsonSchema)]
+    #[allow(dead_code)]
+    struct NestedObject {
+        value: String,
+    }
+
+    #[test]
+    fn test_normalize_output_schema_adds_additional_properties() {
+        let schema = schemars::schema_for!(TestResponse);
+        let fixture = Request::default().output_format(OutputFormat::JsonSchema { schema });
+
+        let actual = EnforceStrictObjectSchema.transform(fixture);
+
+        // Convert to JSON to check if additionalProperties was added
+        if let Some(OutputFormat::JsonSchema { schema }) = actual.output_format {
+            let schema_json = serde_json::to_value(&schema).unwrap();
+
+            // Check top-level schema
+            assert_eq!(
+                schema_json["additionalProperties"],
+                serde_json::Value::Bool(false),
+                "Top-level additionalProperties should be false"
+            );
+
+            // Check nested object schema - it might be in definitions or $defs
+            if let Some(nested_schema) = schema_json
+                .get("properties")
+                .and_then(|p| p.get("nested"))
+                .and_then(|n| n.get("additionalProperties"))
+            {
+                assert_eq!(
+                    nested_schema,
+                    &serde_json::Value::Bool(false),
+                    "Nested additionalProperties should be false"
+                );
+            } else if let Some(defs) = schema_json
+                .get("$defs")
+                .or_else(|| schema_json.get("definitions"))
+            {
+                // Check if NestedObject is in definitions
+                if let Some(nested_def) = defs.get("NestedObject") {
+                    assert_eq!(
+                        nested_def["additionalProperties"],
+                        serde_json::Value::Bool(false),
+                        "NestedObject in definitions should have additionalProperties: false"
+                    );
+                }
+            }
+        } else {
+            panic!("Expected output_format to be Some(OutputFormat::JsonSchema)");
+        }
+    }
+
+    #[test]
+    fn test_normalize_output_schema_preserves_none() {
+        let fixture = Request::default();
+
+        let actual = EnforceStrictObjectSchema.transform(fixture);
+
+        assert_eq!(actual.output_format, None);
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/mcp_tool_names.rs

@@ -0,0 +1,116 @@
+use forge_domain::Transformer;
+
+use crate::dto::anthropic::Request;
+
+/// Converts MCP tool names from Forge's internal format
+/// (`mcp_{server}_tool_{tool}`) to the Claude Code compatible format
+/// (`mcp__{server}__{tool}`).
+///
+/// Claude Code expects MCP tools to use double-underscore separators between
+/// the `mcp` prefix, server name, and tool name. This transformer is applied
+/// only when sending requests to the Claude Code provider (OAuth-authenticated
+/// sessions).
+pub struct McpToolNames;
+
+impl Transformer for McpToolNames {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        for tool in &mut request.tools {
+            tool.name = to_claude_code_format(&tool.name);
+        }
+        request
+    }
+}
+
+/// Converts a tool name from the internal `mcp_{server}_tool_{tool}` format to
+/// the Claude Code `mcp__{server}__{tool}` format.
+///
+/// Uses the last occurrence of `_tool_` as the server/tool separator to
+/// correctly handle server names that themselves contain `_tool_` as a
+/// substring. Names that do not match the internal format are returned
+/// unchanged.
+fn to_claude_code_format(name: &str) -> String {
+    let Some(rest) = name.strip_prefix("mcp_") else {
+        return name.to_string();
+    };
+
+    // Only convert names that contain the `_tool_` separator (internal format).
+    // rsplit_once handles edge-case server names containing `_tool_`.
+    if let Some((server, tool)) = rest.rsplit_once("_tool_") {
+        return format!("mcp__{server}__{tool}");
+    }
+
+    name.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{Context, ContextMessage, ModelId, ToolDefinition, Transformer};
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_converts_simple_mcp_tool_name() {
+        let actual = to_claude_code_format("mcp_github_tool_create_issue");
+        let expected = "mcp__github__create_issue";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_converts_mcp_tool_name_with_underscored_server() {
+        let actual = to_claude_code_format("mcp_hugging_face_tool_read_channel");
+        let expected = "mcp__hugging_face__read_channel";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_handles_server_name_containing_tool_substring() {
+        // Server named "my_tool_server", tool named "action"
+        // rfind gives the LAST `_tool_`, so server = "my_tool_server", tool = "action"
+        let actual = to_claude_code_format("mcp_my_tool_server_tool_action");
+        let expected = "mcp__my_tool_server__action";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_leaves_already_converted_names_unchanged() {
+        // mcp__ prefix means it was already converted; no `_tool_` in sanitized names
+        let actual = to_claude_code_format("mcp__github__create_issue");
+        let expected = "mcp__github__create_issue";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_leaves_non_mcp_tools_unchanged() {
+        let actual = to_claude_code_format("read");
+        let expected = "read";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_transformer_converts_mcp_tools_in_request() {
+        let fixture = Context::default()
+            .add_tool(
+                ToolDefinition::new("mcp_github_tool_create_issue")
+                    .description("Create a GitHub issue"),
+            )
+            .add_tool(ToolDefinition::new("read").description("Read a file"))
+            .add_tool(
+                ToolDefinition::new("mcp_slack_tool_send_message")
+                    .description("Send a Slack message"),
+            )
+            .add_message(ContextMessage::user(
+                "test",
+                Some(ModelId::new("claude-3-5-sonnet-20241022")),
+            ));
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = McpToolNames.transform(request);
+
+        assert_eq!(request.tools[0].name, "mcp__github__create_issue");
+        assert_eq!(request.tools[1].name, "read");
+        assert_eq!(request.tools[2].name, "mcp__slack__send_message");
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/mod.rs

@@ -0,0 +1,19 @@
+mod auth_system_message;
+mod capitalize_tool_names;
+mod drop_invalid_toolcalls;
+mod enforce_schema;
+mod mcp_tool_names;
+mod reasoning_transform;
+mod remove_output_format;
+mod sanitize_tool_ids;
+mod set_cache;
+
+pub use auth_system_message::AuthSystemMessage;
+pub use capitalize_tool_names::CapitalizeToolNames;
+pub use drop_invalid_toolcalls::DropInvalidToolUse;
+pub use enforce_schema::EnforceStrictObjectSchema;
+pub use mcp_tool_names::McpToolNames;
+pub use reasoning_transform::ReasoningTransform;
+pub use remove_output_format::RemoveOutputFormat;
+pub use sanitize_tool_ids::SanitizeToolIds;
+pub use set_cache::SetCache;

crates/forge_app/src/dto/anthropic/transforms/reasoning_transform.rs

@@ -0,0 +1,135 @@
+use forge_domain::{Context, Transformer};
+
+pub struct ReasoningTransform;
+
+impl Transformer for ReasoningTransform {
+    type Value = Context;
+    fn transform(&mut self, mut context: Self::Value) -> Self::Value {
+        // Must stay in lockstep with the Anthropic request builder, which gates
+        // on the same predicate — otherwise `thinking`/`output_config` ship
+        // alongside sampling params that Anthropic rejects.
+        if context.is_reasoning_supported() {
+            context.top_k = None;
+            context.top_p = None;
+        }
+
+        context
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{Context, ReasoningConfig, TopK, TopP, Transformer};
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    fn create_context_fixture() -> Context {
+        Context::default()
+            .top_k(TopK::new(50).unwrap())
+            .top_p(TopP::new(0.8).unwrap())
+    }
+
+    fn create_reasoning_config_fixture(
+        enabled: bool,
+        max_tokens: Option<usize>,
+    ) -> ReasoningConfig {
+        ReasoningConfig {
+            enabled: Some(enabled),
+            max_tokens,
+            effort: None,
+            exclude: None,
+        }
+    }
+
+    #[test]
+    fn test_reasoning_enabled_with_max_tokens_removes_top_k_and_top_p() {
+        let fixture =
+            create_context_fixture().reasoning(create_reasoning_config_fixture(true, Some(1024)));
+        let mut transformer = ReasoningTransform;
+        let actual = transformer.transform(fixture);
+        let expected =
+            Context::default().reasoning(create_reasoning_config_fixture(true, Some(1024)));
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_reasoning_disabled_preserves_top_k_and_top_p() {
+        let fixture =
+            create_context_fixture().reasoning(create_reasoning_config_fixture(false, Some(1024)));
+        let mut transformer = ReasoningTransform;
+        let actual = transformer.transform(fixture.clone());
+        let expected = fixture;
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_reasoning_enabled_without_max_tokens_removes_top_k_and_top_p() {
+        let fixture =
+            create_context_fixture().reasoning(create_reasoning_config_fixture(true, None));
+        let mut transformer = ReasoningTransform;
+        let actual = transformer.transform(fixture);
+        let expected = Context::default().reasoning(create_reasoning_config_fixture(true, None));
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_no_reasoning_config_preserves_top_k_and_top_p() {
+        let fixture = create_context_fixture();
+        let mut transformer = ReasoningTransform;
+        let actual = transformer.transform(fixture.clone());
+        let expected = fixture;
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_enabled_none_with_effort_still_strips_top_k_and_top_p() {
+        // `enabled: None` + effort is treated as reasoning-on (domain rule).
+        let fixture = create_context_fixture().reasoning(ReasoningConfig {
+            enabled: None,
+            max_tokens: None,
+            effort: Some(forge_domain::Effort::High),
+            exclude: None,
+        });
+        let mut transformer = ReasoningTransform;
+        let actual = transformer.transform(fixture);
+
+        assert_eq!(actual.top_k, None);
+        assert_eq!(actual.top_p, None);
+    }
+
+    #[test]
+    fn test_enabled_none_with_positive_max_tokens_still_strips_top_k_and_top_p() {
+        let fixture = create_context_fixture().reasoning(ReasoningConfig {
+            enabled: None,
+            max_tokens: Some(8000),
+            effort: None,
+            exclude: None,
+        });
+        let mut transformer = ReasoningTransform;
+        let actual = transformer.transform(fixture);
+
+        assert_eq!(actual.top_k, None);
+        assert_eq!(actual.top_p, None);
+    }
+
+    #[test]
+    fn test_enabled_none_with_zero_max_tokens_preserves_top_k_and_top_p() {
+        // Matches `is_reasoning_supported`: max_tokens == 0 is treated as off.
+        let fixture = create_context_fixture().reasoning(ReasoningConfig {
+            enabled: None,
+            max_tokens: Some(0),
+            effort: None,
+            exclude: None,
+        });
+        let mut transformer = ReasoningTransform;
+        let actual = transformer.transform(fixture.clone());
+
+        assert_eq!(actual.top_k, fixture.top_k);
+        assert_eq!(actual.top_p, fixture.top_p);
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/remove_output_format.rs

@@ -0,0 +1,75 @@
+use forge_domain::Transformer;
+
+use crate::dto::anthropic::Request;
+
+/// Transformer that removes the output_format field from Anthropic requests.
+///
+/// This is specifically needed for Vertex AI Anthropic integration, which does
+/// not support the `output_format` parameter. When present, it causes a 400
+/// error: "output_format: Extra inputs are not permitted"
+///
+/// # Example
+///
+/// Before transformation:
+/// ```json
+/// {
+///   "messages": [...],
+///   "output_format": {
+///     "type": "json_schema",
+///     "schema": {...}
+///   }
+/// }
+/// ```
+///
+/// After transformation:
+/// ```json
+/// {
+///   "messages": [...]
+/// }
+/// ```
+pub struct RemoveOutputFormat;
+
+impl Transformer for RemoveOutputFormat {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        request.output_format = None;
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+    use schemars::JsonSchema;
+    use serde::Deserialize;
+
+    use super::*;
+    use crate::dto::anthropic::OutputFormat;
+
+    #[derive(Deserialize, JsonSchema)]
+    #[schemars(title = "test_response")]
+    #[allow(dead_code)]
+    struct TestResponse {
+        name: String,
+    }
+
+    #[test]
+    fn test_removes_output_format() {
+        let schema = schemars::schema_for!(TestResponse);
+        let fixture = Request::default().output_format(OutputFormat::JsonSchema { schema });
+
+        let actual = RemoveOutputFormat.transform(fixture);
+
+        assert_eq!(actual.output_format, None);
+    }
+
+    #[test]
+    fn test_preserves_none_output_format() {
+        let fixture = Request::default();
+
+        let actual = RemoveOutputFormat.transform(fixture);
+
+        assert_eq!(actual.output_format, None);
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/sanitize_tool_ids.rs

@@ -0,0 +1,223 @@
+use forge_domain::Transformer;
+use regex::Regex;
+
+use crate::dto::anthropic::{Content, Request};
+
+/// Transformer that sanitizes tool call IDs for Anthropic/Vertex Anthropic
+/// compatibility.
+///
+/// Anthropic requires tool call IDs to match the pattern `^[a-zA-Z0-9_-]+$`.
+/// This transformer replaces any invalid characters (non-alphanumeric,
+/// non-underscore, non-hyphen) with underscores.
+///
+/// This is particularly important for Vertex AI Anthropic which strictly
+/// validates tool_use.id and tool_result.tool_use_id fields and will reject
+/// requests with IDs containing invalid characters with a 400 Bad Request
+/// error.
+///
+/// # Example
+///
+/// ```ignore
+/// // Before transformation:
+/// tool_use.id = "call_123@#$%^&*()"
+///
+/// // After transformation:
+/// tool_use.id = "call_123_________"
+/// ```
+pub struct SanitizeToolIds;
+
+impl Transformer for SanitizeToolIds {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        let regex = Regex::new(r"[^a-zA-Z0-9_-]").unwrap();
+
+        for message in &mut request.messages {
+            for content in &mut message.content {
+                match content {
+                    Content::ToolUse { id, .. } => {
+                        *id = regex.replace_all(id, "_").to_string();
+                    }
+                    Content::ToolResult { tool_use_id, .. } => {
+                        *tool_use_id = regex.replace_all(tool_use_id, "_").to_string();
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{
+        Context, ContextMessage, ModelId, Role, TextMessage, ToolCallArguments, ToolCallFull,
+        ToolCallId, ToolResult, Transformer,
+    };
+
+    use super::*;
+
+    #[test]
+    fn test_sanitizes_tool_use_id_with_invalid_chars() {
+        let fixture = Context::default().messages(vec![
+            ContextMessage::Text(
+                TextMessage::new(Role::User, "test")
+                    .tool_calls(vec![
+                        ToolCallFull::new("test_tool")
+                            .call_id("call_123@#$%^&*()")
+                            .arguments(ToolCallArguments::from_json("{}")),
+                    ])
+                    .model(ModelId::new("claude-3-5-sonnet-20241022")),
+            )
+            .into(),
+        ]);
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = SanitizeToolIds.transform(request);
+
+        // Find the ToolUse content
+        let tool_use = request.messages.iter().find_map(|msg| {
+            msg.content.iter().find_map(|content| {
+                if let Content::ToolUse { id, .. } = content {
+                    Some(id.clone())
+                } else {
+                    None
+                }
+            })
+        });
+
+        assert_eq!(tool_use, Some("call_123_________".to_string()));
+    }
+
+    #[test]
+    fn test_sanitizes_tool_result_id_with_invalid_chars() {
+        let fixture = Context::default().messages(vec![
+            ContextMessage::tool_result(
+                ToolResult::new("test_tool")
+                    .call_id(ToolCallId::new("toolu_01!@#$ABC123"))
+                    .success("result"),
+            )
+            .into(),
+        ]);
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = SanitizeToolIds.transform(request);
+
+        // Find the ToolResult content
+        let tool_result_id = request.messages.iter().find_map(|msg| {
+            msg.content.iter().find_map(|content| {
+                if let Content::ToolResult { tool_use_id, .. } = content {
+                    Some(tool_use_id.clone())
+                } else {
+                    None
+                }
+            })
+        });
+
+        assert_eq!(tool_result_id, Some("toolu_01____ABC123".to_string()));
+    }
+
+    #[test]
+    fn test_leaves_valid_tool_ids_unchanged() {
+        let fixture = Context::default().messages(vec![
+            ContextMessage::Text(
+                TextMessage::new(Role::User, "test")
+                    .tool_calls(vec![
+                        ToolCallFull::new("test_tool")
+                            .call_id("call_abc-123_XYZ")
+                            .arguments(ToolCallArguments::from_json("{}")),
+                    ])
+                    .model(ModelId::new("claude-3-5-sonnet-20241022")),
+            )
+            .into(),
+        ]);
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = SanitizeToolIds.transform(request);
+
+        // Find the ToolUse content
+        let tool_use = request.messages.iter().find_map(|msg| {
+            msg.content.iter().find_map(|content| {
+                if let Content::ToolUse { id, .. } = content {
+                    Some(id.clone())
+                } else {
+                    None
+                }
+            })
+        });
+
+        assert_eq!(tool_use, Some("call_abc-123_XYZ".to_string()));
+    }
+
+    #[test]
+    fn test_handles_multiple_tool_calls_and_results() {
+        let fixture = Context::default().messages(vec![
+            ContextMessage::Text(
+                TextMessage::new(Role::User, "test")
+                    .tool_calls(vec![
+                        ToolCallFull::new("tool1")
+                            .call_id("call_1@#$")
+                            .arguments(ToolCallArguments::from_json("{}")),
+                        ToolCallFull::new("tool2")
+                            .call_id("call_2!@#")
+                            .arguments(ToolCallArguments::from_json("{}")),
+                    ])
+                    .model(ModelId::new("claude-3-5-sonnet-20241022")),
+            )
+            .into(),
+            ContextMessage::tool_result(
+                ToolResult::new("tool1")
+                    .call_id(ToolCallId::new("call_1@#$"))
+                    .success("result1"),
+            )
+            .into(),
+            ContextMessage::tool_result(
+                ToolResult::new("tool2")
+                    .call_id(ToolCallId::new("call_2!@#"))
+                    .success("result2"),
+            )
+            .into(),
+        ]);
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = SanitizeToolIds.transform(request);
+
+        // Collect all tool use IDs
+        let mut tool_use_ids = Vec::new();
+        let mut tool_result_ids = Vec::new();
+
+        for msg in &request.messages {
+            for content in &msg.content {
+                match content {
+                    Content::ToolUse { id, .. } => tool_use_ids.push(id.clone()),
+                    Content::ToolResult { tool_use_id, .. } => {
+                        tool_result_ids.push(tool_use_id.clone())
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        assert_eq!(tool_use_ids, vec!["call_1___", "call_2___"]);
+        assert_eq!(tool_result_ids, vec!["call_1___", "call_2___"]);
+    }
+
+    #[test]
+    fn test_handles_empty_messages() {
+        let fixture = Context::default().messages(vec![
+            ContextMessage::Text(
+                TextMessage::new(Role::User, "test")
+                    .model(ModelId::new("claude-3-5-sonnet-20241022")),
+            )
+            .into(),
+        ]);
+
+        let mut request = Request::try_from(fixture).unwrap();
+        request = SanitizeToolIds.transform(request);
+
+        // Should not panic and should preserve the message
+        assert_eq!(request.messages.len(), 1);
+    }
+}

crates/forge_app/src/dto/anthropic/transforms/set_cache.rs

@@ -0,0 +1,267 @@
+use forge_domain::Transformer;
+
+use crate::dto::anthropic::Request;
+
+/// Transformer that keeps Anthropic prompt-cache markers stable:
+/// - Always caches every system message so the static system prefix remains
+///   reusable
+/// - Falls back to caching the first conversation message when there is no
+///   system prompt so single-turn requests still establish a reusable prefix
+/// - Uses exactly one rolling message-level marker on the newest message
+pub struct SetCache;
+
+impl Transformer for SetCache {
+    type Value = Request;
+
+    /// Applies the default Anthropic cache strategy:
+    /// 1. Cache every system message when present, otherwise cache the first
+    ///    conversation message.
+    /// 2. Cache only the last message as the rolling message-level marker.
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        let len = request.get_messages().len();
+        let sys_len = request.system.as_ref().map_or(0, |msgs| msgs.len());
+
+        if len == 0 && sys_len == 0 {
+            return request;
+        }
+
+        let has_system_prompt = request
+            .system
+            .as_ref()
+            .is_some_and(|messages| !messages.is_empty());
+
+        if let Some(system_messages) = request.system.as_mut() {
+            for message in system_messages.iter_mut() {
+                *message = std::mem::take(message).cached(true);
+            }
+        }
+
+        for message in request.get_messages_mut().iter_mut() {
+            *message = std::mem::take(message).cached(false);
+        }
+
+        if !has_system_prompt
+            && len > 0
+            && let Some(first_message) = request.get_messages_mut().first_mut()
+        {
+            *first_message = std::mem::take(first_message).cached(true);
+        }
+
+        if let Some(message) = request.get_messages_mut().last_mut() {
+            *message = std::mem::take(message).cached(true);
+        }
+
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use forge_domain::{Context, ContextMessage, ModelId, Role, TextMessage};
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    fn create_test_context_with_system(
+        system_messages: &str,
+        conversation_messages: &str,
+    ) -> String {
+        let mut messages = Vec::new();
+
+        // Add system messages to the regular messages array for Anthropic format
+        for c in system_messages.chars() {
+            match c {
+                's' => messages.push(
+                    ContextMessage::Text(TextMessage::new(Role::System, c.to_string())).into(),
+                ),
+                _ => panic!("Invalid character in system message: {}", c),
+            }
+        }
+
+        // Add conversation messages
+        for c in conversation_messages.chars() {
+            match c {
+                'u' => messages.push(
+                    ContextMessage::Text(
+                        TextMessage::new(Role::User, c.to_string())
+                            .model(ModelId::new("claude-3-5-sonnet-20241022")),
+                    )
+                    .into(),
+                ),
+                'a' => messages.push(
+                    ContextMessage::Text(TextMessage::new(Role::Assistant, c.to_string())).into(),
+                ),
+                _ => panic!("Invalid character in conversation message: {}", c),
+            }
+        }
+
+        let context = Context {
+            conversation_id: None,
+            messages,
+            tools: vec![],
+            tool_choice: None,
+            max_tokens: None,
+            temperature: None,
+            top_p: None,
+            top_k: None,
+            reasoning: None,
+            stream: None,
+            response_format: None,
+            initiator: None,
+        };
+
+        let request = Request::try_from(context).expect("Failed to convert context to request");
+        let mut transformer = SetCache;
+        let request = transformer.transform(request);
+
+        let mut output = String::new();
+
+        // Check if first system message is cached
+        let system_cached = request
+            .system
+            .as_ref()
+            .and_then(|sys| sys.first())
+            .map(|msg| msg.is_cached())
+            .unwrap_or(false);
+
+        if system_cached {
+            output.push('[');
+        }
+        output.push_str(system_messages);
+
+        // Check which regular messages are cached
+        let cached_indices = request
+            .get_messages()
+            .iter()
+            .enumerate()
+            .filter(|(_, m)| m.is_cached())
+            .map(|(i, _)| i)
+            .collect::<HashSet<usize>>();
+
+        for (i, c) in conversation_messages.chars().enumerate() {
+            if cached_indices.contains(&i) {
+                output.push('[');
+            }
+            output.push(c);
+        }
+
+        output
+    }
+
+    fn create_test_context(message: impl ToString) -> String {
+        create_test_context_with_system("", &message.to_string())
+    }
+
+    #[test]
+    fn test_single_message() {
+        let actual = create_test_context("u");
+        let expected = "[u";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_two_messages() {
+        let actual = create_test_context("ua");
+        let expected = "[u[a";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_three_messages_cache_first_and_last_only() {
+        let actual = create_test_context("uau");
+        let expected = "[ua[u";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_four_messages_cache_first_and_last_only() {
+        let actual = create_test_context("uaua");
+        let expected = "[uau[a";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_five_messages_cache_first_and_last_only() {
+        let actual = create_test_context("uauau");
+        let expected = "[uaua[u";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_longer_conversation_caches_first_and_last_only() {
+        let actual = create_test_context("uauauauaua");
+        let expected = "[uauauauau[a";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_with_system_message_single_conversation_message() {
+        let actual = create_test_context_with_system("s", "u");
+        let expected = "[s[u";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_with_system_message_multiple_conversation_messages() {
+        let actual = create_test_context_with_system("ss", "uaua");
+        let expected = "[ssuau[a";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_with_system_message_long_conversation() {
+        let actual = create_test_context_with_system("s", "uauauauaua");
+        let expected = "[suauauauau[a";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_only_system_message() {
+        let actual = create_test_context_with_system("s", "");
+        let expected = "[s";
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_multiple_system_messages_all_cached() {
+        let fixture = Context {
+            conversation_id: None,
+            messages: vec![
+                ContextMessage::Text(TextMessage::new(Role::System, "first")).into(),
+                ContextMessage::Text(TextMessage::new(Role::System, "second")).into(),
+                ContextMessage::Text(
+                    TextMessage::new(Role::User, "user")
+                        .model(ModelId::new("claude-3-5-sonnet-20241022")),
+                )
+                .into(),
+            ],
+            tools: vec![],
+            tool_choice: None,
+            max_tokens: None,
+            temperature: None,
+            top_p: None,
+            top_k: None,
+            reasoning: None,
+            stream: None,
+            response_format: None,
+            initiator: None,
+        };
+
+        let request = Request::try_from(fixture).expect("Failed to convert context to request");
+        let mut transformer = SetCache;
+        let request = transformer.transform(request);
+
+        let expected = vec![true, true];
+        let actual = request
+            .system
+            .as_ref()
+            .unwrap()
+            .iter()
+            .map(|message| message.is_cached())
+            .collect::<Vec<_>>();
+        assert_eq!(actual, expected);
+        assert!(request.get_messages()[0].is_cached());
+    }
+}

crates/forge_app/src/dto/google/mod.rs

@@ -0,0 +1,5 @@
+mod request;
+mod response;
+
+pub use request::Request;
+pub use response::{EventData, Model, Response};

crates/forge_app/src/dto/google/request.rs

@@ -0,0 +1,982 @@
+use derive_setters::Setters;
+use forge_domain::{Context, ContextMessage};
+use serde::Serialize;
+
+#[derive(Serialize, Default, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct Request {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system_instruction: Option<Content>,
+    pub contents: Vec<Content>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub generation_config: Option<GenerationConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<Tool>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_config: Option<ToolConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub safety_settings: Option<Vec<SafetySetting>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cached_content: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub labels: Option<serde_json::Value>,
+}
+
+#[derive(Serialize, Default, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct GenerationConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking_config: Option<ThinkingConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop_sequences: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_k: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_mime_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_schema: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_output_tokens: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub frequency_penalty: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub presence_penalty: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub seed: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_modalities: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub audio_timestamp: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub media_resolution: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub image_config: Option<serde_json::Value>,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct ThinkingConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking_level: Option<Level>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking_budget: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub include_thoughts: Option<bool>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Level {
+    Minimal,
+    Low,
+    Medium,
+    High,
+}
+
+#[derive(Serialize)]
+pub struct Content {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub role: Option<Role>,
+    pub parts: Vec<Part>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum Part {
+    Text {
+        text: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        thought: Option<bool>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        thought_signature: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+    Image {
+        inline_data: ImageSource,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+    FunctionCall {
+        function_call: FunctionCallData,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        thought_signature: Option<String>,
+    },
+    FunctionResponse {
+        function_response: FunctionResponseData,
+    },
+    FileData {
+        file_data: FileDataInfo,
+    },
+}
+
+#[derive(Serialize)]
+pub struct ImageSource {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mime_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionCallData {
+    pub name: String,
+    pub args: serde_json::Value,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionResponseData {
+    pub name: String,
+    pub response: serde_json::Value,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FileDataInfo {
+    pub mime_type: String,
+    pub file_uri: String,
+}
+
+#[derive(Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum CacheControl {
+    Ephemeral,
+}
+
+#[derive(Serialize, Debug, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum Role {
+    User,
+    Model,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum Tool {
+    FunctionDeclarations {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        function_declarations: Option<Vec<FunctionDeclaration>>,
+    },
+    GoogleSearch {
+        google_search: GoogleSearchTool,
+    },
+    GoogleSearchRetrieval {
+        google_search_retrieval: GoogleSearchRetrievalTool,
+    },
+    EnterpriseWebSearch {
+        enterprise_web_search: serde_json::Value,
+    },
+    UrlContext {
+        url_context: serde_json::Value,
+    },
+    CodeExecution {
+        code_execution: serde_json::Value,
+    },
+    FileSearch {
+        file_search: FileSearchTool,
+    },
+    GoogleMaps {
+        google_maps: serde_json::Value,
+    },
+    Retrieval {
+        retrieval: RetrievalTool,
+    },
+}
+
+#[derive(Serialize, Default, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct GoogleSearchTool {
+    // Empty object for Gemini 2.0+
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct GoogleSearchRetrievalTool {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dynamic_retrieval_config: Option<DynamicRetrievalConfig>,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct DynamicRetrievalConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mode: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dynamic_threshold: Option<f64>,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct FileSearchTool {
+    pub file_search_store_names: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_k: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata_filter: Option<String>,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct RetrievalTool {
+    pub vertex_rag_store: VertexRagStore,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct VertexRagStore {
+    pub rag_resources: RagResources,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub similarity_top_k: Option<i32>,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct RagResources {
+    pub rag_corpus: String,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionDeclaration {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub parameters: serde_json::Value,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub function_calling_config: Option<FunctionCallingConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retrieval_config: Option<serde_json::Value>,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionCallingConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mode: Option<FunctionCallingMode>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub allowed_function_names: Option<Vec<String>>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum FunctionCallingMode {
+    ModeUnspecified,
+    Auto,
+    Any,
+    None,
+}
+
+#[derive(Serialize, Setters)]
+#[setters(into, strip_option)]
+#[serde(rename_all = "camelCase")]
+pub struct SafetySetting {
+    pub category: String,
+    pub threshold: String,
+}
+
+impl From<Context> for Request {
+    fn from(context: Context) -> Self {
+        // Extract system instruction from ALL system messages
+        let system_parts: Vec<Part> = context
+            .messages
+            .iter()
+            .filter(|msg| msg.has_role(forge_domain::Role::System))
+            .filter_map(|msg| {
+                msg.content().map(|content| Part::Text {
+                    text: content.to_string(),
+                    thought: None,
+                    thought_signature: None,
+                    cache_control: None,
+                })
+            })
+            .collect();
+
+        let system_instruction = if !system_parts.is_empty() {
+            Some(Content { role: None, parts: system_parts })
+        } else {
+            None
+        };
+
+        // Convert messages (excluding system messages)
+        // Group consecutive tool results into single Content objects to match Google's
+        // API requirements
+        let mut contents: Vec<Content> = Vec::new();
+        let mut pending_tool_parts: Vec<Part> = Vec::new();
+
+        for msg in context
+            .messages
+            .into_iter()
+            .filter(|msg| !msg.has_role(forge_domain::Role::System))
+        {
+            match msg.message {
+                ContextMessage::Tool(tool_result) => {
+                    // Collect tool result parts to be grouped together
+                    pending_tool_parts.push(Part::from(tool_result));
+                }
+                other => {
+                    // Flush any pending tool results first
+                    if !pending_tool_parts.is_empty() {
+                        contents.push(Content {
+                            role: Some(Role::User),
+                            parts: std::mem::take(&mut pending_tool_parts),
+                        });
+                    }
+
+                    // Add the current non-tool message
+                    let content = Content::from(other);
+                    if !content.parts.is_empty() {
+                        contents.push(content);
+                    }
+                }
+            }
+        }
+
+        // Flush any remaining tool results
+        if !pending_tool_parts.is_empty() {
+            contents.push(Content { role: Some(Role::User), parts: pending_tool_parts });
+        }
+
+        // Convert tools
+        let tools = if !context.tools.is_empty() {
+            Some(vec![Tool::FunctionDeclarations {
+                function_declarations: Some(
+                    context
+                        .tools
+                        .into_iter()
+                        .map(FunctionDeclaration::from)
+                        .collect(),
+                ),
+            }])
+        } else {
+            None
+        };
+
+        // Build generation config
+        let generation_config = Some(GenerationConfig {
+            max_output_tokens: context.max_tokens.map(|t| t as i32),
+            temperature: context.temperature.map(|t| t.value() as f64),
+            top_p: context.top_p.map(|t| t.value() as f64),
+            top_k: context.top_k.map(|t| t.value() as i32),
+            response_mime_type: context.response_format.as_ref().and_then(|rf| match rf {
+                forge_domain::ResponseFormat::JsonSchema(_) => Some("application/json".to_string()),
+                _ => None,
+            }),
+            response_schema: context.response_format.and_then(|rf| match rf {
+                forge_domain::ResponseFormat::JsonSchema(schema) => {
+                    let mut schema_value = serde_json::to_value(*schema).ok()?;
+                    // Sanitize schema for Gemini API compatibility
+                    crate::utils::sanitize_gemini_schema(&mut schema_value);
+                    Some(schema_value)
+                }
+                _ => None,
+            }),
+            thinking_config: context.reasoning.and_then(|reasoning| {
+                reasoning.enabled.and_then(|enabled| {
+                    if enabled {
+                        Some(ThinkingConfig {
+                            thinking_level: None,
+                            thinking_budget: reasoning.max_tokens.map(|t| t as i32),
+                            include_thoughts: Some(true),
+                        })
+                    } else {
+                        None
+                    }
+                })
+            }),
+            ..Default::default()
+        });
+
+        // Build tool config for tool choice
+        // Only set tool_config if there's an explicit tool choice
+        let tool_config = context.tool_choice.map(ToolConfig::from);
+
+        Request {
+            system_instruction,
+            contents,
+            generation_config,
+            tools,
+            tool_config,
+            safety_settings: None,
+            cached_content: None,
+            labels: None,
+        }
+    }
+}
+
+impl From<forge_domain::ToolChoice> for ToolConfig {
+    fn from(choice: forge_domain::ToolChoice) -> Self {
+        let (mode, allowed_function_names) = match choice {
+            forge_domain::ToolChoice::Auto => (FunctionCallingMode::Auto, None),
+            forge_domain::ToolChoice::None => (FunctionCallingMode::None, None),
+            forge_domain::ToolChoice::Required => (FunctionCallingMode::Any, None),
+            forge_domain::ToolChoice::Call(name) => {
+                (FunctionCallingMode::Any, Some(vec![name.to_string()]))
+            }
+        };
+
+        ToolConfig {
+            function_calling_config: Some(FunctionCallingConfig {
+                mode: Some(mode),
+                allowed_function_names,
+            }),
+            retrieval_config: None,
+        }
+    }
+}
+
+impl From<forge_domain::ToolDefinition> for FunctionDeclaration {
+    fn from(tool: forge_domain::ToolDefinition) -> Self {
+        let mut parameters =
+            serde_json::to_value(tool.input_schema).unwrap_or(serde_json::json!({}));
+
+        // Sanitize schema for Gemini API compatibility (strips $schema,
+        // removes additionalProperties, converts integer enums, ensures
+        // arrays have items, removes properties from non-objects, etc.)
+        crate::utils::sanitize_gemini_schema(&mut parameters);
+
+        FunctionDeclaration {
+            name: tool.name.to_string(),
+            description: Some(tool.description),
+            parameters,
+        }
+    }
+}
+
+impl From<ContextMessage> for Content {
+    fn from(message: ContextMessage) -> Self {
+        match message {
+            ContextMessage::Text(text_message) => Content::from(text_message),
+            ContextMessage::Tool(tool_result) => Content::from(tool_result),
+            ContextMessage::Image(image) => Content::from(image),
+        }
+    }
+}
+
+impl From<forge_domain::TextMessage> for Content {
+    fn from(text_message: forge_domain::TextMessage) -> Self {
+        let role = match text_message.role {
+            forge_domain::Role::User => Some(Role::User),
+            forge_domain::Role::Assistant => Some(Role::Model),
+            forge_domain::Role::System => None, // System messages are handled separately
+        };
+
+        let mut parts = Vec::new();
+
+        // Add text part if content is not empty
+        if !text_message.content.is_empty() {
+            parts.push(Part::Text {
+                text: text_message.content,
+                thought: None,
+                thought_signature: text_message.thought_signature.clone(),
+                cache_control: None,
+            });
+        }
+
+        // Add function calls if present
+        if let Some(tool_calls) = text_message.tool_calls {
+            parts.extend(tool_calls.into_iter().map(Part::from));
+        }
+
+        Content { role, parts }
+    }
+}
+
+impl From<forge_domain::ToolResult> for Content {
+    fn from(tool_result: forge_domain::ToolResult) -> Self {
+        Content {
+            role: Some(Role::User), // Tool results come back as user messages in Google's API
+            parts: vec![Part::from(tool_result)],
+        }
+    }
+}
+
+impl From<forge_domain::Image> for Content {
+    fn from(image: forge_domain::Image) -> Self {
+        Content { role: Some(Role::User), parts: vec![Part::from(image)] }
+    }
+}
+
+impl From<forge_domain::ToolCallFull> for Part {
+    fn from(tool_call: forge_domain::ToolCallFull) -> Self {
+        Part::FunctionCall {
+            function_call: FunctionCallData {
+                name: tool_call.name.to_string(),
+                args: tool_call.arguments.parse().unwrap_or(serde_json::json!({})),
+            },
+            thought_signature: tool_call.thought_signature,
+        }
+    }
+}
+
+impl From<forge_domain::ToolResult> for Part {
+    fn from(tool_result: forge_domain::ToolResult) -> Self {
+        Part::FunctionResponse {
+            function_response: FunctionResponseData {
+                name: tool_result.name.to_string(),
+                response: serde_json::to_value(&tool_result.output)
+                    .unwrap_or(serde_json::json!({})),
+            },
+        }
+    }
+}
+
+impl From<forge_domain::Image> for Part {
+    fn from(image: forge_domain::Image) -> Self {
+        Part::Image {
+            inline_data: ImageSource {
+                mime_type: Some(image.mime_type().to_string()),
+                data: Some(image.data().to_string()),
+            },
+            cache_control: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{ToolCallArguments, ToolCallFull, ToolCallId, ToolName, ToolResult};
+
+    use super::*;
+
+    #[test]
+    fn test_tool_call_args_serialization() {
+        // Create a ToolCallFull with Unparsed JSON arguments (as it would come from
+        // API)
+        let tool_call = ToolCallFull {
+            name: ToolName::new("patch"),
+            call_id: None,
+            arguments: ToolCallArguments::from_json(
+                r#"{"file_path":"test.rs","old_string":"foo","new_string":"bar"}"#,
+            ),
+            thought_signature: None,
+        };
+
+        // Convert to Google Part
+        let part = Part::from(tool_call);
+
+        // Verify it serializes correctly
+        let serialized = serde_json::to_value(&part).unwrap();
+
+        // The Part enum serializes using snake_case for the variant name
+        if let Some(function_call) = serialized.get("function_call") {
+            if let Some(args) = function_call.get("args") {
+                // Args should be a proper JSON object, not a string
+                assert!(
+                    args.is_object(),
+                    "Args should be deserialized as JSON object, not string: {:?}",
+                    args
+                );
+
+                // Verify fields are accessible
+                assert_eq!(args["file_path"], "test.rs");
+                assert_eq!(args["old_string"], "foo");
+                assert_eq!(args["new_string"], "bar");
+            } else {
+                panic!("Expected function_call.args to exist");
+            }
+        } else {
+            panic!("Expected function_call variant");
+        }
+    }
+
+    #[test]
+    fn test_multiple_tool_calls_serialization() {
+        // Simulate multiple tool calls with different args
+        let tool_calls = vec![
+            ToolCallFull {
+                name: ToolName::new("remove"),
+                call_id: None,
+                arguments: ToolCallArguments::from_json(r#"{"path":"file1.rs"}"#),
+                thought_signature: None,
+            },
+            ToolCallFull {
+                name: ToolName::new("remove"),
+                call_id: None,
+                arguments: ToolCallArguments::from_json(r#"{"path":"file2.rs"}"#),
+                thought_signature: None,
+            },
+        ];
+
+        // Convert each to Part and serialize
+        for (i, tool_call) in tool_calls.into_iter().enumerate() {
+            let part = Part::from(tool_call);
+            let serialized = serde_json::to_value(&part).unwrap();
+
+            if let Some(function_call) = serialized.get("function_call") {
+                if let Some(args) = function_call.get("args") {
+                    assert!(
+                        args.is_object(),
+                        "Tool call {} args should be object, got: {:?}",
+                        i,
+                        args
+                    );
+                    let expected_path = format!("file{}.rs", i + 1);
+                    assert_eq!(args["path"], expected_path, "Tool call {} path mismatch", i);
+                } else {
+                    panic!("Expected function_call.args for tool call {}", i);
+                }
+            } else {
+                panic!("Expected function_call variant for tool call {}", i);
+            }
+        }
+    }
+
+    #[test]
+    fn test_consecutive_tool_results_grouped() {
+        use forge_domain::{Context, ContextMessage, ModelId};
+
+        // Create a context with multiple consecutive tool results (simulating 13 read
+        // calls)
+        let mut context = Context::default();
+
+        // Add initial user message
+        context = context.add_message(ContextMessage::user(
+            "Read these files",
+            Some(ModelId::new("test")),
+        ));
+
+        // Add assistant message with tool calls
+        context = context.add_message(ContextMessage::assistant("", None, None, None));
+
+        // Add 13 consecutive tool results (like in the dump)
+        for i in 1..=13 {
+            let tool_result = ToolResult::new("read")
+                .call_id(ToolCallId::new(format!("call_{}", i)))
+                .success(format!("Content of file {}", i));
+            context = context.add_message(ContextMessage::tool_result(tool_result));
+        }
+
+        // Convert to Google Request
+        let request = Request::from(context);
+
+        // Verify structure:
+        // 1. First content: user message
+        // 2. Second content: assistant message (might be empty and filtered out)
+        // 3. Third content: ALL 13 tool results grouped together
+
+        // Find the content with tool results
+        let tool_result_content = request
+            .contents
+            .iter()
+            .find(|c| {
+                c.parts
+                    .iter()
+                    .any(|p| matches!(p, Part::FunctionResponse { .. }))
+            })
+            .expect("Should have a content with function responses");
+
+        // Verify all 13 tool results are in ONE Content object
+        let function_response_count = tool_result_content
+            .parts
+            .iter()
+            .filter(|p| matches!(p, Part::FunctionResponse { .. }))
+            .count();
+
+        assert_eq!(
+            function_response_count, 13,
+            "All 13 tool results should be grouped into a single Content with 13 FunctionResponse parts"
+        );
+
+        // Verify the role is User
+        assert_eq!(
+            tool_result_content.role,
+            Some(Role::User),
+            "Tool results should have User role"
+        );
+    }
+
+    #[test]
+    fn test_non_consecutive_tool_results_not_grouped() {
+        use forge_domain::{Context, ContextMessage, ModelId};
+
+        // Create a context with tool results separated by other messages
+        let mut context = Context::default();
+
+        // User message
+        context = context.add_message(ContextMessage::user(
+            "First task",
+            Some(ModelId::new("test")),
+        ));
+
+        // Tool result #1
+        let tool_result_1 = ToolResult::new("read")
+            .call_id(ToolCallId::new("call_1"))
+            .success("Result 1");
+        context = context.add_message(ContextMessage::tool_result(tool_result_1));
+
+        // Assistant message (breaks the sequence)
+        context = context.add_message(ContextMessage::assistant(
+            "Let me do more",
+            None,
+            None,
+            None,
+        ));
+
+        // Tool result #2 (should be in a separate Content)
+        let tool_result_2 = ToolResult::new("read")
+            .call_id(ToolCallId::new("call_2"))
+            .success("Result 2");
+        context = context.add_message(ContextMessage::tool_result(tool_result_2));
+
+        // Convert to Google Request
+        let request = Request::from(context);
+
+        // Count how many Content objects have FunctionResponse parts
+        let contents_with_tool_results: Vec<_> = request
+            .contents
+            .iter()
+            .filter(|c| {
+                c.parts
+                    .iter()
+                    .any(|p| matches!(p, Part::FunctionResponse { .. }))
+            })
+            .collect();
+
+        // Should have 2 separate Content objects for the 2 non-consecutive tool results
+        assert_eq!(
+            contents_with_tool_results.len(),
+            2,
+            "Non-consecutive tool results should be in separate Content objects"
+        );
+
+        // Each should have exactly 1 FunctionResponse
+        for content in contents_with_tool_results {
+            let count = content
+                .parts
+                .iter()
+                .filter(|p| matches!(p, Part::FunctionResponse { .. }))
+                .count();
+            assert_eq!(
+                count, 1,
+                "Each separate tool result group should have 1 FunctionResponse"
+            );
+        }
+    }
+
+    #[test]
+    fn test_tool_choice_conversion() {
+        use forge_domain::ToolChoice;
+
+        // Test Auto
+        let config = ToolConfig::from(ToolChoice::Auto);
+        let fc_config = config.function_calling_config.unwrap();
+        assert!(matches!(fc_config.mode, Some(FunctionCallingMode::Auto)));
+        assert!(fc_config.allowed_function_names.is_none());
+
+        // Test None
+        let config = ToolConfig::from(ToolChoice::None);
+        let fc_config = config.function_calling_config.unwrap();
+        assert!(matches!(fc_config.mode, Some(FunctionCallingMode::None)));
+        assert!(fc_config.allowed_function_names.is_none());
+
+        // Test Required
+        let config = ToolConfig::from(ToolChoice::Required);
+        let fc_config = config.function_calling_config.unwrap();
+        assert!(matches!(fc_config.mode, Some(FunctionCallingMode::Any)));
+        assert!(fc_config.allowed_function_names.is_none());
+
+        // Test Call
+        let config = ToolConfig::from(ToolChoice::Call(ToolName::new("my_tool")));
+        let fc_config = config.function_calling_config.unwrap();
+        assert!(matches!(fc_config.mode, Some(FunctionCallingMode::Any)));
+        assert_eq!(fc_config.allowed_function_names.unwrap(), vec!["my_tool"]);
+    }
+
+    #[test]
+    fn test_tool_definition_conversion() {
+        use forge_domain::ToolDefinition;
+        use schemars::schema_for;
+
+        #[derive(schemars::JsonSchema)]
+        struct Args {
+            _arg1: String,
+        }
+
+        let tool_def = ToolDefinition {
+            name: ToolName::new("test_tool"),
+            description: "A test tool".to_string(),
+            input_schema: schema_for!(Args),
+        };
+
+        let decl = FunctionDeclaration::from(tool_def);
+
+        assert_eq!(decl.name, "test_tool");
+        assert_eq!(decl.description.unwrap(), "A test tool");
+
+        // Check Gemini schema sanitization
+        let params = decl.parameters;
+        assert!(params.is_object());
+        assert!(!params.as_object().unwrap().contains_key("$schema"));
+        assert!(params.as_object().unwrap().contains_key("type"));
+        // additionalProperties should be removed by Gemini sanitization
+        assert!(
+            !params
+                .as_object()
+                .unwrap()
+                .contains_key("additionalProperties")
+        );
+    }
+
+    #[test]
+    fn test_text_message_conversion() {
+        use forge_domain::{Role, TextMessage};
+
+        // User message
+        let msg = TextMessage::new(Role::User, "Hello");
+        let content = Content::from(msg);
+        assert_eq!(content.role, Some(self::Role::User));
+        assert_eq!(content.parts.len(), 1);
+        match &content.parts[0] {
+            Part::Text { text, .. } => assert_eq!(text, "Hello"),
+            _ => panic!("Expected Text part"),
+        }
+
+        // Assistant message with thought signature
+        let msg = TextMessage::assistant("Hi", None, None).thought_signature("sig");
+        let content = Content::from(msg);
+        assert_eq!(content.role, Some(self::Role::Model));
+        match &content.parts[0] {
+            Part::Text { text, thought_signature, .. } => {
+                assert_eq!(text, "Hi");
+                assert_eq!(thought_signature.as_deref(), Some("sig"));
+            }
+            _ => panic!("Expected Text part"),
+        }
+    }
+
+    #[test]
+    fn test_image_conversion() {
+        use forge_domain::Image;
+
+        let image = Image::new_base64("base64data".to_string(), "image/png");
+        let content = Content::from(image.clone());
+
+        assert_eq!(content.role, Some(self::Role::User));
+        assert_eq!(content.parts.len(), 1);
+
+        match &content.parts[0] {
+            Part::Image { inline_data, .. } => {
+                assert_eq!(inline_data.mime_type.as_deref(), Some("image/png"));
+                assert_eq!(inline_data.data.as_deref(), Some("base64data"));
+            }
+            _ => panic!("Expected Image part"),
+        }
+
+        // Test direct Part conversion
+        let part = Part::from(image);
+        match part {
+            Part::Image { inline_data, .. } => {
+                assert_eq!(inline_data.mime_type.as_deref(), Some("image/png"));
+                assert_eq!(inline_data.data.as_deref(), Some("base64data"));
+            }
+            _ => panic!("Expected Image part"),
+        }
+    }
+
+    #[test]
+    fn test_response_schema_strips_dollar_schema() {
+        use forge_domain::{Context, ResponseFormat};
+        use schemars::schema_for;
+
+        #[allow(dead_code)]
+        #[derive(schemars::JsonSchema)]
+        struct TestResponse {
+            result: String,
+        }
+
+        // Create a context with a JSON schema response format
+        let schema = schema_for!(TestResponse);
+        let context =
+            Context::default().response_format(ResponseFormat::JsonSchema(Box::new(schema)));
+
+        // Convert to Google Request
+        let request = Request::from(context);
+
+        // Verify generation_config has response_schema
+        let generation_config = request
+            .generation_config
+            .expect("Should have generation_config");
+        let response_schema = generation_config
+            .response_schema
+            .expect("Should have response_schema");
+
+        // Verify $schema field is removed
+        if let Some(obj) = response_schema.as_object() {
+            assert!(
+                !obj.contains_key("$schema"),
+                "$schema field should be removed from response_schema"
+            );
+
+            // Verify other schema properties are still present
+            assert!(
+                obj.contains_key("type")
+                    || obj.contains_key("properties")
+                    || obj.contains_key("title"),
+                "Schema should still contain other properties"
+            );
+
+            // Verify additionalProperties is also removed by Gemini sanitization
+            assert!(
+                !obj.contains_key("additionalProperties"),
+                "additionalProperties should be removed by Gemini sanitization"
+            );
+        } else {
+            panic!("response_schema should be an object");
+        }
+
+        // Verify response_mime_type is set to application/json
+        assert_eq!(
+            generation_config.response_mime_type,
+            Some("application/json".to_string()),
+            "response_mime_type should be set for JSON schema"
+        );
+    }
+
+    #[test]
+    fn test_tool_result_part_conversion() {
+        use forge_domain::{ToolCallId, ToolName, ToolResult};
+
+        let result = ToolResult::new(ToolName::new("test"))
+            .call_id(ToolCallId::new("call_1"))
+            .success("output");
+
+        let part = Part::from(result);
+
+        match part {
+            Part::FunctionResponse { function_response } => {
+                assert_eq!(function_response.name, "test");
+                // The response should be wrapped in a JSON value
+                let expected = serde_json::json!({
+                    "is_error": false,
+                    "values": [{"text": "output"}]
+                });
+                assert_eq!(function_response.response, expected);
+            }
+            _ => panic!("Expected FunctionResponse part"),
+        }
+    }
+}

crates/forge_app/src/dto/google/response.rs

@@ -0,0 +1,790 @@
+use forge_domain::{
+    ChatCompletionMessage, FinishReason, Reasoning, ReasoningPart, TokenCount, ToolCallId,
+    ToolCallPart, ToolName,
+};
+use serde::Deserialize;
+
+/// Model information from Google API
+#[derive(Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Model {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+
+impl From<Model> for forge_domain::Model {
+    fn from(value: Model) -> Self {
+        // Extract model ID from name (format: "models/gemini-2.0-flash")
+        let id = value
+            .name
+            .strip_prefix("models/")
+            .unwrap_or(&value.name)
+            .to_string();
+
+        // Determine context length based on model name
+        let context_length = if id.contains("gemini-2.0") || id.contains("gemini-1.5") {
+            2_000_000 // 2M tokens for Gemini 2.0 and 1.5
+        } else {
+            32_000 // Default for older models
+        };
+
+        forge_domain::Model {
+            id: forge_domain::ModelId::new(id),
+            name: Some(value.display_name.unwrap_or(value.name)),
+            description: value.description,
+            context_length: Some(context_length),
+            tools_supported: Some(true), // Google models support function calling
+            supports_parallel_tool_calls: Some(true),
+            supports_reasoning: Some(true), // Gemini 2.0+ supports thinking
+            input_modalities: vec![],       // Google supports text, images, audio, video
+        }
+    }
+}
+
+/// EventData for Google streaming responses
+/// Google returns chunks directly without event wrappers
+#[derive(Deserialize, PartialEq, Clone, Debug)]
+#[serde(untagged)]
+pub enum EventData {
+    Response(Response),
+    Error(ErrorResponse),
+    Ping(PingEvent),
+    Unknown(serde_json::Value),
+}
+
+/// Represents a value that may be either a JSON number or a numeric string,
+/// used for fields like `cost` that proxies sometimes encode as strings.
+#[derive(Deserialize, Debug, Clone, PartialEq, derive_more::TryInto)]
+#[serde(untagged)]
+pub enum StringOrF64 {
+    Number(f64),
+    String(String),
+}
+
+/// Heartbeat/cost event sent by some proxies (e.g. opencode.ai).
+///
+/// Example payload: `{"type":"ping","cost":"0.02889400"}`
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct PingEvent {
+    pub cost: StringOrF64,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct ErrorResponse {
+    pub error: ErrorContent,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct ErrorContent {
+    pub code: i32,
+    pub message: String,
+    pub status: String,
+}
+
+impl TryFrom<EventData> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+
+    fn try_from(value: EventData) -> Result<Self, Self::Error> {
+        match value {
+            EventData::Response(response) => ChatCompletionMessage::try_from(response),
+            EventData::Error(e) => Err(anyhow::anyhow!(
+                "Google API Error {}: {}",
+                e.error.code,
+                e.error.message
+            )),
+            EventData::Ping(ping) => {
+                // Extract cost from proxy ping events (e.g. opencode.ai)
+                let cost = match ping.cost {
+                    StringOrF64::Number(n) => n,
+                    StringOrF64::String(s) => s.parse().unwrap_or(0.0),
+                };
+                let usage = forge_domain::Usage { cost: Some(cost), ..Default::default() };
+                Ok(ChatCompletionMessage::assistant(forge_domain::Content::part("")).usage(usage))
+            }
+            EventData::Unknown(_) => {
+                // Silently ignore any other unrecognised events
+                Ok(ChatCompletionMessage::assistant(
+                    forge_domain::Content::part(""),
+                ))
+            }
+        }
+    }
+}
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Response {
+    pub candidates: Vec<Candidate>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_metadata: Option<UsageMetadata>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prompt_feedback: Option<PromptFeedback>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Candidate {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<Content>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub finish_reason: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub safety_ratings: Option<Vec<SafetyRating>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub grounding_metadata: Option<GroundingMetadata>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub url_context_metadata: Option<UrlContextMetadata>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct Content {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub role: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parts: Option<Vec<Part>>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(untagged)]
+pub enum Part {
+    FunctionCall {
+        #[serde(rename = "functionCall")]
+        function_call: FunctionCall,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        #[serde(rename = "thoughtSignature")]
+        thought_signature: Option<String>,
+    },
+    InlineData {
+        #[serde(rename = "inlineData")]
+        inline_data: InlineData,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        #[serde(rename = "thoughtSignature")]
+        thought_signature: Option<String>,
+    },
+    Text {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        text: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        thought: Option<bool>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        #[serde(rename = "thoughtSignature")]
+        thought_signature: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        #[serde(rename = "executableCode")]
+        executable_code: Option<ExecutableCode>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        #[serde(rename = "codeExecutionResult")]
+        code_execution_result: Option<CodeExecutionResult>,
+    },
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionCall {
+    pub name: String,
+    pub args: serde_json::Value,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct InlineData {
+    pub mime_type: String,
+    pub data: String,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct ExecutableCode {
+    pub language: String,
+    pub code: String,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct CodeExecutionResult {
+    pub outcome: String,
+    pub output: String,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct SafetyRating {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub category: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub probability: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub probability_score: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub severity: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub severity_score: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub blocked: Option<bool>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UsageMetadata {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cached_content_token_count: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thoughts_token_count: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prompt_token_count: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub candidates_token_count: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub total_token_count: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub traffic_type: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct PromptFeedback {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub block_reason: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub safety_ratings: Option<Vec<SafetyRating>>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct GroundingMetadata {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub web_search_queries: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retrieval_queries: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub search_entry_point: Option<SearchEntryPoint>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub grounding_chunks: Option<Vec<GroundingChunk>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub grounding_supports: Option<Vec<GroundingSupport>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retrieval_metadata: Option<serde_json::Value>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchEntryPoint {
+    pub rendered_content: String,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct GroundingChunk {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub web: Option<WebChunk>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retrieved_context: Option<RetrievedContext>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maps: Option<MapsChunk>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+pub struct WebChunk {
+    pub uri: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct RetrievedContext {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub file_search_store: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct MapsChunk {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub place_id: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct GroundingSupport {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub segment: Option<Segment>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "segment_text")]
+    pub segment_text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub grounding_chunk_indices: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub support_chunk_indices: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub confidence_scores: Option<Vec<f64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub confidence_score: Option<Vec<f64>>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Segment {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub start_index: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end_index: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UrlContextMetadata {
+    pub url_metadata: Vec<UrlMetadata>,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UrlMetadata {
+    pub retrieved_url: String,
+    pub url_retrieval_status: String,
+}
+
+impl From<UsageMetadata> for forge_domain::Usage {
+    fn from(usage: UsageMetadata) -> Self {
+        let prompt_tokens = usage.prompt_token_count.unwrap_or_default() as usize;
+        let completion_tokens = usage.candidates_token_count.unwrap_or_default() as usize;
+        let cached_tokens = usage.cached_content_token_count.unwrap_or_default() as usize;
+        let total_tokens = usage.total_token_count.unwrap_or_default() as usize;
+
+        forge_domain::Usage {
+            prompt_tokens: TokenCount::Actual(prompt_tokens),
+            completion_tokens: TokenCount::Actual(completion_tokens),
+            total_tokens: TokenCount::Actual(total_tokens),
+            cached_tokens: TokenCount::Actual(cached_tokens),
+            ..Default::default()
+        }
+    }
+}
+
+/// Converts Google's finish reason strings to domain FinishReason
+fn parse_finish_reason(reason: &str) -> Option<FinishReason> {
+    match reason {
+        "STOP" => Some(FinishReason::Stop),
+        "MAX_TOKENS" => Some(FinishReason::Length),
+        "SAFETY" | "RECITATION" => Some(FinishReason::ContentFilter),
+        _ => Some(FinishReason::Stop), // Default to Stop for unknown reasons
+    }
+}
+
+impl TryFrom<Part> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+
+    fn try_from(part: Part) -> Result<Self, Self::Error> {
+        match part {
+            Part::Text {
+                text,
+                thought,
+                thought_signature,
+                executable_code: _,
+                code_execution_result: _,
+            } => {
+                let text_content = text.unwrap_or_default();
+                let is_thought = thought.unwrap_or(false);
+
+                if is_thought {
+                    // This is a thinking/reasoning part
+                    let mut msg = ChatCompletionMessage::assistant(forge_domain::Content::part(""))
+                        .reasoning(forge_domain::Content::part(text_content.clone()))
+                        .add_reasoning_detail(Reasoning::Part(vec![
+                            ReasoningPart::default()
+                                .text(Some(text_content))
+                                .signature(thought_signature.clone()),
+                        ]));
+
+                    if let Some(signature) = thought_signature {
+                        msg = msg.thought_signature(signature);
+                    }
+
+                    Ok(msg)
+                } else {
+                    // Regular text content
+                    let mut msg =
+                        ChatCompletionMessage::assistant(forge_domain::Content::part(text_content));
+                    if let Some(signature) = thought_signature {
+                        msg = msg.thought_signature(signature);
+                    }
+                    Ok(msg)
+                }
+            }
+            Part::FunctionCall { function_call, thought_signature } => Ok(
+                ChatCompletionMessage::assistant(forge_domain::Content::part("")).add_tool_call(
+                    ToolCallPart {
+                        call_id: Some(ToolCallId::generate()),
+                        name: Some(ToolName::new(function_call.name)),
+                        arguments_part: serde_json::to_string(&function_call.args)?,
+                        thought_signature,
+                    },
+                ),
+            ),
+            Part::InlineData { .. } => {
+                // For now, skip inline data in responses (it's typically for inputs)
+                Ok(ChatCompletionMessage::assistant(
+                    forge_domain::Content::part(""),
+                ))
+            }
+        }
+    }
+}
+
+impl TryFrom<Candidate> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+
+    fn try_from(candidate: Candidate) -> Result<Self, Self::Error> {
+        let mut content_parts: Vec<String> = Vec::new();
+        let mut reasoning_parts: Vec<String> = Vec::new();
+        let mut tool_calls: Vec<forge_domain::ToolCall> = Vec::new();
+        let mut reasoning_details: Option<Vec<forge_domain::Reasoning>> = None;
+        let mut thought_signature: Option<String> = None;
+        let mut finish_reason: Option<FinishReason> = None;
+
+        // Add finish reason if present
+        if let Some(ref reason) = candidate.finish_reason {
+            finish_reason = parse_finish_reason(reason);
+        }
+
+        // Process content parts
+        if let Some(content) = candidate.content
+            && let Some(parts) = content.parts
+        {
+            for part in parts {
+                let part_message = ChatCompletionMessage::try_from(part)?;
+
+                // Collect content text
+                if let Some(part_content) = part_message.content {
+                    let text = part_content.as_str();
+                    if !text.is_empty() {
+                        content_parts.push(text.to_string());
+                    }
+                }
+
+                // Collect reasoning text
+                if let Some(part_reasoning) = part_message.reasoning {
+                    let text = part_reasoning.as_str();
+                    if !text.is_empty() {
+                        reasoning_parts.push(text.to_string());
+                    }
+                }
+
+                // Collect reasoning details (accumulate)
+                if let Some(details) = part_message.reasoning_details {
+                    if let Some(ref mut current) = reasoning_details {
+                        current.extend(details);
+                    } else {
+                        reasoning_details = Some(details);
+                    }
+                }
+
+                // Collect tool calls
+                tool_calls.extend(part_message.tool_calls);
+
+                // Take thought signature (last one wins)
+                if part_message.thought_signature.is_some() {
+                    thought_signature = part_message.thought_signature;
+                }
+            }
+        }
+
+        // Build the final message
+        let content = content_parts.join("");
+        let mut message = ChatCompletionMessage::assistant(forge_domain::Content::part(content));
+
+        if let Some(finish) = finish_reason {
+            message = message.finish_reason(finish);
+        }
+
+        if !reasoning_parts.is_empty() {
+            message = message.reasoning(forge_domain::Content::part(reasoning_parts.join("")));
+        }
+
+        if let Some(details) = reasoning_details {
+            message.reasoning_details = Some(details);
+        }
+
+        if !tool_calls.is_empty() {
+            message.tool_calls = tool_calls;
+        }
+
+        if let Some(signature) = thought_signature {
+            message = message.thought_signature(signature);
+        }
+
+        Ok(message)
+    }
+}
+
+impl TryFrom<Response> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+
+    fn try_from(response: Response) -> Result<Self, Self::Error> {
+        // Get the first candidate
+        if let Some(candidate) = response.candidates.into_iter().next() {
+            let mut message = ChatCompletionMessage::try_from(candidate)?;
+
+            // Add usage metadata if present
+            if let Some(usage) = response.usage_metadata {
+                message.usage = Some(usage.into());
+            }
+
+            Ok(message)
+        } else {
+            // No candidates - return empty message
+            let mut message = ChatCompletionMessage::assistant(forge_domain::Content::part(""));
+
+            // Still add usage if present
+            if let Some(usage) = response.usage_metadata {
+                message.usage = Some(usage.into());
+            }
+
+            Ok(message)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn test_chat_completion_message_from_part_function_call_generates_id() {
+        let function_call =
+            FunctionCall { name: "test_tool".to_string(), args: json!({"arg": "value"}) };
+
+        let part = Part::FunctionCall { function_call, thought_signature: None };
+
+        let message = ChatCompletionMessage::try_from(part).unwrap();
+
+        assert!(!message.tool_calls.is_empty());
+        let tool_calls = message.tool_calls;
+        assert_eq!(tool_calls.len(), 1);
+
+        let tool_call = &tool_calls[0];
+        match tool_call {
+            forge_domain::ToolCall::Part(part) => {
+                assert!(part.call_id.is_some());
+                let call_id = part.call_id.as_ref().unwrap();
+                assert!(call_id.as_str().starts_with("forge_call_id_"));
+            }
+            _ => panic!("Expected ToolCall::Part"),
+        }
+    }
+
+    #[test]
+    fn test_model_conversion() {
+        let model = Model {
+            name: "models/gemini-pro".to_string(),
+            display_name: Some("Gemini Pro".to_string()),
+            description: Some("A model".to_string()),
+        };
+        let domain_model: forge_domain::Model = model.into();
+        assert_eq!(domain_model.id.as_str(), "gemini-pro");
+        assert_eq!(domain_model.name.unwrap(), "Gemini Pro");
+        assert_eq!(domain_model.context_length.unwrap(), 32_000);
+
+        let model_v2 = Model {
+            name: "models/gemini-2.0-flash".to_string(),
+            display_name: None,
+            description: None,
+        };
+        let domain_model_v2: forge_domain::Model = model_v2.clone().into();
+        assert_eq!(domain_model_v2.id.as_str(), "gemini-2.0-flash");
+        assert_eq!(domain_model_v2.name.unwrap(), "models/gemini-2.0-flash");
+        assert_eq!(domain_model_v2.context_length.unwrap(), 2_000_000);
+    }
+
+    #[test]
+    fn test_ping_event_extracts_cost() {
+        let fixture = json!({"type": "ping", "cost": "0.02889400"});
+        let event_data: EventData = serde_json::from_value(fixture).unwrap();
+        assert!(matches!(event_data, EventData::Ping(_)));
+
+        let actual = ChatCompletionMessage::try_from(event_data).unwrap();
+        let expected = ChatCompletionMessage::assistant(forge_domain::Content::part(""))
+            .usage(forge_domain::Usage { cost: Some(0.028894), ..Default::default() });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_ping_event_with_numeric_cost() {
+        let fixture = json!({"type": "ping", "cost": 0.05});
+        let event_data: EventData = serde_json::from_value(fixture).unwrap();
+        assert!(matches!(event_data, EventData::Ping(_)));
+
+        let actual = ChatCompletionMessage::try_from(event_data).unwrap();
+        assert_eq!(actual.usage.unwrap().cost, Some(0.05));
+    }
+
+    #[test]
+    fn test_unknown_event_returns_empty_message() {
+        let fixture = json!({"type": "something_else", "data": 123});
+        let event_data: EventData = serde_json::from_value(fixture).unwrap();
+        assert!(matches!(event_data, EventData::Unknown(_)));
+
+        let actual = ChatCompletionMessage::try_from(event_data).unwrap();
+        let expected = ChatCompletionMessage::assistant(forge_domain::Content::part(""));
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_event_data_parsing() {
+        let response_json = json!({
+            "candidates": [{
+                "content": {
+                    "parts": [{"text": "Hello"}]
+                }
+            }]
+        });
+        let event_data: EventData = serde_json::from_value(response_json).unwrap();
+        match event_data {
+            EventData::Response(_) => {}
+            _ => panic!("Expected Response"),
+        }
+
+        let error_json = json!({
+            "error": {
+                "code": 400,
+                "message": "Bad Request",
+                "status": "INVALID_ARGUMENT"
+            }
+        });
+        let event_data_err: EventData = serde_json::from_value(error_json).unwrap();
+        match event_data_err {
+            EventData::Error(e) => {
+                assert_eq!(e.error.code, 400);
+                assert_eq!(e.error.message, "Bad Request");
+            }
+            _ => panic!("Expected Error"),
+        }
+    }
+
+    #[test]
+    fn test_candidate_to_message_conversion() {
+        let candidate = Candidate {
+            content: Some(Content {
+                role: Some("model".to_string()),
+                parts: Some(vec![
+                    Part::Text {
+                        text: Some("Hello".to_string()),
+                        thought: None,
+                        thought_signature: None,
+                        executable_code: None,
+                        code_execution_result: None,
+                    },
+                    Part::Text {
+                        text: Some("Thinking...".to_string()),
+                        thought: Some(true),
+                        thought_signature: Some("sig123".to_string()),
+                        executable_code: None,
+                        code_execution_result: None,
+                    },
+                ]),
+            }),
+            finish_reason: Some("STOP".to_string()),
+            safety_ratings: None,
+            grounding_metadata: None,
+            url_context_metadata: None,
+        };
+
+        let message = ChatCompletionMessage::try_from(candidate).unwrap();
+
+        // Check content
+        assert_eq!(message.content.unwrap().as_str(), "Hello");
+
+        // Check reasoning
+        assert_eq!(message.reasoning.unwrap().as_str(), "Thinking...");
+
+        // Check finish reason
+        assert_eq!(message.finish_reason.unwrap(), FinishReason::Stop);
+
+        // Check thought signature
+        assert_eq!(message.thought_signature.unwrap(), "sig123");
+    }
+
+    #[test]
+    fn test_usage_metadata_conversion() {
+        let usage = UsageMetadata {
+            prompt_token_count: Some(10),
+            candidates_token_count: Some(20),
+            total_token_count: Some(30),
+            cached_content_token_count: Some(5),
+            thoughts_token_count: None,
+            traffic_type: None,
+        };
+
+        let domain_usage: forge_domain::Usage = usage.into();
+
+        assert_eq!(domain_usage.prompt_tokens, TokenCount::Actual(10));
+        assert_eq!(domain_usage.completion_tokens, TokenCount::Actual(20));
+        assert_eq!(domain_usage.total_tokens, TokenCount::Actual(30));
+        assert_eq!(domain_usage.cached_tokens, TokenCount::Actual(5));
+    }
+
+    #[test]
+    fn test_part_text_conversion() {
+        let part = Part::Text {
+            text: Some("Hello".to_string()),
+            thought: None,
+            thought_signature: None,
+            executable_code: None,
+            code_execution_result: None,
+        };
+        let msg = ChatCompletionMessage::try_from(part).unwrap();
+        assert_eq!(msg.content.unwrap().as_str(), "Hello");
+        assert!(msg.reasoning.is_none());
+
+        // Test thought
+        let part = Part::Text {
+            text: Some("Thinking...".to_string()),
+            thought: Some(true),
+            thought_signature: Some("sig".to_string()),
+            executable_code: None,
+            code_execution_result: None,
+        };
+        let msg = ChatCompletionMessage::try_from(part).unwrap();
+        assert_eq!(msg.content.unwrap().as_str(), ""); // Content should be empty for pure thought part
+        assert_eq!(msg.reasoning.unwrap().as_str(), "Thinking...");
+        assert_eq!(msg.thought_signature.unwrap(), "sig");
+    }
+
+    #[test]
+    fn test_response_no_candidates() {
+        let response = Response {
+            candidates: vec![],
+            usage_metadata: Some(UsageMetadata {
+                prompt_token_count: Some(10),
+                candidates_token_count: Some(20),
+                total_token_count: Some(30),
+                cached_content_token_count: None,
+                thoughts_token_count: None,
+                traffic_type: None,
+            }),
+            prompt_feedback: None,
+        };
+
+        let msg = ChatCompletionMessage::try_from(response).unwrap();
+        assert_eq!(msg.content.unwrap().as_str(), "");
+
+        let usage = msg.usage.unwrap();
+        assert_eq!(usage.prompt_tokens, TokenCount::Actual(10));
+        assert_eq!(usage.completion_tokens, TokenCount::Actual(20));
+    }
+}

crates/forge_app/src/dto/openai/copilot_model.rs

@@ -0,0 +1,407 @@
+use forge_domain::ModelId;
+use serde::{Deserialize, Serialize};
+
+/// Identifier of the synthetic GitHub Copilot "auto" model.
+///
+/// Copilot's API has no `auto` model id; official clients implement "Auto"
+/// by letting the request omit the model so the service selects a default.
+/// Requests made with this id must not include a `model` field.
+pub const COPILOT_AUTO_MODEL_ID: &str = "auto";
+
+/// Creates the synthetic "auto" model entry for GitHub Copilot.
+///
+/// Selecting this model omits the `model` field from chat requests so the
+/// Copilot service chooses the model server-side. This mirrors the "Auto"
+/// option in official clients and is the included option on free and
+/// student plans where premium model requests are limited.
+pub fn copilot_auto_model() -> forge_domain::Model {
+    forge_domain::Model {
+        id: ModelId::new(COPILOT_AUTO_MODEL_ID),
+        name: Some("Auto (server default)".to_string()),
+        description: Some(
+            "Lets GitHub Copilot choose the model. Does not consume premium requests on plans with limited premium quota."
+                .to_string(),
+        ),
+        context_length: None,
+        tools_supported: Some(true),
+        supports_parallel_tool_calls: None,
+        supports_reasoning: None,
+        input_modalities: vec![forge_domain::InputModality::Text],
+    }
+}
+
+/// Response returned by the GitHub Copilot `/models` endpoint.
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct CopilotListModelResponse {
+    pub data: Vec<CopilotModel>,
+}
+
+/// A model entry as returned by the GitHub Copilot `/models` endpoint.
+///
+/// GitHub Copilot uses a schema that differs from the standard OpenAI
+/// models response: capabilities, limits and access policy are nested
+/// under dedicated objects.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct CopilotModel {
+    pub id: ModelId,
+    pub name: Option<String>,
+    /// Whether the model is shown in the model picker of official clients
+    #[serde(default)]
+    pub model_picker_enabled: bool,
+    /// Access policy for the model; models with a `disabled` state cannot
+    /// be used by the authenticated account
+    pub policy: Option<CopilotPolicy>,
+    pub capabilities: Option<CopilotCapabilities>,
+    pub supported_endpoints: Option<Vec<String>>,
+    pub vendor: Option<String>,
+    pub preview: Option<bool>,
+}
+
+/// Access policy attached to a Copilot model.
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct CopilotPolicy {
+    pub state: Option<String>,
+}
+
+/// Capabilities of a Copilot model.
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct CopilotCapabilities {
+    /// Model type, e.g. `chat` or `embeddings`
+    #[serde(rename = "type")]
+    pub model_type: Option<String>,
+    pub limits: Option<CopilotLimits>,
+    pub supports: Option<CopilotSupports>,
+}
+
+/// Token and vision limits of a Copilot model.
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct CopilotLimits {
+    pub max_context_window_tokens: Option<u64>,
+    pub max_prompt_tokens: Option<u64>,
+    pub max_output_tokens: Option<u64>,
+    pub vision: Option<CopilotVisionLimits>,
+}
+
+/// Vision-specific limits of a Copilot model.
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct CopilotVisionLimits {
+    pub supported_media_types: Option<Vec<String>>,
+}
+
+/// Feature support flags of a Copilot model.
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct CopilotSupports {
+    pub tool_calls: Option<bool>,
+    pub parallel_tool_calls: Option<bool>,
+    pub streaming: Option<bool>,
+    pub vision: Option<bool>,
+    pub adaptive_thinking: Option<bool>,
+    pub max_thinking_budget: Option<u64>,
+    pub min_thinking_budget: Option<u64>,
+    pub reasoning_effort: Option<Vec<String>>,
+}
+
+impl CopilotModel {
+    /// Returns true when the model can actually be used for chat by the
+    /// authenticated account.
+    ///
+    /// Filters out models that are policy-disabled for the current
+    /// subscription (requests to them fail with `model_not_supported`) as
+    /// well as non-chat models such as embeddings.
+    pub fn is_usable(&self) -> bool {
+        // Models explicitly disabled by policy cannot be used and return
+        // `model_not_supported` errors when requested
+        let policy_disabled = self
+            .policy
+            .as_ref()
+            .and_then(|p| p.state.as_deref())
+            .is_some_and(|state| state == "disabled");
+        if policy_disabled {
+            return false;
+        }
+
+        let Some(capabilities) = self.capabilities.as_ref() else {
+            return false;
+        };
+
+        // Only chat models are usable for conversations (excludes embeddings)
+        if capabilities.model_type.as_deref() != Some("chat") {
+            return false;
+        }
+
+        // Require known token limits and tool call information, mirroring the
+        // checks official clients perform before offering a model
+        let has_limits = capabilities.limits.as_ref().is_some_and(|limits| {
+            limits.max_output_tokens.is_some() && limits.max_prompt_tokens.is_some()
+        });
+        let has_tool_info = capabilities
+            .supports
+            .as_ref()
+            .is_some_and(|supports| supports.tool_calls.is_some());
+
+        has_limits && has_tool_info
+    }
+}
+
+impl From<CopilotModel> for forge_domain::Model {
+    fn from(value: CopilotModel) -> Self {
+        let supports = value
+            .capabilities
+            .as_ref()
+            .and_then(|c| c.supports.as_ref());
+        let limits = value.capabilities.as_ref().and_then(|c| c.limits.as_ref());
+
+        let context_length =
+            limits.and_then(|l| l.max_context_window_tokens.or(l.max_prompt_tokens));
+
+        let tools_supported = supports.and_then(|s| s.tool_calls);
+        let supports_parallel_tool_calls = supports.and_then(|s| s.parallel_tool_calls);
+
+        // A model supports reasoning when it advertises adaptive thinking,
+        // reasoning effort levels or a thinking budget
+        let supports_reasoning = supports.map(|s| {
+            s.adaptive_thinking.unwrap_or(false)
+                || s.reasoning_effort
+                    .as_ref()
+                    .is_some_and(|efforts| !efforts.is_empty())
+                || s.max_thinking_budget.is_some()
+        });
+
+        let supports_image = supports.and_then(|s| s.vision).unwrap_or(false)
+            || limits
+                .and_then(|l| l.vision.as_ref())
+                .and_then(|v| v.supported_media_types.as_ref())
+                .is_some_and(|types| types.iter().any(|t| t.starts_with("image/")));
+
+        let mut input_modalities = vec![forge_domain::InputModality::Text];
+        if supports_image {
+            input_modalities.push(forge_domain::InputModality::Image);
+        }
+
+        forge_domain::Model {
+            id: value.id,
+            name: value.name,
+            description: None,
+            context_length,
+            tools_supported,
+            supports_parallel_tool_calls,
+            supports_reasoning,
+            input_modalities,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    fn fixture_chat_model() -> CopilotModel {
+        serde_json::from_value(serde_json::json!({
+            "id": "claude-sonnet-4.6",
+            "name": "Claude Sonnet 4.6",
+            "model_picker_enabled": true,
+            "policy": { "state": "enabled" },
+            "vendor": "Anthropic",
+            "preview": false,
+            "supported_endpoints": ["/chat/completions", "/v1/messages"],
+            "capabilities": {
+                "type": "chat",
+                "family": "claude-sonnet-4.6",
+                "limits": {
+                    "max_context_window_tokens": 264000,
+                    "max_output_tokens": 64000,
+                    "max_prompt_tokens": 200000,
+                    "vision": {
+                        "max_prompt_image_size": 3145728,
+                        "max_prompt_images": 5,
+                        "supported_media_types": ["image/jpeg", "image/png"]
+                    }
+                },
+                "supports": {
+                    "adaptive_thinking": true,
+                    "max_thinking_budget": 32000,
+                    "min_thinking_budget": 1024,
+                    "parallel_tool_calls": true,
+                    "reasoning_effort": ["low", "medium", "high", "max"],
+                    "streaming": true,
+                    "structured_outputs": true,
+                    "tool_calls": true,
+                    "vision": true
+                }
+            }
+        }))
+        .unwrap()
+    }
+
+    fn fixture_disabled_model() -> CopilotModel {
+        serde_json::from_value(serde_json::json!({
+            "id": "gpt-5.5",
+            "name": "GPT-5.5",
+            "model_picker_enabled": true,
+            "policy": { "state": "disabled" },
+            "capabilities": {
+                "type": "chat",
+                "limits": {
+                    "max_context_window_tokens": 272000,
+                    "max_output_tokens": 128000,
+                    "max_prompt_tokens": 144000
+                },
+                "supports": { "tool_calls": true, "streaming": true }
+            }
+        }))
+        .unwrap()
+    }
+
+    fn fixture_embedding_model() -> CopilotModel {
+        serde_json::from_value(serde_json::json!({
+            "id": "text-embedding-3-small",
+            "name": "Embedding V3 small",
+            "model_picker_enabled": false,
+            "capabilities": {
+                "type": "embeddings",
+                "limits": { "max_inputs": 256 },
+                "supports": { "dimensions": true }
+            }
+        }))
+        .unwrap()
+    }
+
+    #[test]
+    fn test_usable_chat_model() {
+        let fixture = fixture_chat_model();
+        let actual = fixture.is_usable();
+        let expected = true;
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_policy_disabled_model_is_not_usable() {
+        let fixture = fixture_disabled_model();
+        let actual = fixture.is_usable();
+        let expected = false;
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_embedding_model_is_not_usable() {
+        let fixture = fixture_embedding_model();
+        let actual = fixture.is_usable();
+        let expected = false;
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_model_without_policy_is_usable() {
+        let fixture = serde_json::from_value::<CopilotModel>(serde_json::json!({
+            "id": "gpt-4o",
+            "name": "GPT-4o",
+            "model_picker_enabled": false,
+            "capabilities": {
+                "type": "chat",
+                "limits": {
+                    "max_context_window_tokens": 128000,
+                    "max_output_tokens": 16384,
+                    "max_prompt_tokens": 64000
+                },
+                "supports": { "tool_calls": true, "parallel_tool_calls": true }
+            }
+        }))
+        .unwrap();
+
+        let actual = fixture.is_usable();
+        let expected = true;
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_conversion_to_domain_model() {
+        let fixture = fixture_chat_model();
+
+        let actual: forge_domain::Model = fixture.into();
+
+        let expected = forge_domain::Model {
+            id: ModelId::new("claude-sonnet-4.6"),
+            name: Some("Claude Sonnet 4.6".to_string()),
+            description: None,
+            context_length: Some(264000),
+            tools_supported: Some(true),
+            supports_parallel_tool_calls: Some(true),
+            supports_reasoning: Some(true),
+            input_modalities: vec![
+                forge_domain::InputModality::Text,
+                forge_domain::InputModality::Image,
+            ],
+        };
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_conversion_falls_back_to_max_prompt_tokens() {
+        let fixture = serde_json::from_value::<CopilotModel>(serde_json::json!({
+            "id": "some-model",
+            "name": "Some Model",
+            "capabilities": {
+                "type": "chat",
+                "limits": { "max_prompt_tokens": 100000, "max_output_tokens": 4096 },
+                "supports": { "tool_calls": true }
+            }
+        }))
+        .unwrap();
+
+        let actual: forge_domain::Model = fixture.into();
+
+        assert_eq!(actual.context_length, Some(100000));
+        assert_eq!(actual.supports_reasoning, Some(false));
+        assert_eq!(
+            actual.input_modalities,
+            vec![forge_domain::InputModality::Text]
+        );
+    }
+
+    #[test]
+    fn test_list_response_deserialization_ignores_unknown_fields() {
+        let fixture = serde_json::json!({
+            "data": [
+                {
+                    "id": "claude-sonnet-4.6",
+                    "name": "Claude Sonnet 4.6",
+                    "object": "model",
+                    "model_picker_category": "versatile",
+                    "warning_message": "some warning",
+                    "capabilities": {
+                        "type": "chat",
+                        "object": "model_capabilities",
+                        "tokenizer": "o200k_base",
+                        "limits": { "max_prompt_tokens": 200000, "max_output_tokens": 64000 },
+                        "supports": { "tool_calls": true }
+                    }
+                }
+            ]
+        });
+
+        let actual = serde_json::from_value::<CopilotListModelResponse>(fixture).unwrap();
+
+        assert_eq!(actual.data.len(), 1);
+        assert_eq!(actual.data[0].id.as_str(), "claude-sonnet-4.6");
+        assert_eq!(actual.data[0].is_usable(), true);
+    }
+
+    #[test]
+    fn test_copilot_auto_model_id() {
+        let fixture = copilot_auto_model();
+        let actual = fixture.id.as_str();
+        let expected = COPILOT_AUTO_MODEL_ID;
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_copilot_auto_model_supports_tools() {
+        let fixture = copilot_auto_model();
+        let actual = fixture.tools_supported;
+        let expected = Some(true);
+        assert_eq!(actual, expected);
+    }
+}

crates/forge_app/src/dto/openai/error.rs

@@ -0,0 +1,193 @@
+use std::collections::BTreeMap;
+
+use derive_setters::Setters;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+#[derive(Debug, derive_more::From, Error)]
+pub enum Error {
+    #[error("{0}")]
+    Response(ErrorResponse),
+
+    #[error("Invalid Status Code: {0}")]
+    InvalidStatusCode(u16),
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[serde(untagged)]
+pub enum ErrorCode {
+    String(String),
+    Number(u16),
+}
+
+impl ErrorCode {
+    pub fn as_number(&self) -> Option<u16> {
+        match self {
+            ErrorCode::String(s) => s.parse::<u16>().ok(),
+            ErrorCode::Number(code) => Some(*code),
+        }
+    }
+
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            ErrorCode::String(s) => Some(s),
+            ErrorCode::Number(_) => None,
+        }
+    }
+}
+
+#[derive(Default, Debug, Deserialize, Serialize, Clone, Setters)]
+#[setters(strip_option)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<Box<ErrorResponse>>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub errno: Option<i32>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<ErrorCode>,
+
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub metadata: BTreeMap<String, serde_json::Value>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub syscall: Option<String>,
+
+    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
+    pub type_of: Option<serde_json::Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub param: Option<serde_json::Value>,
+}
+
+impl ErrorResponse {
+    /// Deeply introspects the error structure to determine the ErrorCode
+    pub fn get_code_deep(&self) -> Option<&ErrorCode> {
+        if let Some(ref code) = self.code {
+            return Some(code);
+        }
+        if let Some(ref error) = self.error {
+            return error.get_code_deep();
+        }
+        None
+    }
+}
+
+impl std::fmt::Display for ErrorResponse {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        serde_json::to_string(self)
+            .map_err(|_| std::fmt::Error)?
+            .fmt(f)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_error_code_as_number() {
+        // Test with numeric error code
+        let code_number = ErrorCode::Number(404);
+        assert_eq!(code_number.as_number(), Some(404));
+
+        // Test with string error code containing a valid number
+        let code_string_numeric = ErrorCode::String("500".to_string());
+        assert_eq!(code_string_numeric.as_number(), Some(500));
+
+        // Test with string error code containing a non-numeric value
+        let code_string_non_numeric = ErrorCode::String("ERR_STREAM_PREMATURE_CLOSE".to_string());
+        assert_eq!(code_string_non_numeric.as_number(), None);
+    }
+
+    #[test]
+    fn test_error_code_as_str() {
+        // Test with string error code
+        let code_string = ErrorCode::String("ERR_STREAM_PREMATURE_CLOSE".to_string());
+        assert_eq!(code_string.as_str(), Some("ERR_STREAM_PREMATURE_CLOSE"));
+
+        // Test with numeric error code
+        let code_number = ErrorCode::Number(404);
+        assert_eq!(code_number.as_str(), None);
+    }
+
+    #[test]
+    fn test_get_code_deep_direct() {
+        // Test with an error that has a direct code
+        let error_code = ErrorCode::Number(404);
+
+        // Use derived setters for a cleaner initialization
+        let fixture = ErrorResponse::default()
+            .message("Error message".to_string())
+            .code(error_code);
+
+        let actual = fixture.get_code_deep();
+
+        // Create a new ErrorCode to compare against
+        let expected_code = ErrorCode::Number(404);
+        assert_eq!(actual, Some(&expected_code));
+    }
+
+    #[test]
+    fn test_get_code_deep_nested() {
+        // Test with an error that has no direct code but has an inner error with a code
+        let error_code = ErrorCode::String("ERR_STREAM_PREMATURE_CLOSE".to_string());
+
+        // Use derived setters for cleaner initialization
+        let inner_error = ErrorResponse::default()
+            .message("Inner error".to_string())
+            .code(error_code);
+
+        let fixture = ErrorResponse::default()
+            .error(Box::new(inner_error))
+            .message("Outer error".to_string());
+
+        let actual = fixture.get_code_deep();
+
+        // Create a new ErrorCode to compare against
+        let expected_code = ErrorCode::String("ERR_STREAM_PREMATURE_CLOSE".to_string());
+        assert_eq!(actual, Some(&expected_code));
+    }
+
+    #[test]
+    fn test_get_code_deep_no_code() {
+        // Test with an error that has no code and no inner error
+        let fixture = ErrorResponse::default().message("Error message".to_string());
+
+        let actual = fixture.get_code_deep();
+        let expected = None;
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_get_code_deep_multiple_nested() {
+        // Test with deeply nested errors
+        let error_code = ErrorCode::Number(500);
+
+        let deepest_error = ErrorResponse::default()
+            .message("Deepest error".to_string())
+            .code(error_code);
+
+        let middle_error = ErrorResponse::default()
+            .error(Box::new(deepest_error))
+            .message("Middle error".to_string());
+        // No code here, should find deepest
+
+        let fixture = ErrorResponse::default()
+            .error(Box::new(middle_error))
+            .message("Outer error".to_string());
+        // No code here, should find deepest
+
+        let actual = fixture.get_code_deep();
+
+        // Create a new ErrorCode to compare against
+        let expected_code = ErrorCode::Number(500);
+        assert_eq!(actual, Some(&expected_code));
+    }
+}

crates/forge_app/src/dto/openai/fixtures/chutes_api_response.json

@@ -0,0 +1,16 @@
+{
+  "data": [
+    {
+      "id": "moonshotai/Kimi-K2-Instruct-75k",
+      "name": "Kimi K2 Instruct 75k",
+      "created": 1234567890,
+      "description": "Kimi K2 model with 75k context length",
+      "context_length": 75000,
+      "pricing": {
+        "prompt": 0.17992692,
+        "completion": 0.17992692
+      },
+      "supported_parameters": ["tools", "supports_parallel_tool_calls"]
+    }
+  ]
+}

crates/forge_app/src/dto/openai/fixtures/chutes_completion_response.json

@@ -0,0 +1,23 @@
+{
+  "id": "chatcmpl-a9db7cc9005c6568",
+  "object": "chat.completion.chunk",
+  "created": 1775233185,
+  "model": "moonshotai/Kimi-K2.5-TEE",
+  "choices": [
+    {
+      "index": 0,
+      "delta": { "reasoning": " The", "reasoning_content": " The" },
+      "logprobs": null,
+      "finish_reason": null,
+      "token_ids": null,
+      "hidden_states": null
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 8764,
+    "total_tokens": 8765,
+    "completion_tokens": 1,
+    "reasoning_tokens": 1
+  },
+  "chutes_verification": "6bbeaf04d5800d774cc497b0a619acee"
+}

crates/forge_app/src/dto/openai/fixtures/model_invalid_pricing.json

@@ -0,0 +1,8 @@
+{
+  "id": "invalid-pricing-model",
+  "name": "Invalid Pricing Model",
+  "pricing": {
+    "prompt": "not-a-number",
+    "completion": 0.002
+  }
+}

crates/forge_app/src/dto/openai/fixtures/model_mixed_pricing.json

@@ -0,0 +1,9 @@
+{
+  "id": "mixed-model",
+  "name": "Mixed Pricing Model",
+  "pricing": {
+    "prompt": "0.001",
+    "completion": 0.002,
+    "image": null
+  }
+}

crates/forge_app/src/dto/openai/fixtures/model_no_pricing.json

@@ -0,0 +1,4 @@
+{
+  "id": "no-pricing-model",
+  "name": "No Pricing Model"
+}

crates/forge_app/src/dto/openai/fixtures/model_numeric_pricing.json

@@ -0,0 +1,8 @@
+{
+  "id": "moonshotai/Kimi-K2-Instruct-75k",
+  "name": "Kimi K2 Instruct 75k",
+  "pricing": {
+    "prompt": 0.17992692,
+    "completion": 0.17992692
+  }
+}

crates/forge_app/src/dto/openai/fixtures/model_scientific_notation.json

@@ -0,0 +1,8 @@
+{
+  "id": "scientific-model",
+  "name": "Scientific Notation Model",
+  "pricing": {
+    "prompt": "1.5e-3",
+    "completion": "2.0E-4"
+  }
+}

crates/forge_app/src/dto/openai/fixtures/model_string_pricing.json

@@ -0,0 +1,8 @@
+{
+  "id": "test-model",
+  "name": "Test Model",
+  "pricing": {
+    "prompt": "0.001",
+    "completion": "0.002"
+  }
+}

crates/forge_app/src/dto/openai/fixtures/orcarouter_api_response.json

@@ -0,0 +1,31 @@
+{
+  "data": [
+    {
+      "id": "openai/gpt-4o-mini",
+      "object": "model",
+      "created": 1626777600,
+      "owned_by": "OpenAI",
+      "supported_endpoint_types": ["openai", "openai-response"],
+      "name": "OpenAI: GPT-4o-mini",
+      "description": "GPT-4o mini is OpenAI's most advanced small model, supporting both text and image inputs with text outputs.",
+      "context_length": 128000,
+      "max_completion_tokens": 16384,
+      "architecture": {
+        "input_modalities": ["text", "image", "file"],
+        "output_modalities": ["text"]
+      },
+      "top_provider": {
+        "context_length": 128000,
+        "max_completion_tokens": 16384
+      },
+      "pricing": {
+        "prompt": "0.0000001500",
+        "completion": "0.0000006000",
+        "prompt_per_million": "0.150000",
+        "completion_per_million": "0.600000"
+      }
+    }
+  ],
+  "object": "list",
+  "success": true
+}

crates/forge_app/src/dto/openai/fixtures/zai_api_delta_response.json

@@ -0,0 +1 @@
+{"id":"20250822012952a2d93c459ed54892","created":1755797392,"model":"glm-4.5","choices":[{"index":0,"delta":{"role":"assistant","content":"Hi","reasoning_content":""}}]}

crates/forge_app/src/dto/openai/fixtures/zai_api_response.json

@@ -0,0 +1 @@
+{"id":"20250822012952a2d93c459ed54892","created":1755797392,"model":"glm-4.5","choices":[{"index":0,"finish_reason":"stop","delta":{"role":"assistant","content":"","reasoning_content":""}}],"usage":{"prompt_tokens":8,"completion_tokens":14,"total_tokens":22,"prompt_tokens_details":{"cached_tokens":0}}}

crates/forge_app/src/dto/openai/mod.rs

@@ -0,0 +1,17 @@
+mod copilot_model;
+mod error;
+mod model;
+mod reasoning;
+mod request;
+mod response;
+mod tool_choice;
+mod transformers;
+
+pub use copilot_model::*;
+pub use error::*;
+pub use model::*;
+pub use reasoning::*;
+pub use request::*;
+pub use response::*;
+pub use tool_choice::*;
+pub use transformers::ProviderPipeline;

crates/forge_app/src/dto/openai/model.rs

@@ -0,0 +1,356 @@
+use forge_domain::ModelId;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(untagged)]
+enum PriceValue {
+    Number(f32),
+    String(String),
+}
+
+impl From<PriceValue> for Option<f32> {
+    fn from(value: PriceValue) -> Self {
+        match value {
+            PriceValue::Number(n) => Some(n),
+            PriceValue::String(s) => s.parse().ok(),
+        }
+    }
+}
+
+impl TryFrom<PriceValue> for f32 {
+    type Error = std::num::ParseFloatError;
+
+    fn try_from(value: PriceValue) -> Result<Self, Self::Error> {
+        match value {
+            PriceValue::Number(n) => Ok(n),
+            PriceValue::String(s) => s.parse(),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Model {
+    pub id: ModelId,
+    pub name: Option<String>,
+    pub created: Option<u64>,
+    pub description: Option<String>,
+    pub context_length: Option<u64>,
+    pub architecture: Option<Architecture>,
+    pub pricing: Option<Pricing>,
+    pub top_provider: Option<TopProvider>,
+    pub per_request_limits: Option<serde_json::Value>,
+    pub supported_parameters: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Architecture {
+    // Some OpenAI-compatible providers (e.g. OrcaRouter) return an
+    // `architecture` object carrying only the modality arrays, so every
+    // field must tolerate being absent.
+    pub modality: Option<String>,
+    pub tokenizer: Option<String>,
+    pub instruct_type: Option<String>,
+    pub input_modalities: Option<Vec<String>>,
+    pub output_modalities: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+pub struct Pricing {
+    #[serde(default, deserialize_with = "deserialize_optional_price")]
+    pub prompt: Option<f32>,
+    #[serde(default, deserialize_with = "deserialize_optional_price")]
+    pub completion: Option<f32>,
+    #[serde(default, deserialize_with = "deserialize_optional_price")]
+    pub image: Option<f32>,
+    #[serde(default, deserialize_with = "deserialize_optional_price")]
+    pub request: Option<f32>,
+}
+
+fn deserialize_optional_price<'de, D>(deserializer: D) -> Result<Option<f32>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::de::Error;
+
+    match Option::<PriceValue>::deserialize(deserializer)? {
+        Some(price_value) => match f32::try_from(price_value) {
+            Ok(value) => Ok(Some(value)),
+            Err(_) => Err(Error::custom("invalid string format for pricing value")),
+        },
+        None => Ok(None),
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct TopProvider {
+    pub context_length: Option<u64>,
+    pub max_completion_tokens: Option<u64>,
+    #[serde(default)]
+    pub is_moderated: bool,
+}
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct ListModelResponse {
+    pub data: Vec<Model>,
+}
+
+impl From<Model> for forge_domain::Model {
+    fn from(value: Model) -> Self {
+        let has_param = |name: &str| {
+            value
+                .supported_parameters
+                .as_ref()
+                .map(|params| params.iter().any(|p| p == name))
+        };
+
+        // Parse input modalities from OpenRouter's input_modalities field
+        let input_modalities = value
+            .architecture
+            .as_ref()
+            .and_then(|arch| arch.input_modalities.as_ref())
+            .map(|modalities| {
+                modalities
+                    .iter()
+                    .filter_map(|s| s.parse::<forge_domain::InputModality>().ok())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_else(|| vec![forge_domain::InputModality::Text]);
+
+        let tools_supported = has_param("tools");
+        let supports_parallel_tool_calls = has_param("supports_parallel_tool_calls");
+        let supports_reasoning = has_param("reasoning");
+
+        forge_domain::Model {
+            id: value.id,
+            name: value.name,
+            description: value.description,
+            context_length: value.context_length,
+            tools_supported,
+            supports_parallel_tool_calls,
+            supports_reasoning,
+            input_modalities,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    pub async fn load_fixture(filename: &str) -> serde_json::Value {
+        let fixture_path = format!("src/dto/openai/fixtures/{}", filename);
+        let fixture_content = tokio::fs::read_to_string(&fixture_path)
+            .await
+            .unwrap_or_else(|_| panic!("Failed to read fixture file: {}", fixture_path));
+        serde_json::from_str(&fixture_content)
+            .unwrap_or_else(|_| panic!("Failed to parse JSON fixture: {}", fixture_path))
+    }
+
+    #[tokio::test]
+    async fn test_deserialize_model_with_numeric_pricing() {
+        // This reproduces the issue where Chutes API returns numeric pricing instead of
+        // strings
+        let fixture = load_fixture("model_numeric_pricing.json").await;
+
+        let actual = serde_json::from_value::<Model>(fixture).unwrap();
+
+        // This should not fail - we should be able to handle numeric pricing
+        assert_eq!(actual.pricing.as_ref().unwrap().prompt, Some(0.17992692));
+        assert_eq!(
+            actual.pricing.as_ref().unwrap().completion,
+            Some(0.17992692)
+        );
+    }
+
+    #[tokio::test]
+    async fn test_deserialize_model_with_string_pricing() {
+        let fixture = load_fixture("model_string_pricing.json").await;
+
+        let actual = serde_json::from_value::<Model>(fixture).unwrap();
+        let expected = Model {
+            id: "test-model".into(),
+            name: Some("Test Model".to_string()),
+            created: None,
+            description: None,
+            context_length: None,
+            architecture: None,
+            pricing: Some(Pricing {
+                prompt: Some(0.001),
+                completion: Some(0.002),
+                image: None,
+                request: None,
+            }),
+            top_provider: None,
+            per_request_limits: None,
+            supported_parameters: None,
+        };
+
+        assert_eq!(actual.id, expected.id);
+        assert_eq!(actual.name, expected.name);
+        assert_eq!(
+            actual.pricing.as_ref().unwrap().prompt,
+            expected.pricing.as_ref().unwrap().prompt
+        );
+        assert_eq!(
+            actual.pricing.as_ref().unwrap().completion,
+            expected.pricing.as_ref().unwrap().completion
+        );
+    }
+
+    #[tokio::test]
+    async fn test_deserialize_model_with_mixed_pricing() {
+        // Test with mixed string, numeric, and null pricing values
+        let fixture = load_fixture("model_mixed_pricing.json").await;
+
+        let actual = serde_json::from_value::<Model>(fixture).unwrap();
+
+        assert_eq!(actual.pricing.as_ref().unwrap().prompt, Some(0.001));
+        assert_eq!(actual.pricing.as_ref().unwrap().completion, Some(0.002));
+        assert_eq!(actual.pricing.as_ref().unwrap().image, None);
+        assert_eq!(actual.pricing.as_ref().unwrap().request, None);
+    }
+
+    #[tokio::test]
+    async fn test_deserialize_model_without_pricing() {
+        // Test that models without pricing field work correctly
+        let fixture = load_fixture("model_no_pricing.json").await;
+
+        let actual = serde_json::from_value::<Model>(fixture).unwrap();
+
+        assert_eq!(actual.id.as_str(), "no-pricing-model");
+        assert_eq!(actual.name, Some("No Pricing Model".to_string()));
+        assert_eq!(actual.pricing, None);
+    }
+
+    #[tokio::test]
+    async fn test_chutes_api_response_format() {
+        // This simulates the actual Chutes API response format that was causing the
+        // issue
+        let fixture = load_fixture("chutes_api_response.json").await;
+
+        let actual = serde_json::from_value::<ListModelResponse>(fixture).unwrap();
+
+        assert_eq!(actual.data.len(), 1);
+        let model = &actual.data[0];
+        assert_eq!(model.id.as_str(), "moonshotai/Kimi-K2-Instruct-75k");
+        assert_eq!(model.name, Some("Kimi K2 Instruct 75k".to_string()));
+        assert_eq!(model.context_length, Some(75000));
+
+        let pricing = model.pricing.as_ref().unwrap();
+        assert_eq!(pricing.prompt, Some(0.17992692));
+        assert_eq!(pricing.completion, Some(0.17992692));
+        assert_eq!(pricing.image, None);
+        assert_eq!(pricing.request, None);
+    }
+
+    #[tokio::test]
+    async fn test_orcarouter_api_response_format() {
+        // OrcaRouter returns an `architecture` object with only the modality
+        // arrays (no `modality`/`tokenizer`) and a `top_provider` without
+        // `is_moderated`; all of these must deserialize.
+        let fixture = load_fixture("orcarouter_api_response.json").await;
+
+        let actual = serde_json::from_value::<ListModelResponse>(fixture).unwrap();
+
+        assert_eq!(actual.data.len(), 1);
+        let model = &actual.data[0];
+        assert_eq!(model.id.as_str(), "openai/gpt-4o-mini");
+        assert_eq!(model.name, Some("OpenAI: GPT-4o-mini".to_string()));
+        assert_eq!(model.context_length, Some(128000));
+
+        let architecture = model.architecture.as_ref().unwrap();
+        assert_eq!(architecture.modality, None);
+        assert_eq!(architecture.tokenizer, None);
+        assert_eq!(
+            architecture.input_modalities,
+            Some(vec![
+                "text".to_string(),
+                "image".to_string(),
+                "file".to_string()
+            ])
+        );
+
+        let top_provider = model.top_provider.as_ref().unwrap();
+        assert_eq!(top_provider.context_length, Some(128000));
+        assert_eq!(top_provider.is_moderated, false);
+
+        let pricing = model.pricing.as_ref().unwrap();
+        assert_eq!(pricing.prompt, Some(0.00000015));
+        assert_eq!(pricing.completion, Some(0.0000006));
+    }
+
+    #[tokio::test]
+    async fn test_deserialize_model_with_invalid_string_pricing() {
+        // Test that invalid string pricing formats fail gracefully
+        let fixture = load_fixture("model_invalid_pricing.json").await;
+
+        let actual = serde_json::from_value::<Model>(fixture);
+
+        // This should fail with a parsing error
+        assert!(actual.is_err());
+        let error_message = format!("{}", actual.unwrap_err());
+        assert!(error_message.contains("invalid string format for pricing value"));
+    }
+
+    #[tokio::test]
+    async fn test_deserialize_model_with_scientific_notation_string() {
+        // Test that scientific notation in strings works
+        let fixture = load_fixture("model_scientific_notation.json").await;
+
+        let actual = serde_json::from_value::<Model>(fixture).unwrap();
+
+        assert_eq!(actual.pricing.as_ref().unwrap().prompt, Some(0.0015));
+        assert_eq!(actual.pricing.as_ref().unwrap().completion, Some(0.0002));
+    }
+    #[tokio::test]
+    async fn test_model_conversion_without_supported_parameters() {
+        let model = Model {
+            id: "test-model".into(),
+            name: Some("Test Model".to_string()),
+            created: None,
+            description: Some("A test model".to_string()),
+            context_length: Some(4096),
+            architecture: None,
+            pricing: None,
+            top_provider: None,
+            per_request_limits: None,
+            supported_parameters: None, // No supported_parameters field
+        };
+
+        let domain_model: forge_domain::Model = model.into();
+
+        // When supported_parameters is None, capabilities should be None (unknown)
+        assert_eq!(domain_model.tools_supported, None);
+        assert_eq!(domain_model.supports_parallel_tool_calls, None);
+        assert_eq!(domain_model.supports_reasoning, None);
+    }
+
+    #[tokio::test]
+    async fn test_model_conversion_with_supported_parameters() {
+        let model = Model {
+            id: "test-model".into(),
+            name: Some("Test Model".to_string()),
+            created: None,
+            description: Some("A test model".to_string()),
+            context_length: Some(4096),
+            architecture: None,
+            pricing: None,
+            top_provider: None,
+            per_request_limits: None,
+            supported_parameters: Some(vec![
+                "tools".to_string(),
+                "reasoning".to_string(),
+                // Note: "supports_parallel_tool_calls" is not included
+            ]),
+        };
+
+        let domain_model: forge_domain::Model = model.into();
+
+        // Should reflect what's actually in supported_parameters
+        assert_eq!(domain_model.tools_supported, Some(true));
+        assert_eq!(domain_model.supports_parallel_tool_calls, Some(false));
+        assert_eq!(domain_model.supports_reasoning, Some(true));
+    }
+}

crates/forge_app/src/dto/openai/reasoning.rs

@@ -0,0 +1,18 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ReasoningDetail {
+    pub r#type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub format: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub index: Option<i32>,
+}

crates/forge_app/src/dto/openai/request.rs

@@ -0,0 +1,937 @@
+use std::vec;
+
+use derive_more::derive::Display;
+use derive_setters::Setters;
+use forge_json_repair::coerce_to_schema;
+use serde::{Deserialize, Serialize};
+use strum::IntoEnumIterator;
+
+use super::response::{ExtraContent, FunctionCall, ToolCall};
+use super::tool_choice::{FunctionType, ToolChoice};
+use crate::domain::{
+    Context, ContextMessage, ModelId, ToolCallFull, ToolCallId, ToolCatalog, ToolDefinition,
+    ToolName, ToolResult, ToolValue,
+};
+use crate::dto::openai::ReasoningDetail;
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+pub struct ImageUrl {
+    pub url: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub detail: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Message {
+    pub role: Role,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<MessageContent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<ToolName>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_call_id: Option<ToolCallId>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_calls: Option<Vec<ToolCall>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_details: Option<Vec<ReasoningDetail>>,
+    // GitHub Copilot format (flat fields instead of array)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_opaque: Option<String>,
+    // kimi_k2 uses reasoning_content as flat string (similar to reasoning_text but aliased)
+    #[serde(skip_serializing_if = "Option::is_none", rename = "reasoning_content")]
+    pub reasoning_content: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra_content: Option<ExtraContent>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[serde(untagged)]
+pub enum MessageContent {
+    Text(String),
+    Parts(Vec<ContentPart>),
+}
+
+impl MessageContent {
+    pub fn cached(self, enable_cache: bool) -> Self {
+        let cache_control =
+            enable_cache.then_some(CacheControl { type_: CacheControlType::Ephemeral });
+
+        match self {
+            MessageContent::Text(text) => {
+                if let Some(cc) = cache_control {
+                    MessageContent::Parts(vec![ContentPart::Text { text, cache_control: Some(cc) }])
+                } else {
+                    MessageContent::Text(text)
+                }
+            }
+            MessageContent::Parts(mut parts) => {
+                parts.iter_mut().for_each(ContentPart::reset_cache);
+                match cache_control {
+                    Some(_) => {
+                        // cache the last part of the message
+                        if let Some(part) = parts.last_mut() {
+                            part.cached(enable_cache)
+                        }
+                        MessageContent::Parts(parts)
+                    }
+                    None => MessageContent::Parts(parts),
+                }
+            }
+        }
+    }
+
+    pub fn is_cached(&self) -> bool {
+        match self {
+            MessageContent::Text(_) => false,
+            MessageContent::Parts(parts) => parts.iter().any(|part| {
+                if let ContentPart::Text { cache_control, .. } = part {
+                    cache_control.is_some()
+                } else {
+                    false
+                }
+            }),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ContentPart {
+    Text {
+        text: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+    ImageUrl {
+        image_url: ImageUrl,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        cache_control: Option<CacheControl>,
+    },
+}
+
+impl ContentPart {
+    pub fn reset_cache(&mut self) {
+        match self {
+            ContentPart::Text { cache_control, .. } => {
+                *cache_control = None;
+            }
+            ContentPart::ImageUrl { cache_control, .. } => {
+                *cache_control = None;
+            }
+        }
+    }
+
+    pub fn cached(&mut self, enable_cache: bool) {
+        let src_cache_control =
+            enable_cache.then_some(CacheControl { type_: CacheControlType::Ephemeral });
+        match self {
+            ContentPart::Text { cache_control, .. } => {
+                *cache_control = src_cache_control;
+            }
+            ContentPart::ImageUrl { cache_control, .. } => {
+                *cache_control = src_cache_control;
+            }
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct CacheControl {
+    #[serde(rename = "type")]
+    pub type_: CacheControlType,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum CacheControlType {
+    Ephemeral,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+pub struct FunctionDescription {
+    pub description: Option<String>,
+    pub name: String,
+    pub parameters: serde_json::Value,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+pub struct Tool {
+    // TODO: should be an enum
+    pub r#type: FunctionType,
+    pub function: FunctionDescription,
+}
+
+/// Response format configuration for OpenAI API
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[serde(tag = "type", content = "json_schema")]
+pub enum ResponseFormat {
+    #[serde(rename = "text")]
+    Text,
+    #[serde(rename = "json_schema")]
+    JsonSchema {
+        name: String,
+        schema: Box<schemars::Schema>,
+    },
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+pub struct Prediction {
+    pub r#type: String,
+    pub content: String,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+pub struct ProviderPreferences {
+    // Define fields as necessary
+}
+
+/// Z.ai-specific thinking type
+///
+/// Represents the state of thinking for z.ai providers
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum ThinkingType {
+    Enabled,
+    Disabled,
+}
+
+/// Z.ai-specific thinking configuration structure
+///
+/// Z.ai uses a different format than standard OpenAI reasoning configuration.
+/// This struct represents z.ai's thinking format: `{"type": "enabled"}` or
+/// `{"type": "disabled"}`
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+pub struct ThinkingConfig {
+    /// Type of thinking configuration - enabled or disabled
+    #[serde(rename = "type")]
+    pub r#type: ThinkingType,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, Setters, Default)]
+#[setters(strip_option)]
+pub struct Request {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub messages: Option<Vec<Message>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prompt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model: Option<ModelId>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_format: Option<ResponseFormat>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stream: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_tokens: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<Tool>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_choice: Option<ToolChoice>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub seed: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_k: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub frequency_penalty: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub presence_penalty: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub repetition_penalty: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logit_bias: Option<std::collections::HashMap<u32, f32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_logprobs: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub min_p: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_a: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prediction: Option<Prediction>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub transforms: Option<Vec<Transform>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub models: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub route: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub provider: Option<ProviderPreferences>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parallel_tool_calls: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    /// Indicates who initiated the conversation: "user" or "agent".
+    /// Used for GitHub Copilot billing optimization. Not serialized to API.
+    #[serde(skip_serializing)]
+    pub initiator: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stream_options: Option<StreamOptions>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning: Option<forge_domain::ReasoningConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_effort: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_completion_tokens: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<ThinkingConfig>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct StreamOptions {
+    pub include_usage: Option<bool>,
+}
+
+impl Request {
+    pub fn message_count(&self) -> usize {
+        self.messages
+            .as_ref()
+            .map(|messages| messages.len())
+            .unwrap_or(0)
+    }
+
+    pub fn message_cache_count(&self) -> usize {
+        self.messages
+            .iter()
+            .flatten()
+            .flat_map(|a| a.content.as_ref())
+            .enumerate()
+            .map(|(i, _)| i)
+            .max()
+            .unwrap_or(0)
+    }
+}
+
+/// ref: https://openrouter.ai/docs/transforms
+#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Transform {
+    #[default]
+    #[serde(rename = "middle-out")]
+    MiddleOut,
+}
+
+impl From<ToolDefinition> for Tool {
+    fn from(value: ToolDefinition) -> Self {
+        Tool {
+            r#type: FunctionType,
+            function: FunctionDescription {
+                description: Some(value.description),
+                name: value.name.to_string(),
+                parameters: {
+                    let mut params = serde_json::to_value(value.input_schema).unwrap();
+                    // Ensure OpenAI compatibility by adding properties field if missing
+                    if let Some(obj) = params.as_object_mut()
+                        && obj.get("type") == Some(&serde_json::Value::String("object".to_string()))
+                        && !obj.contains_key("properties")
+                    {
+                        obj.insert(
+                            "properties".to_string(),
+                            serde_json::Value::Object(serde_json::Map::new()),
+                        );
+                    }
+                    params
+                },
+            },
+        }
+    }
+}
+
+impl From<Context> for Request {
+    fn from(context: Context) -> Self {
+        Request {
+            messages: {
+                let messages = context
+                    .messages
+                    .into_iter()
+                    .map(|msg| Message::from(msg.message))
+                    .collect::<Vec<_>>();
+
+                Some(messages)
+            },
+            tools: {
+                let tools = context
+                    .tools
+                    .into_iter()
+                    .map(Tool::from)
+                    .collect::<Vec<_>>();
+                if tools.is_empty() { None } else { Some(tools) }
+            },
+            model: None,
+            prompt: Default::default(),
+            response_format: context.response_format.map(|rf| match rf {
+                forge_domain::ResponseFormat::Text => ResponseFormat::Text,
+                forge_domain::ResponseFormat::JsonSchema(schema) => {
+                    // Extract name from schema title
+                    let name = schema
+                        .as_value()
+                        .as_object()
+                        .and_then(|obj| obj.get("title"))
+                        .and_then(|t| t.as_str())
+                        .map(String::from)
+                        .expect("Schema must have a title");
+
+                    ResponseFormat::JsonSchema { name, schema }
+                }
+            }),
+            stop: Default::default(),
+            stream: Some(context.stream.unwrap_or(true)),
+            max_tokens: context.max_tokens.map(|t| t as u32),
+            temperature: context.temperature.map(|t| t.value()),
+            tool_choice: context.tool_choice.map(|tc| tc.into()),
+            seed: Default::default(),
+            top_p: context.top_p.map(|t| t.value()),
+            top_k: context.top_k.map(|t| t.value()),
+            frequency_penalty: Default::default(),
+            presence_penalty: Default::default(),
+            repetition_penalty: Default::default(),
+            logit_bias: Default::default(),
+            top_logprobs: Default::default(),
+            min_p: Default::default(),
+            top_a: Default::default(),
+            prediction: Default::default(),
+            // Since compaction is support on the client we don't need middle-out transforms any
+            // more
+            transforms: Default::default(),
+            models: Default::default(),
+            route: Default::default(),
+            provider: Default::default(),
+            parallel_tool_calls: Some(true), /* Default to true, transformers will adjust based
+                                              * on model capabilities */
+            stream_options: Some(StreamOptions { include_usage: Some(true) }),
+            session_id: context.conversation_id.map(|id| id.to_string()),
+            initiator: context.initiator,
+            reasoning: context.reasoning,
+            reasoning_effort: Default::default(),
+            max_completion_tokens: Default::default(),
+            thinking: Default::default(),
+        }
+    }
+}
+
+fn serialize_tool_call_arguments(tool_call: &ToolCallFull) -> String {
+    let serialized_arguments = || serde_json::to_string(&tool_call.arguments).unwrap();
+
+    let Ok(parsed_arguments) = tool_call.arguments.parse() else {
+        return serialized_arguments();
+    };
+
+    let normalized_arguments = ToolCatalog::iter()
+        .find(|tool| tool.definition().name == tool_call.name)
+        .map(|tool| coerce_to_schema(parsed_arguments.clone(), &tool.definition().input_schema))
+        .unwrap_or(parsed_arguments);
+
+    serde_json::to_string(&normalized_arguments).unwrap_or_else(|_| serialized_arguments())
+}
+
+impl From<ToolCallFull> for ToolCall {
+    fn from(value: ToolCallFull) -> Self {
+        let arguments = serialize_tool_call_arguments(&value);
+        let extra_content = value.thought_signature.map(ExtraContent::from);
+
+        Self {
+            id: value.call_id,
+            r#type: FunctionType,
+            function: FunctionCall { arguments, name: Some(value.name) },
+            extra_content,
+        }
+    }
+}
+
+impl From<ContextMessage> for Message {
+    fn from(value: ContextMessage) -> Self {
+        match value {
+            ContextMessage::Text(chat_message) => Message {
+                role: chat_message.role.into(),
+                content: Some(MessageContent::Text(chat_message.content)),
+                name: None,
+                tool_call_id: None,
+                tool_calls: chat_message
+                    .tool_calls
+                    .map(|tool_calls| tool_calls.into_iter().map(ToolCall::from).collect()),
+                reasoning_details: chat_message.reasoning_details.map(|details| {
+                    details
+                        .into_iter()
+                        .map(|detail| ReasoningDetail {
+                            r#type: detail
+                                .type_of
+                                .unwrap_or_else(|| "reasoning.text".to_string()),
+                            text: detail.text,
+                            signature: detail.signature,
+                            data: detail.data,
+                            id: detail.id,
+                            format: detail.format,
+                            index: detail.index,
+                        })
+                        .collect::<Vec<ReasoningDetail>>()
+                }),
+                reasoning_text: None,
+                reasoning_opaque: None,
+                reasoning_content: None,
+                extra_content: chat_message.thought_signature.map(ExtraContent::from),
+            },
+            ContextMessage::Tool(tool_result) => Message {
+                role: Role::Tool,
+                tool_call_id: tool_result.call_id.clone(),
+                name: Some(tool_result.name.clone()),
+                content: Some(tool_result.into()),
+                tool_calls: None,
+                reasoning_details: None,
+                reasoning_text: None,
+                reasoning_opaque: None,
+                reasoning_content: None,
+                extra_content: None,
+            },
+            ContextMessage::Image(img) => {
+                let content = vec![ContentPart::ImageUrl {
+                    image_url: ImageUrl { url: img.url().clone(), detail: None },
+                    cache_control: None,
+                }];
+                Message {
+                    role: Role::User,
+                    content: Some(MessageContent::Parts(content)),
+                    name: None,
+                    tool_call_id: None,
+                    tool_calls: None,
+                    reasoning_details: None,
+                    reasoning_text: None,
+                    reasoning_opaque: None,
+                    reasoning_content: None,
+                    extra_content: None,
+                }
+            }
+        }
+    }
+}
+
+impl From<ToolResult> for MessageContent {
+    fn from(result: ToolResult) -> Self {
+        if result.output.values.len() == 1
+            && let Some(text) = result.output.as_str()
+        {
+            return MessageContent::Text(text.to_string());
+        }
+        let mut parts = Vec::new();
+        for value in result.output.values.into_iter() {
+            match value {
+                ToolValue::Text(text) => {
+                    parts.push(ContentPart::Text { text, cache_control: None });
+                }
+                ToolValue::Image(img) => {
+                    let content = ContentPart::ImageUrl {
+                        image_url: ImageUrl { url: img.url().clone(), detail: None },
+                        cache_control: None,
+                    };
+                    parts.push(content);
+                }
+                ToolValue::Empty => {
+                    // Handle empty case if needed
+                }
+                ToolValue::AI { value, .. } => {
+                    parts.push(ContentPart::Text { text: value, cache_control: None })
+                }
+            }
+        }
+
+        MessageContent::Parts(parts)
+    }
+}
+
+impl From<forge_domain::Role> for Role {
+    fn from(role: forge_domain::Role) -> Self {
+        match role {
+            forge_domain::Role::System => Role::System,
+            forge_domain::Role::User => Role::User,
+            forge_domain::Role::Assistant => Role::Assistant,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Display, Serialize, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Role {
+    System,
+    User,
+    Assistant,
+    Tool,
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_cached_text_true() {
+        let fixture = MessageContent::Text("hello".to_string());
+        let actual = fixture.cached(true);
+        let expected = MessageContent::Parts(vec![ContentPart::Text {
+            text: "hello".to_string(),
+            cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+        }]);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cached_text_false() {
+        let fixture = MessageContent::Text("hello".to_string());
+        let actual = fixture.cached(false);
+        let expected = MessageContent::Text("hello".to_string());
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cached_parts_true() {
+        let fixture = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+        ]);
+        let actual = fixture.cached(true);
+        let expected = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+        ]);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cached_parts_multi_false() {
+        let fixture = MessageContent::Parts(vec![
+            ContentPart::Text {
+                text: "a".to_string(),
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+            ContentPart::Text {
+                text: "b".to_string(),
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+        ]);
+        let actual = fixture.cached(false);
+        let expected = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::Text { text: "b".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: None,
+            },
+        ]);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cached_parts_already_true() {
+        let fixture = MessageContent::Parts(vec![
+            ContentPart::Text {
+                text: "a".to_string(),
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+            ContentPart::Text { text: "b".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: None,
+            },
+        ]);
+        let actual = fixture.cached(true);
+        let expected = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::Text { text: "b".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+        ]);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cached_parts_multi_true() {
+        let fixture = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::Text { text: "b".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: None,
+            },
+        ]);
+        let actual = fixture.cached(true);
+        let expected = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::Text { text: "b".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: Some(CacheControl { type_: CacheControlType::Ephemeral }),
+            },
+        ]);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cached_parts_false() {
+        let fixture = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: None,
+            },
+        ]);
+        let actual = fixture.cached(false);
+        let expected = MessageContent::Parts(vec![
+            ContentPart::Text { text: "a".to_string(), cache_control: None },
+            ContentPart::ImageUrl {
+                image_url: ImageUrl { url: "http://example.com/a.png".to_string(), detail: None },
+                cache_control: None,
+            },
+        ]);
+        assert_eq!(actual, expected);
+    }
+
+    use forge_domain::{
+        ContextMessage, Role, TextMessage, ToolCallFull, ToolCallId, ToolCatalog, ToolName,
+        ToolResult,
+    };
+    use insta::assert_json_snapshot;
+
+    #[test]
+    fn test_user_message_conversion() {
+        let user_message = ContextMessage::Text(
+            TextMessage::new(Role::User, "Hello").model(ModelId::new("gpt-3.5-turbo")),
+        );
+        let router_message = Message::from(user_message);
+        assert_json_snapshot!(router_message);
+    }
+
+    #[test]
+    fn test_message_with_special_chars() {
+        let xml_content = r#"Here's some XML content:
+<task>
+    <id>123</id>
+    <description>Test <special> characters</description>
+    <data key="value">
+        <item>1</item>
+        <item>2</item>
+    </data>
+</task>"#;
+
+        let message = ContextMessage::Text(
+            TextMessage::new(Role::User, xml_content).model(ModelId::new("gpt-3.5-turbo")),
+        );
+        let router_message = Message::from(message);
+        assert_json_snapshot!(router_message);
+    }
+
+    #[test]
+    fn test_assistant_message_with_tool_call_conversion() {
+        let tool_call = ToolCallFull {
+            call_id: Some(ToolCallId::new("123")),
+            name: ToolName::new("test_tool"),
+            arguments: serde_json::json!({"key": "value"}).into(),
+            thought_signature: None,
+        };
+
+        let assistant_message = ContextMessage::Text(
+            TextMessage::new(Role::Assistant, "Using tool")
+                .tool_calls(vec![tool_call])
+                .model(ModelId::new("gpt-3.5-turbo")),
+        );
+        let router_message = Message::from(assistant_message);
+        assert_json_snapshot!(router_message);
+    }
+
+    #[test]
+    fn test_assistant_message_with_dump_style_tool_call_arguments_conversion() {
+        let fixture = ToolCatalog::tool_call_patch(
+            "/tmp/file.txt",
+            "new text",
+            "old text",
+            false,
+        )
+        .arguments(
+            serde_json::from_str::<forge_domain::ToolCallArguments>(
+                r#""{\"file_path\":\"/tmp/file.txt\",\"old_string\":\"old text\",\"new_string\":\"new text\",\"replace_all\":false}""#,
+            )
+            .unwrap(),
+        )
+        .call_id(ToolCallId::new("123"));
+
+        let assistant_message = ContextMessage::Text(
+            TextMessage::new(Role::Assistant, "Using tool")
+                .tool_calls(vec![fixture])
+                .model(ModelId::new("gpt-3.5-turbo")),
+        );
+        let actual = Message::from(assistant_message);
+        let actual =
+            serde_json::to_value(actual.tool_calls.expect("Tool calls should exist")).unwrap();
+        let expected = serde_json::json!([
+            {
+                "id": "123",
+                "type": "function",
+                "function": {
+                    "arguments": "{\"file_path\":\"/tmp/file.txt\",\"new_string\":\"new text\",\"old_string\":\"old text\",\"replace_all\":false}",
+                    "name": "patch"
+                }
+            }
+        ]);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_tool_message_conversion() {
+        let tool_result = ToolResult::new(ToolName::new("test_tool"))
+            .call_id(ToolCallId::new("123"))
+            .success(
+                r#"{
+               "user": "John",
+               "age": 30,
+               "address": [{"city": "New York"}, {"city": "San Francisco"}]
+            }"#,
+            );
+
+        let tool_message = ContextMessage::Tool(tool_result);
+        let router_message = Message::from(tool_message);
+        assert_json_snapshot!(router_message);
+    }
+
+    #[test]
+    fn test_tool_message_with_special_chars() {
+        let tool_result = ToolResult::new(ToolName::new("html_tool"))
+            .call_id(ToolCallId::new("456"))
+            .success(
+                r#"{
+                "html": "<div class=\"container\"><p>Hello <World></p></div>",
+                "elements": ["<span>", "<br/>", "<hr>"],
+                "attributes": {
+                    "style": "color: blue; font-size: 12px;",
+                    "data-test": "<test>&value</test>"
+                }
+            }"#,
+            );
+
+        let tool_message = ContextMessage::Tool(tool_result);
+        let router_message = Message::from(tool_message);
+        assert_json_snapshot!(router_message);
+    }
+
+    #[test]
+    fn test_tool_message_typescript_code() {
+        let tool_result = ToolResult::new(ToolName::new("rust_tool"))
+            .call_id(ToolCallId::new("456"))
+            .success(r#"{ "code": "fn main<T>(gt: T) {let b = &gt; }"}"#);
+
+        let tool_message = ContextMessage::Tool(tool_result);
+        let router_message = Message::from(tool_message);
+        assert_json_snapshot!(router_message);
+    }
+
+    #[test]
+    fn test_transform_display() {
+        assert_eq!(
+            serde_json::to_string(&Transform::MiddleOut).unwrap(),
+            "\"middle-out\""
+        );
+    }
+    #[test]
+    fn test_tool_definition_conversion_missing_properties() {
+        // Test case where input_schema is an object type but missing properties field
+        let fixture = {
+            // In schemars 1.0, Schema wraps serde_json::Value, so we create JSON directly
+            let schema_value = serde_json::json!({
+                "$schema": "http://json-schema.org/draft-07/schema#",
+                "title": "Null",
+                "type": "object",
+                "properties": {}
+            });
+            let schema = schemars::Schema::try_from(schema_value).unwrap();
+
+            ToolDefinition::new("test_tool")
+                .description("Test tool")
+                .input_schema(schema)
+        };
+
+        let actual = Tool::from(fixture);
+
+        let expected = Tool {
+            r#type: FunctionType,
+            function: FunctionDescription {
+                description: Some("Test tool".to_string()),
+                name: "test_tool".to_string(),
+                parameters: serde_json::json!({
+                    "$schema": "http://json-schema.org/draft-07/schema#",
+                    "properties": {},
+                    "title": "Null",
+                    "type": "object"
+                }),
+            },
+        };
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_context_conversion_stream_defaults_to_true() {
+        let fixture = forge_domain::Context::default();
+        let actual = Request::from(fixture);
+
+        assert_eq!(actual.stream, Some(true));
+    }
+
+    #[test]
+    fn test_context_conversion_stream_explicit_true() {
+        let fixture = forge_domain::Context::default().stream(true);
+        let actual = Request::from(fixture);
+
+        assert_eq!(actual.stream, Some(true));
+    }
+
+    #[test]
+    fn test_context_conversion_stream_explicit_false() {
+        let fixture = forge_domain::Context::default().stream(false);
+        let actual = Request::from(fixture);
+
+        assert_eq!(actual.stream, Some(false));
+    }
+
+    #[test]
+    fn test_response_format_json_schema_serialization() {
+        use schemars::JsonSchema;
+        use serde::Deserialize;
+
+        #[derive(Deserialize, JsonSchema)]
+        #[allow(dead_code)]
+        #[schemars(title = "test_response")]
+        struct TestResponse {
+            message: String,
+        }
+
+        let schema = schemars::schema_for!(TestResponse);
+        let fixture = forge_domain::Context::default()
+            .response_format(forge_domain::ResponseFormat::JsonSchema(Box::new(schema)));
+
+        let actual = Request::from(fixture);
+
+        assert!(actual.response_format.is_some());
+        let rf = actual.response_format.unwrap();
+
+        // Serialize to JSON to verify the format
+        let json = serde_json::to_string(&rf).unwrap();
+        println!("Serialized response_format: {}", json);
+
+        // Should contain type and json_schema fields
+        assert!(json.contains("\"type\":\"json_schema\""));
+        assert!(json.contains("\"json_schema\""));
+    }
+}

crates/forge_app/src/dto/openai/response.rs

@@ -0,0 +1,1120 @@
+use std::str::FromStr;
+
+use forge_domain::{
+    ChatCompletionMessage, Content, FinishReason, TokenCount, ToolCallFull, ToolCallId,
+    ToolCallPart, ToolName, Usage,
+};
+use serde::{Deserialize, Serialize};
+
+use super::tool_choice::FunctionType;
+use crate::dto::openai::ReasoningDetail;
+use crate::dto::openai::error::{Error, ErrorCode, ErrorResponse};
+
+/// Represents a value that may be either a JSON number or a numeric string.
+#[derive(Deserialize, Debug, Clone, PartialEq, derive_more::TryInto, Serialize)]
+#[serde(untagged)]
+pub enum StringOrF64 {
+    Number(f64),
+    String(String),
+}
+
+/// Epsilon for floating point comparison to handle near-zero costs
+const COST_EPSILON: f64 = 1e-9;
+
+/// Checks if a cost value is non-zero considering floating point precision
+#[inline]
+fn is_non_zero_cost(cost: &f64) -> bool {
+    cost.abs() > COST_EPSILON
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(untagged)]
+pub enum Response {
+    Success {
+        id: String,
+        provider: Option<String>,
+        #[serde(default)]
+        model: Option<String>,
+        choices: Vec<Choice>,
+        #[serde(default)]
+        created: u64,
+        object: Option<String>,
+        system_fingerprint: Option<String>,
+        usage: Option<ResponseUsage>,
+        #[serde(default)]
+        prompt_filter_results: Option<Vec<PromptFilterResult>>,
+    },
+    CostOnly {
+        choices: Vec<Choice>,
+        cost: Option<StringOrF64>,
+    },
+    Failure {
+        error: ErrorResponse,
+    },
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct PromptFilterResult {
+    pub prompt_index: u32,
+    pub content_filter_results: ContentFilterResults,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ContentFilterResults {
+    pub hate: Option<FilterResult>,
+    pub self_harm: Option<FilterResult>,
+    pub sexual: Option<FilterResult>,
+    pub violence: Option<FilterResult>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct FilterResult {
+    pub filtered: bool,
+    pub severity: String,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ResponseUsage {
+    pub prompt_tokens: usize,
+    pub completion_tokens: usize,
+    pub total_tokens: usize,
+    pub cost: Option<f64>,
+    pub prompt_tokens_details: Option<PromptTokenDetails>,
+    pub cost_details: Option<CostDetails>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct CostDetails {
+    pub upstream_inference_cost: Option<f64>,
+    pub upstream_inference_prompt_cost: Option<f64>,
+    pub upstream_inference_completions_cost: Option<f64>,
+}
+
+impl CostDetails {
+    fn total_cost(&self) -> Option<f64> {
+        self.upstream_inference_cost
+            .filter(is_non_zero_cost)
+            .or({
+                match (
+                    self.upstream_inference_prompt_cost,
+                    self.upstream_inference_completions_cost,
+                ) {
+                    (None, None) => None,
+                    (Some(p), None) => Some(p),
+                    (None, Some(c)) => Some(c),
+                    (Some(p), Some(c)) => Some(p + c),
+                }
+            })
+            .filter(is_non_zero_cost)
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct PromptTokenDetails {
+    pub cached_tokens: usize,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(untagged)]
+pub enum Choice {
+    NonChat {
+        finish_reason: Option<String>,
+        text: String,
+        error: Option<ErrorResponse>,
+    },
+    NonStreaming {
+        logprobs: Option<serde_json::Value>,
+        index: u32,
+        finish_reason: Option<String>,
+        message: ResponseMessage,
+        error: Option<ErrorResponse>,
+    },
+    Streaming {
+        finish_reason: Option<String>,
+        delta: ResponseMessage,
+        error: Option<ErrorResponse>,
+    },
+}
+
+/// A message returned by a provider, used for both streaming deltas and
+/// non-streaming responses.
+///
+/// `reasoning` and `reasoning_content` are kept as separate private fields
+/// because some providers (e.g. `moonshotai/Kimi-K2.5-TEE`) emit **both**
+/// keys in the same delta object. Using `#[serde(alias)]` would cause a
+/// `duplicate_field` error in that case. Use [`ResponseMessage::reasoning`]
+/// to read the value in preference order.
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ResponseMessage {
+    pub content: Option<String>,
+    // Private: some providers (e.g. moonshotai/Kimi-K2.5-TEE) emit both keys
+    // in the same delta object. Exposing them directly would let callers
+    // accidentally read only one and miss the other. Use `reasoning()` instead,
+    // which merges them in preference order.
+    reasoning: Option<String>,
+    reasoning_content: Option<String>,
+    pub role: Option<String>,
+    pub tool_calls: Option<Vec<ToolCall>>,
+    pub refusal: Option<String>,
+    pub reasoning_details: Option<Vec<ReasoningDetail>>,
+    // GitHub Copilot format (flat fields instead of array)
+    pub reasoning_text: Option<String>,
+    pub reasoning_opaque: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra_content: Option<ExtraContent>,
+}
+
+impl ResponseMessage {
+    /// Returns the reasoning text. When both `reasoning` and
+    /// `reasoning_content` are present, the longer non-empty value is
+    /// returned; otherwise whichever is non-empty is used.
+    pub fn reasoning(&self) -> Option<&str> {
+        match (self.reasoning.as_deref(), self.reasoning_content.as_deref()) {
+            (Some(a), Some(b)) => {
+                let a = a.trim();
+                let b = b.trim();
+                match (a.is_empty(), b.is_empty()) {
+                    (true, _) => Some(b).filter(|s| !s.is_empty()),
+                    (_, true) => Some(a).filter(|s| !s.is_empty()),
+                    _ => Some(if b.len() > a.len() { b } else { a }),
+                }
+            }
+            (Some(a), None) => Some(a).filter(|s| !s.trim().is_empty()),
+            (None, Some(b)) => Some(b).filter(|s| !s.trim().is_empty()),
+            (None, None) => None,
+        }
+    }
+}
+
+impl From<ReasoningDetail> for forge_domain::ReasoningDetail {
+    fn from(detail: ReasoningDetail) -> Self {
+        forge_domain::ReasoningDetail {
+            text: detail.text,
+            signature: detail.signature,
+            data: detail.data,
+            id: detail.id,
+            format: detail.format,
+            index: detail.index,
+            type_of: Some(detail.r#type),
+        }
+    }
+}
+
+/// Google-specific metadata for Vertex AI thought signatures
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct GoogleMetadata {
+    pub thought_signature: Option<String>,
+}
+
+/// Extra content that may be included by certain providers (e.g., Vertex AI)
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ExtraContent {
+    pub google: Option<GoogleMetadata>,
+}
+
+impl ExtraContent {
+    /// Extracts the thought_signature from the extra content if present
+    pub fn thought_signature(&self) -> Option<String> {
+        self.google
+            .as_ref()
+            .and_then(|g| g.thought_signature.clone())
+    }
+}
+
+impl From<String> for ExtraContent {
+    fn from(thought_signature: String) -> Self {
+        Self {
+            google: Some(GoogleMetadata { thought_signature: Some(thought_signature) }),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ToolCall {
+    pub id: Option<ToolCallId>,
+    pub r#type: FunctionType,
+    pub function: FunctionCall,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra_content: Option<ExtraContent>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct FunctionCall {
+    // Only the first event typically has the name of the function call
+    pub name: Option<ToolName>,
+    #[serde(default)]
+    pub arguments: String,
+}
+
+impl From<ResponseUsage> for Usage {
+    fn from(usage: ResponseUsage) -> Self {
+        let cost = usage
+            .cost
+            .filter(is_non_zero_cost)
+            .or_else(|| {
+                usage
+                    .cost_details
+                    .as_ref()
+                    .and_then(CostDetails::total_cost)
+            })
+            .filter(is_non_zero_cost);
+
+        Usage {
+            prompt_tokens: TokenCount::Actual(usage.prompt_tokens),
+            completion_tokens: TokenCount::Actual(usage.completion_tokens),
+            total_tokens: TokenCount::Actual(usage.total_tokens),
+            cached_tokens: usage
+                .prompt_tokens_details
+                .map(|token_details| TokenCount::Actual(token_details.cached_tokens))
+                .unwrap_or_default(),
+            cost,
+        }
+    }
+}
+
+/// Intermediate representation of GitHub Copilot reasoning fields
+struct GitHubCopilotReasoning {
+    text: Option<String>,
+    data: Option<String>,
+    r#type: Option<String>,
+}
+
+impl GitHubCopilotReasoning {
+    fn into_reasoning_detail(self) -> forge_domain::ReasoningDetail {
+        forge_domain::ReasoningDetail {
+            text: self.text,
+            data: self.data,
+            type_of: self.r#type,
+            ..Default::default()
+        }
+    }
+}
+
+/// Converts GitHub Copilot flat reasoning fields to structured reasoning
+/// details
+fn convert_github_copilot_reasoning(
+    reasoning_text: &Option<String>,
+    reasoning_opaque: &Option<String>,
+) -> Option<Vec<GitHubCopilotReasoning>> {
+    if reasoning_text.is_some() || reasoning_opaque.is_some() {
+        let mut details = Vec::new();
+        if let Some(text) = reasoning_text {
+            details.push(GitHubCopilotReasoning {
+                text: Some(text.clone()),
+                data: None,
+                r#type: Some("reasoning.text".to_string()),
+            });
+        }
+        if let Some(opaque) = reasoning_opaque {
+            details.push(GitHubCopilotReasoning {
+                text: None,
+                data: Some(opaque.clone()),
+                r#type: Some("reasoning.encrypted".to_string()),
+            });
+        }
+        Some(details)
+    } else {
+        None
+    }
+}
+
+impl TryFrom<Response> for ChatCompletionMessage {
+    type Error = anyhow::Error;
+
+    fn try_from(res: Response) -> Result<Self, Self::Error> {
+        match res {
+            Response::Success { choices, usage, prompt_filter_results, .. } => {
+                if let Some(choice) = choices.first() {
+                    // Check if the choice has an error first
+                    let error = match choice {
+                        Choice::NonChat { error, .. } => error,
+                        Choice::NonStreaming { error, .. } => error,
+                        Choice::Streaming { error, .. } => error,
+                    };
+
+                    if let Some(error) = error {
+                        return Err(Error::Response(error.clone()).into());
+                    }
+
+                    let mut response = match choice {
+                        Choice::NonChat { text, finish_reason, .. } => {
+                            ChatCompletionMessage::assistant(Content::full(text)).finish_reason_opt(
+                                finish_reason
+                                    .clone()
+                                    .and_then(|s| FinishReason::from_str(&s).ok()),
+                            )
+                        }
+                        Choice::NonStreaming { message, finish_reason, .. } => {
+                            let mut resp = ChatCompletionMessage::assistant(Content::full(
+                                message.content.clone().unwrap_or_default(),
+                            ))
+                            .finish_reason_opt(
+                                finish_reason
+                                    .clone()
+                                    .and_then(|s| FinishReason::from_str(&s).ok()),
+                            );
+                            if let Some(reasoning) = message.reasoning() {
+                                resp = resp.reasoning(Content::full(reasoning.to_owned()));
+                            }
+
+                            if let Some(thought_signature) = message
+                                .extra_content
+                                .as_ref()
+                                .and_then(ExtraContent::thought_signature)
+                            {
+                                resp = resp.thought_signature(thought_signature);
+                            }
+
+                            if let Some(reasoning_details) = &message.reasoning_details {
+                                let converted_details: Vec<forge_domain::ReasoningFull> =
+                                    reasoning_details
+                                        .clone()
+                                        .into_iter()
+                                        .map(forge_domain::ReasoningFull::from)
+                                        .collect();
+
+                                resp = resp.add_reasoning_detail(forge_domain::Reasoning::Full(
+                                    converted_details,
+                                ));
+                            } else if let Some(details) = convert_github_copilot_reasoning(
+                                &message.reasoning_text,
+                                &message.reasoning_opaque,
+                            ) {
+                                resp = resp.add_reasoning_detail(forge_domain::Reasoning::Full(
+                                    details
+                                        .into_iter()
+                                        .map(GitHubCopilotReasoning::into_reasoning_detail)
+                                        .collect(),
+                                ));
+                            }
+
+                            if let Some(tool_calls) = &message.tool_calls {
+                                for tool_call in tool_calls {
+                                    let thought_signature = tool_call
+                                        .extra_content
+                                        .as_ref()
+                                        .and_then(ExtraContent::thought_signature);
+
+                                    resp = resp.add_tool_call(ToolCallFull {
+                                        call_id: tool_call.id.clone(),
+                                        name: tool_call
+                                            .function
+                                            .name
+                                            .clone()
+                                            .ok_or(forge_domain::Error::ToolCallMissingName)?,
+                                        arguments: serde_json::from_str(
+                                            &tool_call.function.arguments,
+                                        )?,
+                                        thought_signature,
+                                    });
+                                }
+                            }
+                            resp
+                        }
+                        Choice::Streaming { delta, finish_reason, .. } => {
+                            let mut resp = ChatCompletionMessage::assistant(Content::part(
+                                delta.content.clone().unwrap_or_default(),
+                            ))
+                            .finish_reason_opt(
+                                finish_reason
+                                    .clone()
+                                    .and_then(|s| FinishReason::from_str(&s).ok()),
+                            );
+
+                            if let Some(reasoning) = delta.reasoning() {
+                                resp = resp.reasoning(Content::part(reasoning.to_owned()));
+                            }
+
+                            if let Some(thought_signature) = delta
+                                .extra_content
+                                .as_ref()
+                                .and_then(ExtraContent::thought_signature)
+                            {
+                                resp = resp.thought_signature(thought_signature);
+                            }
+
+                            if let Some(reasoning_details) = &delta.reasoning_details {
+                                let converted_details: Vec<forge_domain::ReasoningPart> =
+                                    reasoning_details
+                                        .clone()
+                                        .into_iter()
+                                        .map(forge_domain::ReasoningPart::from)
+                                        .collect();
+                                resp = resp.add_reasoning_detail(forge_domain::Reasoning::Part(
+                                    converted_details,
+                                ));
+                            } else if let Some(details) = convert_github_copilot_reasoning(
+                                &delta.reasoning_text,
+                                &delta.reasoning_opaque,
+                            ) {
+                                resp = resp.add_reasoning_detail(forge_domain::Reasoning::Part(
+                                    details
+                                        .into_iter()
+                                        .map(GitHubCopilotReasoning::into_reasoning_detail)
+                                        .collect(),
+                                ));
+                            }
+
+                            if let Some(tool_calls) = &delta.tool_calls {
+                                for tool_call in tool_calls {
+                                    let thought_signature = tool_call
+                                        .extra_content
+                                        .as_ref()
+                                        .and_then(ExtraContent::thought_signature);
+
+                                    resp = resp.add_tool_call(ToolCallPart {
+                                        call_id: tool_call.id.clone(),
+                                        name: tool_call.function.name.clone(),
+                                        arguments_part: tool_call.function.arguments.clone(),
+                                        thought_signature,
+                                    });
+                                }
+                            }
+                            resp
+                        }
+                    };
+
+                    if let Some(usage) = usage {
+                        response.usage = Some(usage.into());
+                    }
+                    Ok(response)
+                } else {
+                    // Check if content was filtered
+                    if let Some(filter_results) = prompt_filter_results
+                        && let Some(filter_result) = filter_results.first()
+                    {
+                        let filtered_categories: Vec<String> = [
+                            filter_result
+                                .content_filter_results
+                                .hate
+                                .as_ref()
+                                .filter(|f| f.filtered)
+                                .map(|_| "hate"),
+                            filter_result
+                                .content_filter_results
+                                .self_harm
+                                .as_ref()
+                                .filter(|f| f.filtered)
+                                .map(|_| "self_harm"),
+                            filter_result
+                                .content_filter_results
+                                .sexual
+                                .as_ref()
+                                .filter(|f| f.filtered)
+                                .map(|_| "sexual"),
+                            filter_result
+                                .content_filter_results
+                                .violence
+                                .as_ref()
+                                .filter(|f| f.filtered)
+                                .map(|_| "violence"),
+                        ]
+                        .into_iter()
+                        .flatten()
+                        .map(String::from)
+                        .collect();
+
+                        if !filtered_categories.is_empty() {
+                            let error = ErrorResponse::default()
+                                .message(format!(
+                                    "Content was filtered due to: {}",
+                                    filtered_categories.join(", ")
+                                ))
+                                .code(ErrorCode::String("content_filter".to_string()));
+                            return Err(Error::Response(error).into());
+                        }
+                    }
+
+                    let mut default_response = ChatCompletionMessage::assistant(Content::full(""));
+                    // No choices – this can happen with Ollama/LMStudio streaming where the final
+                    // chunk only contains usage information.
+                    if let Some(u) = usage {
+                        default_response.usage = Some(u.into());
+                    }
+                    Ok(default_response)
+                }
+            }
+            Response::CostOnly { cost, .. } => {
+                let mut msg = ChatCompletionMessage::default();
+                if let Some(c) = cost {
+                    let cost_value = match c {
+                        StringOrF64::Number(n) => n,
+                        StringOrF64::String(s) => s.parse().unwrap_or(0.0),
+                    };
+                    msg.usage = Some(Usage {
+                        prompt_tokens: TokenCount::Actual(0),
+                        completion_tokens: TokenCount::Actual(0),
+                        total_tokens: TokenCount::Actual(0),
+                        cached_tokens: TokenCount::Actual(0),
+                        cost: Some(cost_value),
+                    });
+                }
+                Ok(msg)
+            }
+            Response::Failure { error } => Err(Error::Response(error).into()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Context;
+    use forge_domain::ChatCompletionMessage;
+
+    use super::*;
+
+    struct Fixture;
+
+    fn response_message(
+        reasoning: Option<&str>,
+        reasoning_content: Option<&str>,
+    ) -> ResponseMessage {
+        ResponseMessage {
+            content: None,
+            reasoning: reasoning.map(str::to_owned),
+            reasoning_content: reasoning_content.map(str::to_owned),
+            role: None,
+            tool_calls: None,
+            refusal: None,
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            extra_content: None,
+        }
+    }
+
+    #[test]
+    fn test_reasoning_only_reasoning_field() {
+        let fixture = response_message(Some("hello"), None);
+        assert_eq!(fixture.reasoning(), Some("hello"));
+    }
+
+    #[test]
+    fn test_reasoning_only_reasoning_content_field() {
+        let fixture = response_message(None, Some("hello"));
+        assert_eq!(fixture.reasoning(), Some("hello"));
+    }
+
+    #[test]
+    fn test_reasoning_both_returns_longer() {
+        let fixture = response_message(Some("short"), Some("much longer text"));
+        assert_eq!(fixture.reasoning(), Some("much longer text"));
+    }
+
+    #[test]
+    fn test_reasoning_both_equal_length_returns_reasoning() {
+        let fixture = response_message(Some("aaa"), Some("bbb"));
+        assert_eq!(fixture.reasoning(), Some("aaa"));
+    }
+
+    #[test]
+    fn test_reasoning_both_present_one_empty_returns_non_empty() {
+        let fixture = response_message(Some(""), Some("content"));
+        assert_eq!(fixture.reasoning(), Some("content"));
+    }
+
+    #[test]
+    fn test_reasoning_both_empty_returns_none() {
+        let fixture = response_message(Some(""), Some(""));
+        assert_eq!(fixture.reasoning(), None);
+    }
+
+    #[test]
+    fn test_reasoning_neither_present_returns_none() {
+        let fixture = response_message(None, None);
+        assert_eq!(fixture.reasoning(), None);
+    }
+
+    async fn load_fixture(filename: &str) -> serde_json::Value {
+        let fixture_path = format!("src/dto/openai/fixtures/{}", filename);
+        let fixture_content = tokio::fs::read_to_string(&fixture_path)
+            .await
+            .unwrap_or_else(|_| panic!("Failed to read fixture file: {}", fixture_path));
+        serde_json::from_str(&fixture_content)
+            .unwrap_or_else(|_| panic!("Failed to parse JSON fixture: {}", fixture_path))
+    }
+
+    impl Fixture {
+        // check if the response is compatible with the
+        fn test_response_compatibility(message: &str) -> bool {
+            let response = serde_json::from_str::<Response>(message)
+                .with_context(|| format!("Failed to parse response: {message}"))
+                .and_then(|event| {
+                    ChatCompletionMessage::try_from(event.clone())
+                        .with_context(|| "Failed to create completion message")
+                });
+            response.is_ok()
+        }
+    }
+
+    #[test]
+    fn test_open_ai_response_event() {
+        let event = "{\"id\":\"chatcmpl-B2YVxGR9TaLBrEcFMVCv2B4IcNe4g\",\"object\":\"chat.completion.chunk\",\"created\":1739949029,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_00428b782a\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":null,\"tool_calls\":[{\"index\":0,\"id\":\"call_fmuXMsHhKD5eM2k0CvgNed53\",\"type\":\"function\",\"function\":{\"name\":\"shell\",\"arguments\":\"\"}}],\"refusal\":null},\"logprobs\":null,\"finish_reason\":null}]}";
+        assert!(Fixture::test_response_compatibility(event));
+    }
+
+    #[test]
+    fn test_forge_response_event() {
+        let event = "{\"id\":\"gen-1739949430-JZMcABaj4fg8oFDtRNDZ\",\"provider\":\"OpenAI\",\"model\":\"openai/gpt-4o-mini\",\"object\":\"chat.completion.chunk\",\"created\":1739949430,\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":null,\"tool_calls\":[{\"index\":0,\"id\":\"call_bhjvz9w48ov4DSRhM15qLMmh\",\"type\":\"function\",\"function\":{\"name\":\"shell\",\"arguments\":\"\"}}],\"refusal\":null},\"logprobs\":null,\"finish_reason\":null,\"native_finish_reason\":null}],\"system_fingerprint\":\"fp_00428b782a\"}";
+        assert!(Fixture::test_response_compatibility(event));
+    }
+
+    #[test]
+    fn test_reasoning_response_event() {
+        let event = "{\"id\":\"gen-1751626123-nYRpHzdA0thRXF0LoQi0\",\"provider\":\"Google\",\"model\":\"anthropic/claude-3.7-sonnet:thinking\",\"object\":\"chat.completion.chunk\",\"created\":1751626123,\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\",\"reasoning\":\"I need to check\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"I need to check\"}]},\"finish_reason\":null,\"native_finish_reason\":null,\"logprobs\":null}]}";
+        assert!(Fixture::test_response_compatibility(event));
+    }
+
+    #[tokio::test]
+    async fn test_kimi_k2_both_reasoning_keys_event() {
+        // moonshotai/Kimi-K2.5-TEE emits both "reasoning" and "reasoning_content"
+        // in the same delta object. This must parse without a duplicate_field error.
+        let fixture = load_fixture("chutes_completion_response.json").await;
+        let actual = serde_json::from_value::<Response>(fixture);
+        assert!(actual.is_ok(), "Failed to parse: {:?}", actual.err());
+        let completion_result = ChatCompletionMessage::try_from(actual.unwrap());
+        assert!(completion_result.is_ok());
+    }
+
+    #[test]
+    fn test_fireworks_response_event_missing_arguments() {
+        let event = "{\"id\":\"gen-1749331907-SttL6PXleVHnrdLMABfU\",\"provider\":\"Fireworks\",\"model\":\"qwen/qwen3-235b-a22b\",\"object\":\"chat.completion.chunk\",\"created\":1749331907,\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":null,\"tool_calls\":[{\"index\":0,\"id\":\"call_Wl2L8rrzHwrXSeiciIvU65IS\",\"type\":\"function\",\"function\":{\"name\":\"attempt_completion\"}}]},\"finish_reason\":null,\"native_finish_reason\":null,\"logprobs\":null}]}";
+        assert!(Fixture::test_response_compatibility(event));
+    }
+
+    #[tokio::test]
+    async fn test_responses() -> anyhow::Result<()> {
+        let content = forge_test_kit::fixture!("/src/dto/openai/responses.jsonl").await;
+
+        for (i, line) in content.split('\n').enumerate() {
+            let i = i + 1;
+            let _: Response = serde_json::from_str(line).with_context(|| {
+                format!("Failed to parse response [responses.jsonl:{i}]: {line}")
+            })?;
+        }
+
+        Ok(())
+    }
+    #[test]
+    fn test_choice_error_handling_non_chat() {
+        let error_response = ErrorResponse::default().message("Test error message".to_string());
+
+        let response = Response::Success {
+            id: "test-id".to_string(),
+            provider: Some("test".to_string()),
+            model: Some("test-model".to_string()),
+            choices: vec![Choice::NonChat {
+                text: "test content".to_string(),
+                finish_reason: None,
+                error: Some(error_response.clone()),
+            }],
+            created: 123456789,
+            object: Some("chat.completion".to_string()),
+            system_fingerprint: None,
+            usage: None,
+            prompt_filter_results: None,
+        };
+
+        let result = ChatCompletionMessage::try_from(response);
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+        let error_string = format!("{:?}", error);
+        assert!(error_string.contains("Test error message"));
+    }
+
+    #[test]
+    fn test_choice_error_handling_non_streaming() {
+        let error_response = ErrorResponse::default().message("API limit exceeded".to_string());
+
+        let response = Response::Success {
+            id: "test-id".to_string(),
+            provider: Some("test".to_string()),
+            model: Some("test-model".to_string()),
+            choices: vec![Choice::NonStreaming {
+                logprobs: None,
+                index: 0,
+                finish_reason: None,
+                message: ResponseMessage {
+                    content: Some("test content".to_string()),
+                    reasoning: None,
+                    reasoning_content: None,
+                    role: Some("assistant".to_string()),
+                    tool_calls: None,
+                    refusal: None,
+                    reasoning_details: None,
+                    reasoning_text: None,
+                    reasoning_opaque: None,
+                    extra_content: None,
+                },
+                error: Some(error_response.clone()),
+            }],
+            created: 123456789,
+            object: Some("chat.completion".to_string()),
+            system_fingerprint: None,
+            usage: None,
+            prompt_filter_results: None,
+        };
+
+        let result = ChatCompletionMessage::try_from(response);
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+        let error_string = format!("{:?}", error);
+        assert!(error_string.contains("API limit exceeded"));
+    }
+
+    #[test]
+    fn test_choice_error_handling_streaming() {
+        let error_response = ErrorResponse::default().message("Stream interrupted".to_string());
+
+        let response = Response::Success {
+            id: "test-id".to_string(),
+            provider: Some("test".to_string()),
+            model: Some("test-model".to_string()),
+            choices: vec![Choice::Streaming {
+                finish_reason: None,
+                delta: ResponseMessage {
+                    content: Some("test content".to_string()),
+                    reasoning: None,
+                    reasoning_content: None,
+                    role: Some("assistant".to_string()),
+                    tool_calls: None,
+                    refusal: None,
+                    reasoning_details: None,
+                    reasoning_text: None,
+                    reasoning_opaque: None,
+                    extra_content: None,
+                },
+                error: Some(error_response.clone()),
+            }],
+            created: 123456789,
+            object: Some("chat.completion".to_string()),
+            system_fingerprint: None,
+            usage: None,
+            prompt_filter_results: None,
+        };
+
+        let result = ChatCompletionMessage::try_from(response);
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+        let error_string = format!("{:?}", error);
+        assert!(error_string.contains("Stream interrupted"));
+    }
+
+    #[test]
+    fn test_choice_no_error_success() {
+        let response = Response::Success {
+            id: "test-id".to_string(),
+            provider: Some("test".to_string()),
+            model: Some("test-model".to_string()),
+            choices: vec![Choice::NonStreaming {
+                logprobs: None,
+                index: 0,
+                finish_reason: Some("stop".to_string()),
+                message: ResponseMessage {
+                    content: Some("Hello, world!".to_string()),
+                    reasoning: None,
+                    reasoning_content: None,
+                    role: Some("assistant".to_string()),
+                    tool_calls: None,
+                    refusal: None,
+                    reasoning_details: None,
+                    reasoning_text: None,
+                    reasoning_opaque: None,
+                    extra_content: None,
+                },
+                error: None,
+            }],
+            created: 123456789,
+            object: Some("chat.completion".to_string()),
+            system_fingerprint: None,
+            usage: None,
+            prompt_filter_results: None,
+        };
+
+        let result = ChatCompletionMessage::try_from(response);
+        assert!(result.is_ok());
+        let message = result.unwrap();
+        assert_eq!(message.content.unwrap().as_str(), "Hello, world!");
+    }
+
+    #[test]
+    fn test_empty_choices_no_error() {
+        let response = Response::Success {
+            id: "test-id".to_string(),
+            provider: Some("test".to_string()),
+            model: Some("test-model".to_string()),
+            choices: vec![],
+            created: 123456789,
+            object: Some("chat.completion".to_string()),
+            system_fingerprint: None,
+            usage: None,
+            prompt_filter_results: None,
+        };
+
+        let result = ChatCompletionMessage::try_from(response);
+        assert!(result.is_ok());
+        let message = result.unwrap();
+        assert_eq!(message.content.unwrap().as_str(), "");
+    }
+
+    #[test]
+    fn test_cost_only_response_parses_and_returns_empty_message() {
+        let fixture = r#"{"choices":[],"cost":"0"}"#;
+        let actual = serde_json::from_str::<Response>(fixture).unwrap();
+
+        let actual = ChatCompletionMessage::try_from(actual).unwrap();
+
+        // CostOnly events now include the cost in the usage
+        let expected = ChatCompletionMessage::default().usage(Usage {
+            prompt_tokens: TokenCount::Actual(0),
+            completion_tokens: TokenCount::Actual(0),
+            total_tokens: TokenCount::Actual(0),
+            cached_tokens: TokenCount::Actual(0),
+            cost: Some(0.0),
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cost_only_response_numeric_cost_parses() {
+        let fixture = r#"{"choices":[],"cost":0.0}"#;
+        let actual = serde_json::from_str::<Response>(fixture);
+
+        assert!(actual.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_z_ai_response_compatibility() {
+        let fixture = load_fixture("zai_api_delta_response.json").await;
+        let actual = serde_json::from_value::<Response>(fixture);
+
+        assert!(actual.is_ok());
+
+        let response = actual.unwrap();
+        let completion_result = ChatCompletionMessage::try_from(response);
+        assert!(completion_result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_z_ai_response_complete_with_usage() {
+        let fixture = load_fixture("zai_api_response.json").await;
+        let actual = serde_json::from_value::<Response>(fixture);
+
+        assert!(actual.is_ok());
+
+        let response = actual.unwrap();
+        let completion_result = ChatCompletionMessage::try_from(response);
+        assert!(completion_result.is_ok());
+    }
+
+    #[test]
+    fn test_response_usage_cost_priority_chain() {
+        // Priority 1: cost field (non-zero) beats everything
+        let fixture_cost_wins = ResponseUsage {
+            prompt_tokens: 100,
+            completion_tokens: 50,
+            total_tokens: 150,
+            cost: Some(0.001),
+            prompt_tokens_details: None,
+            cost_details: Some(CostDetails {
+                upstream_inference_cost: Some(0.005),
+                upstream_inference_prompt_cost: Some(0.003),
+                upstream_inference_completions_cost: Some(0.002),
+            }),
+        };
+
+        let actual: Usage = fixture_cost_wins.into();
+        assert_eq!(actual.cost, Some(0.001));
+
+        // Priority 2: upstream_inference_cost beats partial costs
+        let fixture_upstream_wins = ResponseUsage {
+            prompt_tokens: 100,
+            completion_tokens: 50,
+            total_tokens: 150,
+            cost: None,
+            prompt_tokens_details: None,
+            cost_details: Some(CostDetails {
+                upstream_inference_cost: Some(0.005),
+                upstream_inference_prompt_cost: Some(0.003),
+                upstream_inference_completions_cost: Some(0.002),
+            }),
+        };
+
+        let actual: Usage = fixture_upstream_wins.into();
+        assert_eq!(actual.cost, Some(0.005));
+
+        // Priority 3: partial costs are summed when upstream_inference_cost is None
+        let fixture_partial_sum = ResponseUsage {
+            prompt_tokens: 100,
+            completion_tokens: 50,
+            total_tokens: 150,
+            cost: None,
+            prompt_tokens_details: None,
+            cost_details: Some(CostDetails {
+                upstream_inference_cost: None,
+                upstream_inference_prompt_cost: Some(0.003),
+                upstream_inference_completions_cost: Some(0.002),
+            }),
+        };
+
+        let actual: Usage = fixture_partial_sum.into();
+        assert_eq!(actual.cost, Some(0.005));
+
+        // Priority 4: when upstream_inference_cost is 0 then compute it from other
+        // parameters.
+        let fixture = ResponseUsage {
+            prompt_tokens: 100,
+            completion_tokens: 50,
+            total_tokens: 150,
+            cost: None,
+            prompt_tokens_details: None,
+            cost_details: Some(CostDetails {
+                upstream_inference_cost: Some(0.0),
+                upstream_inference_prompt_cost: Some(0.003),
+                upstream_inference_completions_cost: Some(0.002),
+            }),
+        };
+
+        let actual: Usage = fixture.into();
+        assert_eq!(actual.cost, Some(0.005));
+    }
+
+    #[test]
+    fn test_zero_cost_should_fallback_to_cost_details() {
+        let fixture = ResponseUsage {
+            prompt_tokens: 100,
+            completion_tokens: 50,
+            total_tokens: 150,
+            cost: Some(0.0),
+            prompt_tokens_details: None,
+            cost_details: Some(CostDetails {
+                upstream_inference_cost: Some(0.005),
+                upstream_inference_prompt_cost: None,
+                upstream_inference_completions_cost: None,
+            }),
+        };
+
+        let actual: Usage = fixture.into();
+        assert_eq!(actual.cost, Some(0.005));
+    }
+
+    #[test]
+    fn test_near_zero_cost_should_fallback_to_cost_details() {
+        let fixture = ResponseUsage {
+            prompt_tokens: 100,
+            completion_tokens: 50,
+            total_tokens: 150,
+            cost: Some(1e-10),
+            prompt_tokens_details: None,
+            cost_details: Some(CostDetails {
+                upstream_inference_cost: Some(0.005),
+                upstream_inference_prompt_cost: None,
+                upstream_inference_completions_cost: None,
+            }),
+        };
+
+        let actual: Usage = fixture.into();
+        assert_eq!(actual.cost, Some(0.005));
+    }
+
+    #[test]
+    fn test_github_copilot_content_filter_response() {
+        let response_json = r#"{
+            "choices": [],
+            "created": 0,
+            "id": "",
+            "prompt_filter_results": [{
+                "content_filter_results": {
+                    "hate": {"filtered": false, "severity": "safe"},
+                    "self_harm": {"filtered": false, "severity": "safe"},
+                    "sexual": {"filtered": false, "severity": "safe"},
+                    "violence": {"filtered": false, "severity": "safe"}
+                },
+                "prompt_index": 0
+            }]
+        }"#;
+
+        let actual = serde_json::from_str::<Response>(response_json);
+        assert!(
+            actual.is_ok(),
+            "Should parse GitHub Copilot filter response: {:?}",
+            actual.err()
+        );
+    }
+
+    #[test]
+    fn test_github_copilot_filtered_content_error() {
+        let response = Response::Success {
+            id: "".to_string(),
+            provider: None,
+            model: Some("gpt-5".to_string()),
+            choices: vec![],
+            created: 0,
+            object: None,
+            system_fingerprint: None,
+            usage: None,
+            prompt_filter_results: Some(vec![PromptFilterResult {
+                prompt_index: 0,
+                content_filter_results: ContentFilterResults {
+                    hate: Some(FilterResult { filtered: true, severity: "high".to_string() }),
+                    self_harm: Some(FilterResult { filtered: false, severity: "safe".to_string() }),
+                    sexual: Some(FilterResult { filtered: false, severity: "safe".to_string() }),
+                    violence: Some(FilterResult { filtered: false, severity: "safe".to_string() }),
+                },
+            }]),
+        };
+
+        let result = ChatCompletionMessage::try_from(response);
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+        let error_string = format!("{:?}", error);
+        assert!(error_string.contains("Content was filtered"));
+        assert!(error_string.contains("hate"));
+    }
+
+    #[test]
+    fn test_nvidia_tool_call_streaming_chunk() {
+        let response_json = r#"{"id":"chatcmpl-994182aa3bf1d873","object":"chat.completion.chunk","created":1775363363,"model":"qwen/qwen3.5-397b-a17b","choices":[{"index":0,"delta":{"content":null,"reasoning":null,"reasoning_content":null,"tool_calls":[{"index":1,"function":{"arguments":"}"}}]},"logprobs":null,"finish_reason":"tool_calls","stop_reason":null,"token_ids":null}]}"#;
+
+        let actual = serde_json::from_str::<Response>(response_json);
+        assert!(
+            actual.is_ok(),
+            "Should parse NVIDIA tool call streaming chunk: {:?}",
+            actual.err()
+        );
+    }
+
+    #[test]
+    fn test_nvidia_tool_call_deserialization() {
+        // NVIDIA sends tool calls without "id" and "type" fields
+        let tool_call_json = r#"{"index":1,"function":{"arguments":"}"}}"#;
+        let actual = serde_json::from_str::<ToolCall>(tool_call_json);
+        assert!(
+            actual.is_ok(),
+            "Should parse NVIDIA tool call: {:?}",
+            actual.err()
+        );
+    }
+
+    #[test]
+    fn test_nvidia_response_message_deserialization() {
+        let msg_json = r#"{"content":null,"reasoning":null,"reasoning_content":null,"tool_calls":[{"index":1,"function":{"arguments":"}"}}]}"#;
+        let actual = serde_json::from_str::<ResponseMessage>(msg_json);
+        assert!(
+            actual.is_ok(),
+            "Should parse NVIDIA response message: {:?}",
+            actual.err()
+        );
+    }
+
+    #[test]
+    fn test_nvidia_choice_deserialization() {
+        let choice_json = r#"{"index":0,"delta":{"content":null,"reasoning":null,"reasoning_content":null,"tool_calls":[{"index":1,"function":{"arguments":"}"}}]},"logprobs":null,"finish_reason":"tool_calls","stop_reason":null,"token_ids":null}"#;
+        let actual = serde_json::from_str::<Choice>(choice_json);
+        assert!(
+            actual.is_ok(),
+            "Should parse NVIDIA choice: {:?}",
+            actual.err()
+        );
+    }
+}

crates/forge_app/src/dto/openai/responses.jsonl

@@ -0,0 +1,20 @@
+{"error": {"code": "ERR_STREAM_PREMATURE_CLOSE"}}
+{"error": {"errno": -104, "code": "ECONNRESET", "syscall": "read"}}
+{"error": {"errno": -110, "code": "ETIMEDOUT", "syscall": "read"}}
+{"error": {"error": {"code": "ERR_STREAM_PREMATURE_CLOSE"}}}
+{"error": {"error": {"message": "Provider returned error", "code": 400, "metadata": {"raw": "{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"input length and `max_tokens` exceed context limit: MIN + MAX > 200000, decrease input length or `max_tokens` and try again\"}}", "provider_name": "Google"}}, "code": 400}}
+{"error": {"error": {"message": "Provider returned error", "code": 413, "metadata": {"raw": "{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"Prompt is too long\"}}", "provider_name": "Google"}}, "code": 413}}
+{"error": {"error": {"message": "Provider returned error", "code": 503, "metadata": {"raw": "{\n  \"error\": {\n    \"code\": 503,\n    \"message\": \"The service is currently unavailable.\",\n    \"status\": \"UNAVAILABLE\"\n  }\n}\n", "provider_name": "Google AI Studio"}}, "code": 503}}
+{"error": {"error": {"message": "Rate limit exceeded: limit_rpm/google/gemini-2.5-pro-exp-03-25/e5b7a905-dd02-4f6e-b61b-3aa1a1b8b9c8. ", "code": 429, "metadata": {"headers": {"X-RateLimit-Limit": "1", "X-RateLimit-Remaining": "0", "X-RateLimit-Reset": "1746315180000"}, "provider_name": null}}, "code": 429}}
+{"error": {"error": {"message": "Rate limit exceeded: limit_rpm/google/gemini-2.5-pro-exp-03-25/e5b7a905-dd02-4f6e-b61b-3aa1a1b8b9c8. High demand for google/gemini-2.5-pro-exp-03-25 on OpenRouter - limited to 1 requests per minute. Please retry shortly.", "code": 429, "metadata": {"headers": {"X-RateLimit-Limit": "1", "X-RateLimit-Remaining": "0", "X-RateLimit-Reset": "1746937440000"}, "provider_name": null}}, "code": 429}}
+{"error": {"error": {"message": "This endpoint's maximum context length is 200000 tokens. However, you requested about X tokens (Y of text input). Please reduce the length of either one, or use the \"middle-out\" transform to compress your prompt automatically.", "code": 400, "metadata": {"provider_name": null}}, "code": 400}}
+{"error": {"error": {"message": "Upstream error from Chutes: Requested token count exceeds the model's maximum context length of 32768 tokens. You requested a total of 34689 tokens: 22892 tokens from the input messages and 11797 tokens for the completion. Please reduce the number of tokens in the input messages or the completion to fit within the limit.", "code": 502, "metadata": {"raw": {"object": "error", "message": "Requested token count exceeds the model's maximum context length of 32768 tokens. You requested a total of 34689 tokens: 22892 tokens from the input messages and 11797 tokens for the completion. Please reduce the number of tokens in the input messages or the completion to fit within the limit.", "type": "BadRequestError", "param": null, "code": 400}, "provider_name": "Chutes"}}, "code": 502}}
+{"error": {"message": "400: An error occurred (ValidationException) when calling the ConverseStream operation: The text field in the ContentBlock object at messages.19.content.0 is blank. Add text to the text field, and try again."}}
+{"error": {"message": "500: An error occurred (AccessDeniedException) when calling the ConverseStream operation: User: arn:aws:sts::275481790157:assumed-role/bedrockpartnerawsv1-ProxyApiHandlerServiceRoleBE71B-LZI8y019SUOG/bedrockpartnerawsv1-ProxyApiHandlerEC15A492-1JsCZPLohxs3 is not authorized to perform: bedrock:InvokeModelWithResponseStream on resource: arn:aws:bedrock:us-west-2::foundation-model/anthropic.claude-3-7-sonnet-20250219-v1:0 with an explicit deny in a service control policy"}}
+{"error": {"message": "An error occurred (modelStreamErrorException) when calling the ConverseStream operation: The system encountered an unexpected error during processing. Try your request again."}}
+{"error": {"message": "An error occurred (serviceUnavailableException) when calling the ConverseStream operation: Bedrock is unable to process your request."}}
+{"error": {"message": "An error occurred (validationException) when calling the ConverseStream operation: The model returned the following errors: Input is too long for requested model."}}
+{"error": {"message": "litellm.APIConnectionError: AnthropicException - ", "type": null, "param": null, "code": "500"}}
+{"error": {"message": "litellm.BadRequestError: BedrockException - validationException {\"message\":\"The model returned the following errors: input length and `max_tokens` exceed context limit: 197717 + 8192 > 204698, decrease input length or `max_tokens` and try again\"}", "type": null, "param": null, "code": "400"}}
+{"error": {"message": "litellm.ContextWindowExceededError: litellm.BadRequestError: BedrockException: Context Window Error - validationException {\"message\":\"The model returned the following errors: Input is too long for requested model.\"}", "type": null, "param": null, "code": "400"}}
+{"error": {"message": "litellm.InternalServerError: AnthropicException - Overloaded. Handle with `litellm.InternalServerError`.", "type": null, "param": null, "code": "500"}}

crates/forge_app/src/dto/openai/snapshots/forge_app__dto__openai__request__tests__assistant_message_with_tool_call_conversion.snap

@@ -0,0 +1,18 @@
+---
+source: crates/forge_app/src/dto/openai/request.rs
+expression: router_message
+---
+{
+  "role": "assistant",
+  "content": "Using tool",
+  "tool_calls": [
+    {
+      "id": "123",
+      "type": "function",
+      "function": {
+        "name": "test_tool",
+        "arguments": "{\"key\":\"value\"}"
+      }
+    }
+  ]
+}

crates/forge_app/src/dto/openai/snapshots/forge_app__dto__openai__request__tests__message_with_special_chars.snap

@@ -0,0 +1,8 @@
+---
+source: crates/forge_app/src/dto/openai/request.rs
+expression: router_message
+---
+{
+  "role": "user",
+  "content": "Here's some XML content:\n<task>\n    <id>123</id>\n    <description>Test <special> characters</description>\n    <data key=\"value\">\n        <item>1</item>\n        <item>2</item>\n    </data>\n</task>"
+}

crates/forge_app/src/dto/openai/snapshots/forge_app__dto__openai__request__tests__tool_message_conversion.snap

@@ -0,0 +1,10 @@
+---
+source: crates/forge_app/src/dto/openai/request.rs
+expression: router_message
+---
+{
+  "role": "tool",
+  "content": "{\n               \"user\": \"John\",\n               \"age\": 30,\n               \"address\": [{\"city\": \"New York\"}, {\"city\": \"San Francisco\"}]\n            }",
+  "name": "test_tool",
+  "tool_call_id": "123"
+}

crates/forge_app/src/dto/openai/snapshots/forge_app__dto__openai__request__tests__tool_message_typescript_code.snap

@@ -0,0 +1,10 @@
+---
+source: crates/forge_app/src/dto/openai/request.rs
+expression: router_message
+---
+{
+  "role": "tool",
+  "content": "{ \"code\": \"fn main<T>(gt: T) {let b = &gt; }\"}",
+  "name": "rust_tool",
+  "tool_call_id": "456"
+}

crates/forge_app/src/dto/openai/snapshots/forge_app__dto__openai__request__tests__tool_message_with_special_chars.snap

@@ -0,0 +1,10 @@
+---
+source: crates/forge_app/src/dto/openai/request.rs
+expression: router_message
+---
+{
+  "role": "tool",
+  "content": "{\n                \"html\": \"<div class=\\\"container\\\"><p>Hello <World></p></div>\",\n                \"elements\": [\"<span>\", \"<br/>\", \"<hr>\"],\n                \"attributes\": {\n                    \"style\": \"color: blue; font-size: 12px;\",\n                    \"data-test\": \"<test>&value</test>\"\n                }\n            }",
+  "name": "html_tool",
+  "tool_call_id": "456"
+}

crates/forge_app/src/dto/openai/snapshots/forge_app__dto__openai__request__tests__user_message_conversion.snap

@@ -0,0 +1,8 @@
+---
+source: crates/forge_app/src/dto/openai/request.rs
+expression: router_message
+---
+{
+  "role": "user",
+  "content": "Hello"
+}

crates/forge_app/src/dto/openai/tool_choice.rs

@@ -0,0 +1,81 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ToolChoice {
+    None,
+    Auto,
+    Required,
+    #[serde(untagged)]
+    Function {
+        r#type: FunctionType,
+        function: FunctionName,
+    },
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub struct FunctionName {
+    pub name: String,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct FunctionType;
+
+impl Serialize for FunctionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str("function")
+    }
+}
+
+impl<'de> Deserialize<'de> for FunctionType {
+    fn deserialize<D>(_deserializer: D) -> Result<FunctionType, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        Ok(FunctionType)
+    }
+}
+
+impl From<forge_domain::ToolChoice> for ToolChoice {
+    fn from(value: forge_domain::ToolChoice) -> Self {
+        match value {
+            forge_domain::ToolChoice::None => ToolChoice::None,
+            forge_domain::ToolChoice::Auto => ToolChoice::Auto,
+            forge_domain::ToolChoice::Required => ToolChoice::Required,
+            forge_domain::ToolChoice::Call(tool_name) => ToolChoice::Function {
+                function: FunctionName { name: tool_name.to_string() },
+                r#type: FunctionType,
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tool_choice_serialization() {
+        // Test None variant
+        let choice_none = ToolChoice::None;
+        assert_eq!(serde_json::to_string(&choice_none).unwrap(), r#""none""#);
+
+        // Test Auto variant
+        let choice_auto = ToolChoice::Auto;
+        assert_eq!(serde_json::to_string(&choice_auto).unwrap(), r#""auto""#);
+
+        // Test Function variant
+        let choice_function = ToolChoice::Function {
+            function: FunctionName { name: "test_tool".to_string() },
+            r#type: FunctionType,
+        };
+        assert_eq!(
+            serde_json::to_string(&choice_function).unwrap(),
+            r#"{"type":"function","function":{"name":"test_tool"}}"#
+        );
+    }
+}

crates/forge_app/src/dto/openai/transformers/default_reasoning_content.rs

@@ -0,0 +1,99 @@
+use forge_domain::Transformer;
+
+use crate::dto::openai::Request;
+
+/// Transformer that ensures every message has a `reasoning_content` field set.
+///
+/// DeepSeek requires the `reasoning_content` field to be present on assistant
+/// messages even when there is no reasoning text. When the field is `None` this
+/// transformer falls back to an empty string.
+pub struct DefaultReasoningContent;
+
+impl Transformer for DefaultReasoningContent {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        if let Some(ref mut messages) = request.messages {
+            for message in messages.iter_mut() {
+                if message.reasoning_content.is_none() {
+                    message.reasoning_content = Some(String::new());
+                }
+            }
+        }
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+    use crate::dto::openai::{Message, MessageContent, Request, Role};
+
+    #[test]
+    fn test_sets_empty_string_when_reasoning_content_is_none() {
+        let fixture = Request::default().messages(vec![Message {
+            role: Role::Assistant,
+            content: Some(MessageContent::Text("test".to_string())),
+            name: None,
+            tool_call_id: None,
+            tool_calls: None,
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: None,
+            extra_content: None,
+        }]);
+
+        let actual = DefaultReasoningContent.transform(fixture);
+
+        let messages = actual.messages.unwrap();
+        let msg = messages.first().unwrap();
+        assert_eq!(msg.reasoning_content, Some(String::new()));
+    }
+
+    #[test]
+    fn test_preserves_existing_reasoning_content() {
+        let fixture = Request::default().messages(vec![Message {
+            role: Role::Assistant,
+            content: Some(MessageContent::Text("test".to_string())),
+            name: None,
+            tool_call_id: None,
+            tool_calls: None,
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: Some("thinking...".to_string()),
+            extra_content: None,
+        }]);
+
+        let actual = DefaultReasoningContent.transform(fixture);
+
+        let messages = actual.messages.unwrap();
+        let msg = messages.first().unwrap();
+        assert_eq!(msg.reasoning_content, Some("thinking...".to_string()));
+    }
+
+    #[test]
+    fn test_preserves_preserves_empty_string_when_already_set() {
+        let fixture = Request::default().messages(vec![Message {
+            role: Role::Assistant,
+            content: Some(MessageContent::Text("test".to_string())),
+            name: None,
+            tool_call_id: None,
+            tool_calls: None,
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: Some(String::new()),
+            extra_content: None,
+        }]);
+
+        let actual = DefaultReasoningContent.transform(fixture);
+
+        let messages = actual.messages.unwrap();
+        let msg = messages.first().unwrap();
+        assert_eq!(msg.reasoning_content, Some(String::new()));
+    }
+}

crates/forge_app/src/dto/openai/transformers/drop_tool_call.rs

@@ -0,0 +1,89 @@
+use forge_domain::Transformer;
+
+use crate::dto::openai::{Request, Role};
+
+/// Drops all tool call messages and converts them to user/assistant messages
+pub struct DropToolCalls;
+
+impl Transformer for DropToolCalls {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        if let Some(messages) = request.messages.as_mut() {
+            for message in messages.iter_mut() {
+                // Convert tool messages to user messages
+                if message.role == Role::Tool {
+                    message.role = Role::User;
+                    message.tool_calls = None;
+                    message.tool_call_id = None;
+                    message.name = None;
+                }
+                // Remove tool calls from assistant messages
+                if message.role == Role::Assistant {
+                    message.tool_calls = None;
+                }
+            }
+        }
+
+        // Reset the tools field
+        request.tools = None;
+
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use forge_domain::{
+        Context, ContextMessage, Role, TextMessage, ToolCallFull, ToolCallId, ToolName, ToolResult,
+    };
+
+    use super::*;
+
+    #[test]
+    fn test_mistral_transformer_tools_not_supported() {
+        let tool_call = ToolCallFull {
+            call_id: Some(ToolCallId::new("123")),
+            name: ToolName::new("test_tool"),
+            arguments: serde_json::json!({"key": "value"}).into(),
+            thought_signature: None,
+        };
+
+        let tool_result = ToolResult::new(ToolName::new("test_tool"))
+            .call_id(ToolCallId::new("123"))
+            .success("test result");
+
+        let context = Context {
+            conversation_id: None,
+            messages: vec![
+                ContextMessage::Text(
+                    TextMessage::new(Role::Assistant, "Using tool").tool_calls(vec![tool_call]),
+                )
+                .into(),
+                ContextMessage::Tool(tool_result).into(),
+            ],
+            tools: vec![forge_domain::ToolDefinition::new("test_tool").description("A test tool")],
+            tool_choice: None,
+            max_tokens: None,
+            temperature: None,
+            top_p: None,
+            top_k: None,
+            reasoning: None,
+            stream: None,
+            response_format: None,
+            initiator: None,
+        };
+
+        let request = Request::from(context);
+        let mut transformer = DropToolCalls;
+        let transformed = transformer.transform(request);
+
+        let messages = transformed.messages.unwrap();
+        // Assistant message
+        assert!(messages[0].tool_calls.is_none());
+        // Converted tool message
+        assert_eq!(messages[1].role, Role::User.into());
+        // Tools field should be reset
+        assert!(transformed.tools.is_none());
+    }
+}

crates/forge_app/src/dto/openai/transformers/ensure_system_first.rs

@@ -0,0 +1,198 @@
+use forge_domain::Transformer;
+
+use crate::dto::openai::{Message, MessageContent, Request, Role};
+
+/// Merges all system messages into a single system message at the beginning of
+/// the messages array.
+///
+/// Some providers (e.g. NVIDIA, vLLM) reject requests with multiple system
+/// messages or system messages that are not positioned at the start of the
+/// conversation.
+pub struct MergeSystemMessages;
+
+impl Transformer for MergeSystemMessages {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        if let Some(messages) = request.messages.take() {
+            let (system, rest): (Vec<_>, Vec<_>) =
+                messages.into_iter().partition(|m| m.role == Role::System);
+
+            let merged = if system.is_empty() {
+                rest
+            } else {
+                let combined_content = system
+                    .iter()
+                    .filter_map(|m| match &m.content {
+                        Some(MessageContent::Text(text)) => Some(text.clone()),
+                        Some(MessageContent::Parts(parts)) => Some(
+                            parts
+                                .iter()
+                                .filter_map(|p| match p {
+                                    crate::dto::openai::ContentPart::Text { text, .. } => {
+                                        Some(text.clone())
+                                    }
+                                    _ => None,
+                                })
+                                .collect::<Vec<_>>()
+                                .join(""),
+                        ),
+                        None => None,
+                    })
+                    .collect::<Vec<_>>()
+                    .join("\n\n");
+
+                if combined_content.is_empty() {
+                    // All system messages had no content, don't create empty system message
+                    rest
+                } else {
+                    let mut result = vec![Message {
+                        role: Role::System,
+                        content: Some(MessageContent::Text(combined_content)),
+                        name: None,
+                        tool_call_id: None,
+                        tool_calls: None,
+                        reasoning_details: None,
+                        reasoning_text: None,
+                        reasoning_opaque: None,
+                        reasoning_content: None,
+                        extra_content: None,
+                    }];
+                    result.extend(rest);
+                    result
+                }
+            };
+
+            request.messages = Some(merged);
+        }
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+    use crate::dto::openai::{Message, MessageContent, Role};
+
+    fn system_msg(content: &str) -> Message {
+        Message {
+            role: Role::System,
+            content: Some(MessageContent::Text(content.to_string())),
+            name: None,
+            tool_call_id: None,
+            tool_calls: None,
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: None,
+            extra_content: None,
+        }
+    }
+
+    fn user_msg(content: &str) -> Message {
+        Message {
+            role: Role::User,
+            content: Some(MessageContent::Text(content.to_string())),
+            name: None,
+            tool_call_id: None,
+            tool_calls: None,
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: None,
+            extra_content: None,
+        }
+    }
+
+    fn assistant_msg(content: &str) -> Message {
+        Message {
+            role: Role::Assistant,
+            content: Some(MessageContent::Text(content.to_string())),
+            name: None,
+            tool_call_id: None,
+            tool_calls: None,
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: None,
+            extra_content: None,
+        }
+    }
+
+    fn get_text_content(msg: &Message) -> Option<&str> {
+        match msg.content.as_ref() {
+            Some(MessageContent::Text(text)) => Some(text.as_str()),
+            _ => None,
+        }
+    }
+
+    #[test]
+    fn test_multiple_system_messages_merged() {
+        let fixture = Request::default().messages(vec![
+            user_msg("hello"),
+            system_msg("you are helpful"),
+            assistant_msg("hi"),
+            system_msg("be concise"),
+            user_msg("how are you"),
+        ]);
+
+        let actual = MergeSystemMessages.transform(fixture);
+
+        let messages = actual.messages.unwrap();
+        assert_eq!(messages.len(), 4);
+        assert_eq!(messages[0].role, Role::System);
+        assert_eq!(
+            get_text_content(&messages[0]),
+            Some("you are helpful\n\nbe concise")
+        );
+        assert_eq!(messages[1].role, Role::User);
+        assert_eq!(messages[2].role, Role::Assistant);
+        assert_eq!(messages[3].role, Role::User);
+    }
+
+    #[test]
+    fn test_single_system_message_unchanged() {
+        let fixture = Request::default().messages(vec![
+            system_msg("you are helpful"),
+            user_msg("hello"),
+            assistant_msg("hi"),
+        ]);
+
+        let actual = MergeSystemMessages.transform(fixture);
+
+        let messages = actual.messages.unwrap();
+        assert_eq!(messages.len(), 3);
+        assert_eq!(messages[0].role, Role::System);
+        assert_eq!(get_text_content(&messages[0]), Some("you are helpful"));
+        assert_eq!(messages[1].role, Role::User);
+        assert_eq!(messages[2].role, Role::Assistant);
+    }
+
+    #[test]
+    fn test_no_system_messages_unchanged() {
+        let fixture = Request::default().messages(vec![
+            user_msg("hello"),
+            assistant_msg("hi"),
+            user_msg("how are you"),
+        ]);
+
+        let actual = MergeSystemMessages.transform(fixture);
+
+        let messages = actual.messages.unwrap();
+        assert_eq!(messages.len(), 3);
+        assert_eq!(messages[0].role, Role::User);
+        assert_eq!(messages[1].role, Role::Assistant);
+        assert_eq!(messages[2].role, Role::User);
+    }
+
+    #[test]
+    fn test_no_messages_unchanged() {
+        let fixture = Request::default();
+
+        let actual = MergeSystemMessages.transform(fixture);
+
+        assert!(actual.messages.is_none());
+    }
+}

crates/forge_app/src/dto/openai/transformers/github_copilot_reasoning.rs

@@ -0,0 +1,126 @@
+use forge_domain::Transformer;
+
+use crate::dto::openai::Request;
+
+/// Transformer that converts reasoning_details to GitHub Copilot's flat format.
+///
+/// GitHub Copilot uses `reasoning_text` and `reasoning_opaque` fields directly
+/// in messages instead of the OpenRouter-style `reasoning_details` array.
+///
+/// This transformer:
+/// 1. Extracts `reasoning.text` type entries → `reasoning_text`
+/// 2. Extracts `reasoning.encrypted` type entries → `reasoning_opaque`
+/// 3. Removes `reasoning_details` array
+pub struct GitHubCopilotReasoning;
+
+impl Transformer for GitHubCopilotReasoning {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        if let Some(ref mut messages) = request.messages {
+            for message in messages.iter_mut() {
+                if let Some(reasoning_details) = &message.reasoning_details {
+                    // Extract reasoning_text (type: "reasoning.text")
+                    let reasoning_text = reasoning_details
+                        .iter()
+                        .find(|d| d.r#type == "reasoning.text")
+                        .and_then(|d| d.text.clone());
+
+                    // Extract reasoning_opaque (type: "reasoning.encrypted")
+                    let reasoning_opaque = reasoning_details
+                        .iter()
+                        .find(|d| d.r#type == "reasoning.encrypted")
+                        .and_then(|d| d.data.clone());
+
+                    // Set flat fields
+                    message.reasoning_text = reasoning_text;
+                    message.reasoning_opaque = reasoning_opaque;
+
+                    // Remove reasoning_details array (GitHub Copilot doesn't accept it)
+                    message.reasoning_details = None;
+                }
+            }
+        }
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+    use crate::dto::openai::{Message, MessageContent, ReasoningDetail, Request, Role};
+
+    #[test]
+    fn test_converts_reasoning_details_to_flat_format() {
+        // Setup
+        let fixture = Request::default().messages(vec![Message {
+            role: Role::Assistant,
+            content: Some(MessageContent::Text("test".to_string())),
+            reasoning_details: Some(vec![
+                ReasoningDetail {
+                    r#type: "reasoning.text".to_string(),
+                    text: Some("thinking...".to_string()),
+                    signature: None,
+                    data: None,
+                    id: None,
+                    format: None,
+                    index: None,
+                },
+                ReasoningDetail {
+                    r#type: "reasoning.encrypted".to_string(),
+                    text: None,
+                    signature: None,
+                    data: Some("encrypted_data".to_string()),
+                    id: None,
+                    format: None,
+                    index: None,
+                },
+            ]),
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: None,
+            tool_calls: None,
+            tool_call_id: None,
+            name: None,
+            extra_content: None,
+        }]);
+
+        // Execute
+        let actual = GitHubCopilotReasoning.transform(fixture);
+
+        // Verify transformation
+        let messages = actual.messages.unwrap();
+        let msg = messages.first().unwrap();
+        assert_eq!(msg.reasoning_text, Some("thinking...".to_string()));
+        assert_eq!(msg.reasoning_opaque, Some("encrypted_data".to_string()));
+        assert!(msg.reasoning_details.is_none());
+    }
+
+    #[test]
+    fn test_handles_missing_reasoning_details() {
+        // Setup
+        let fixture = Request::default().messages(vec![Message {
+            role: Role::User,
+            content: Some(MessageContent::Text("test".to_string())),
+            reasoning_details: None,
+            reasoning_text: None,
+            reasoning_opaque: None,
+            reasoning_content: None,
+            tool_calls: None,
+            tool_call_id: None,
+            name: None,
+            extra_content: None,
+        }]);
+
+        // Execute
+        let actual = GitHubCopilotReasoning.transform(fixture.clone());
+
+        // Verify - no change since there were no reasoning_details
+        let messages = actual.messages.unwrap();
+        let msg = messages.first().unwrap();
+        assert!(msg.reasoning_text.is_none());
+        assert!(msg.reasoning_opaque.is_none());
+    }
+}

crates/forge_app/src/dto/openai/transformers/make_cerebras_compat.rs

@@ -0,0 +1,43 @@
+use forge_domain::Transformer;
+
+use crate::dto::openai::Request;
+
+/// makes the Request compatible with the OpenAI API.
+pub struct MakeCerebrasCompat;
+
+impl Transformer for MakeCerebrasCompat {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        // remove fields that are not supported by cerebras.
+        request.parallel_tool_calls = None;
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_parallel_tool_calls_dropped() {
+        use crate::dto::openai::{FunctionDescription, FunctionType, Request, Tool};
+
+        let fixture = Request::default()
+            .tools(vec![Tool {
+                r#type: FunctionType,
+                function: FunctionDescription {
+                    description: Some("test".to_string()),
+                    name: "test".to_string(),
+                    parameters: serde_json::json!({}),
+                },
+            }])
+            .parallel_tool_calls(true);
+        let mut transformer = MakeCerebrasCompat;
+        let actual = transformer.transform(fixture);
+        let expected = None;
+        assert_eq!(actual.parallel_tool_calls, expected);
+    }
+}

crates/forge_app/src/dto/openai/transformers/make_openai_compat.rs

@@ -0,0 +1,112 @@
+use forge_domain::Transformer;
+
+use crate::dto::openai::Request;
+
+/// makes the Request compatible with the OpenAI API.
+pub struct MakeOpenAiCompat;
+
+impl Transformer for MakeOpenAiCompat {
+    type Value = Request;
+
+    fn transform(&mut self, mut request: Self::Value) -> Self::Value {
+        // remove fields that are not supported by open-ai.
+        request.provider = None;
+        request.transforms = None;
+        request.prompt = None;
+        request.models = None;
+        request.route = None;
+        request.top_k = None;
+        request.top_p = None;
+        request.repetition_penalty = None;
+        request.min_p = None;
+        request.top_a = None;
+        request.session_id = None;
+        request.reasoning = None;
+
+        let tools_present = request
+            .tools
+            .as_ref()
+            .is_some_and(|tools| !tools.is_empty());
+
+        if !tools_present {
+            // drop `parallel_tool_calls` field if tools are not passed to the request.
+            request.parallel_tool_calls = None;
+        }
+
+        // OpenAI has deprecated `max_tokens`, now it is `max_completion_tokens`.
+        request.max_completion_tokens = request.max_tokens.take();
+
+        request
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_parallel_tool_calls_removed_when_no_tools() {
+        use crate::dto::openai::Request;
+
+        let fixture = Request::default().parallel_tool_calls(true);
+        let mut transformer = MakeOpenAiCompat;
+        let actual = transformer.transform(fixture);
+        let expected = None;
+        assert_eq!(actual.parallel_tool_calls, expected);
+    }
+
+    #[test]
+    fn test_parallel_tool_calls_removed_when_empty_tools() {
+        let fixture = Request::default().tools(vec![]).parallel_tool_calls(true);
+        let mut transformer = MakeOpenAiCompat;
+        let actual = transformer.transform(fixture);
+        let expected = None;
+        assert_eq!(actual.parallel_tool_calls, expected);
+    }
+
+    #[test]
+    fn test_parallel_tool_calls_preserved_when_tools_present() {
+        use crate::dto::openai::{FunctionDescription, FunctionType, Request, Tool};
+
+        let fixture = Request::default()
+            .tools(vec![Tool {
+                r#type: FunctionType,
+                function: FunctionDescription {
+                    description: Some("test".to_string()),
+                    name: "test".to_string(),
+                    parameters: serde_json::json!({}),
+                },
+            }])
+            .parallel_tool_calls(true);
+        let mut transformer = MakeOpenAiCompat;
+        let actual = transformer.transform(fixture);
+        let expected = Some(true);
+        assert_eq!(actual.parallel_tool_calls, expected);
+    }
+
+    #[test]
+    fn test_reasoning_removed() {
+        let fixture = Request::default().reasoning(forge_domain::ReasoningConfig {
+            enabled: Some(true),
+            effort: None,
+            max_tokens: None,
+            exclude: None,
+        });
+        let mut transformer = MakeOpenAiCompat;
+        let actual = transformer.transform(fixture);
+        let expected = None;
+        assert_eq!(actual.reasoning, expected);
+    }
+
+    #[test]
+    fn test_max_tokens_mapped_correctly() {
+        let fixture = Request::default().max_tokens(100);
+        let mut transformer = MakeOpenAiCompat;
+        let actual = transformer.transform(fixture);
+        let expected = Some(100);
+        assert_eq!(actual.max_completion_tokens, expected);
+        assert_eq!(actual.max_tokens, None);
+    }
+}