From 93ff4d7b1fd59e89d4a5704891de7040105cc6bd Mon Sep 17 00:00:00 2001
From: Salman Paracha <salman.paracha@gmail.com>
Date: Thu, 7 Aug 2025 12:42:09 -0700
Subject: [PATCH] pushing new apis module for hermes (#547)

---
 crates/hermesllm/src/apis/anthropic.rs      |  898 ++++++++++
 crates/hermesllm/src/apis/mod.rs            |  197 +++
 crates/hermesllm/src/apis/openai.rs         |  883 ++++++++++
 crates/hermesllm/src/clients/endpoints.rs   |  130 ++
 crates/hermesllm/src/clients/lib.rs         |   33 +
 crates/hermesllm/src/clients/mod.rs         |    9 +
 crates/hermesllm/src/clients/transformer.rs | 1722 +++++++++++++++++++
 crates/hermesllm/src/lib.rs                 |    6 +-
 crates/hermesllm/src/mod.rs                 |    2 +
 9 files changed, 3878 insertions(+), 2 deletions(-)
 create mode 100644 crates/hermesllm/src/apis/anthropic.rs
 create mode 100644 crates/hermesllm/src/apis/mod.rs
 create mode 100644 crates/hermesllm/src/apis/openai.rs
 create mode 100644 crates/hermesllm/src/clients/endpoints.rs
 create mode 100644 crates/hermesllm/src/clients/lib.rs
 create mode 100644 crates/hermesllm/src/clients/mod.rs
 create mode 100644 crates/hermesllm/src/clients/transformer.rs
 create mode 100644 crates/hermesllm/src/mod.rs

diff --git a/crates/hermesllm/src/apis/anthropic.rs b/crates/hermesllm/src/apis/anthropic.rs
new file mode 100644
index 00000000..0ffe4e8d
--- /dev/null
+++ b/crates/hermesllm/src/apis/anthropic.rs
@@ -0,0 +1,898 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use serde_with::skip_serializing_none;
+use std::collections::HashMap;
+
+use super::ApiDefinition;
+
+// Enum for all supported Anthropic APIs
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AnthropicApi {
+    Messages,
+    // Future APIs can be added here:
+    // Embeddings,
+    // etc.
+}
+
+impl ApiDefinition for AnthropicApi {
+    fn endpoint(&self) -> &'static str {
+        match self {
+            AnthropicApi::Messages => "/v1/messages",
+        }
+    }
+
+    fn from_endpoint(endpoint: &str) -> Option<Self> {
+        match endpoint {
+            "/v1/messages" => Some(AnthropicApi::Messages),
+            _ => None,
+        }
+    }
+
+    fn supports_streaming(&self) -> bool {
+        match self {
+            AnthropicApi::Messages => true,
+        }
+    }
+
+    fn supports_tools(&self) -> bool {
+        match self {
+            AnthropicApi::Messages => true,
+        }
+    }
+
+    fn supports_vision(&self) -> bool {
+        match self {
+            AnthropicApi::Messages => true,
+        }
+    }
+
+    fn all_variants() -> Vec<Self> {
+        vec![
+            AnthropicApi::Messages,
+        ]
+    }
+}
+
+// Service tier enum for request priority
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ServiceTier {
+    Auto,
+    StandardOnly,
+}
+
+// Thinking configuration
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ThinkingConfig {
+    pub enabled: bool,
+}
+
+// MCP Server types
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum McpServerType {
+    Url,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct McpToolConfiguration {
+    pub allowed_tools: Option<Vec<String>>,
+    pub enabled: Option<bool>,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct McpServer {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub server_type: McpServerType,
+    pub url: String,
+    pub authorization_token: Option<String>,
+    pub tool_configuration: Option<McpToolConfiguration>,
+}
+
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesRequest {
+    pub model: String,
+    pub messages: Vec<MessagesMessage>,
+    pub max_tokens: u32,
+    pub container: Option<String>,
+    pub mcp_servers: Option<Vec<McpServer>>,
+    pub system: Option<MessagesSystemPrompt>,
+    pub metadata: Option<HashMap<String, Value>>,
+    pub service_tier: Option<ServiceTier>,
+    pub thinking: Option<ThinkingConfig>,
+
+    pub temperature: Option<f32>,
+    pub top_p: Option<f32>,
+    pub top_k: Option<u32>,
+    pub stream: Option<bool>,
+    pub stop_sequences: Option<Vec<String>>,
+    pub tools: Option<Vec<MessagesTool>>,
+    pub tool_choice: Option<MessagesToolChoice>,
+
+}
+
+
+// Messages API specific types
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum MessagesRole {
+    User,
+    Assistant,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+#[serde(tag = "type")]
+pub enum MessagesContentBlock {
+    Text {
+        text: String,
+    },
+    Thinking {
+        text: String,
+    },
+    Image {
+        source: MessagesImageSource,
+    },
+    Document {
+        source: MessagesDocumentSource,
+    },
+    ToolUse {
+        id: String,
+        name: String,
+        input: Value,
+    },
+    ToolResult {
+        tool_use_id: String,
+        is_error: Option<bool>,
+        content: Vec<MessagesContentBlock>,
+    },
+    ServerToolUse {
+        id: String,
+        name: String,
+        input: Value,
+    },
+    WebSearchToolResult {
+        tool_use_id: String,
+        is_error: Option<bool>,
+        content: Vec<MessagesContentBlock>,
+    },
+    CodeExecutionToolResult {
+        tool_use_id: String,
+        is_error: Option<bool>,
+        content: Vec<MessagesContentBlock>,
+    },
+    McpToolUse {
+        id: String,
+        name: String,
+        input: Value,
+    },
+    McpToolResult {
+        tool_use_id: String,
+        is_error: Option<bool>,
+        content: Vec<MessagesContentBlock>,
+    },
+    ContainerUpload {
+        id: String,
+        name: String,
+        media_type: String,
+        data: String,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum MessagesImageSource {
+    Base64 {
+        media_type: String,
+        data: String,
+    },
+    Url {
+        url: String,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum MessagesDocumentSource {
+    Base64 {
+        media_type: String,
+        data: String,
+    },
+    Url {
+        url: String,
+    },
+    File {
+        file_id: String,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum MessagesMessageContent {
+    Single(String),
+    Blocks(Vec<MessagesContentBlock>),
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum MessagesSystemPrompt {
+    Single(String),
+    Blocks(Vec<MessagesContentBlock>),
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesMessage {
+    pub role: MessagesRole,
+    pub content: MessagesMessageContent,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesTool {
+    pub name: String,
+    pub description: Option<String>,
+    pub input_schema: Value,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum MessagesToolChoiceType {
+    Auto,
+    Any,
+    Tool,
+    None,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesToolChoice {
+    #[serde(rename = "type")]
+    pub kind: MessagesToolChoiceType,
+    pub name: Option<String>,
+    pub disable_parallel_tool_use: Option<bool>,
+}
+
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum MessagesStopReason {
+    EndTurn,
+    MaxTokens,
+    StopSequence,
+    ToolUse,
+    PauseTurn,
+    Refusal,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesUsage {
+    pub input_tokens: u32,
+    pub output_tokens: u32,
+    pub cache_creation_input_tokens: Option<u32>,
+    pub cache_read_input_tokens: Option<u32>,
+}
+
+// Container response object
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesContainer {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub container_type: String,
+    pub name: String,
+    pub status: String,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesResponse {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub obj_type: String,
+    pub role: MessagesRole,
+    pub content: Vec<MessagesContentBlock>,
+    pub model: String,
+    pub stop_reason: MessagesStopReason,
+    pub stop_sequence: Option<String>,
+    pub usage: MessagesUsage,
+    pub container: Option<MessagesContainer>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+#[serde(tag = "type")]
+pub enum MessagesStreamEvent {
+    MessageStart {
+        message: MessagesStreamMessage,
+    },
+    ContentBlockStart {
+        index: u32,
+        content_block: MessagesContentBlock,
+    },
+    ContentBlockDelta {
+        index: u32,
+        delta: MessagesContentDelta,
+    },
+    ContentBlockStop {
+        index: u32,
+    },
+    MessageDelta {
+        delta: MessagesMessageDelta,
+        usage: MessagesUsage,
+    },
+    MessageStop,
+    Ping,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesStreamMessage {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub obj_type: String,
+    pub role: MessagesRole,
+    pub content: Vec<Value>, // Initially empty
+    pub model: String,
+    pub stop_reason: Option<MessagesStopReason>,
+    pub stop_sequence: Option<String>,
+    pub usage: MessagesUsage,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum MessagesContentDelta {
+    #[serde(rename = "text_delta")]
+    TextDelta { text: String },
+    #[serde(rename = "input_json_delta")]
+    InputJsonDelta { partial_json: String },
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessagesMessageDelta {
+    pub stop_reason: MessagesStopReason,
+    pub stop_sequence: Option<String>,
+}
+
+// Helper functions for API detection and conversion
+impl MessagesRequest {
+    pub fn api_type() -> AnthropicApi {
+        AnthropicApi::Messages
+    }
+}
+
+impl MessagesResponse {
+    pub fn api_type() -> AnthropicApi {
+        AnthropicApi::Messages
+    }
+}
+
+impl MessagesStreamEvent {
+    pub fn api_type() -> AnthropicApi {
+        AnthropicApi::Messages
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_anthropic_required_fields() {
+        // Create a JSON object with only required fields
+        let original_json = json!({
+            "model": "claude-3-sonnet-20240229",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "Hello"
+                }
+            ],
+            "max_tokens": 100
+        });
+
+        // Deserialize JSON into MessagesRequest
+        let deserialized_request: MessagesRequest = serde_json::from_value(original_json.clone()).unwrap();
+
+        // Validate required fields are properly set
+        assert_eq!(deserialized_request.model, "claude-3-sonnet-20240229");
+        assert_eq!(deserialized_request.messages.len(), 1);
+        assert_eq!(deserialized_request.max_tokens, 100);
+
+        let message = &deserialized_request.messages[0];
+        assert_eq!(message.role, MessagesRole::User);
+        if let MessagesMessageContent::Single(content) = &message.content {
+            assert_eq!(content, "Hello");
+        } else {
+            panic!("Expected single content");
+        }
+
+        // Validate optional fields are None
+        assert!(deserialized_request.system.is_none());
+        assert!(deserialized_request.container.is_none());
+        assert!(deserialized_request.mcp_servers.is_none());
+        assert!(deserialized_request.service_tier.is_none());
+        assert!(deserialized_request.thinking.is_none());
+        assert!(deserialized_request.temperature.is_none());
+        assert!(deserialized_request.top_p.is_none());
+        assert!(deserialized_request.top_k.is_none());
+        assert!(deserialized_request.stream.is_none());
+        assert!(deserialized_request.stop_sequences.is_none());
+        assert!(deserialized_request.tools.is_none());
+        assert!(deserialized_request.tool_choice.is_none());
+        assert!(deserialized_request.metadata.is_none());
+
+        // Serialize back to JSON and compare
+        let serialized_json = serde_json::to_value(&deserialized_request).unwrap();
+        assert_eq!(original_json, serialized_json);
+    }
+
+    #[test]
+    fn test_anthropic_optional_fields() {
+        // Create a JSON object with optional fields set
+        let original_json = json!({
+            "model": "claude-3-sonnet-20240229",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "Hello"
+                }
+            ],
+            "max_tokens": 100,
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "system": "You are a helpful assistant",
+            "service_tier": "auto",
+            "thinking": {
+                "enabled": true
+            },
+            "metadata": {
+                "user_id": "123"
+            }
+        });
+
+        // Deserialize JSON into MessagesRequest
+        let deserialized_request: MessagesRequest = serde_json::from_value(original_json.clone()).unwrap();
+
+        // Validate required fields
+        assert_eq!(deserialized_request.model, "claude-3-sonnet-20240229");
+        assert_eq!(deserialized_request.messages.len(), 1);
+        assert_eq!(deserialized_request.max_tokens, 100);
+
+        // Validate optional fields are properly set
+        assert!((deserialized_request.temperature.unwrap() - 0.7).abs() < 1e-6);
+        assert!((deserialized_request.top_p.unwrap() - 0.9).abs() < 1e-6);
+        assert_eq!(deserialized_request.service_tier, Some(ServiceTier::Auto));
+
+        if let Some(MessagesSystemPrompt::Single(system)) = &deserialized_request.system {
+            assert_eq!(system, "You are a helpful assistant");
+        } else {
+            panic!("Expected single system prompt");
+        }
+
+        if let Some(thinking) = &deserialized_request.thinking {
+            assert_eq!(thinking.enabled, true);
+        } else {
+            panic!("Expected thinking config");
+        }
+
+        assert!(deserialized_request.metadata.is_some());
+
+        // Validate fields not in JSON are None
+        assert!(deserialized_request.container.is_none());
+        assert!(deserialized_request.mcp_servers.is_none());
+        assert!(deserialized_request.top_k.is_none());
+        assert!(deserialized_request.stream.is_none());
+        assert!(deserialized_request.stop_sequences.is_none());
+        assert!(deserialized_request.tools.is_none());
+        assert!(deserialized_request.tool_choice.is_none());
+
+        // Serialize back to JSON and compare (handle floating point precision)
+        let serialized_json = serde_json::to_value(&deserialized_request).unwrap();
+
+        // Compare all fields except floating point ones
+        assert_eq!(serialized_json["model"], original_json["model"]);
+        assert_eq!(serialized_json["messages"], original_json["messages"]);
+        assert_eq!(serialized_json["max_tokens"], original_json["max_tokens"]);
+        assert_eq!(serialized_json["system"], original_json["system"]);
+        assert_eq!(serialized_json["service_tier"], original_json["service_tier"]);
+        assert_eq!(serialized_json["thinking"], original_json["thinking"]);
+        assert_eq!(serialized_json["metadata"], original_json["metadata"]);
+
+        // Handle floating point fields with tolerance
+        let original_temp = original_json["temperature"].as_f64().unwrap();
+        let serialized_temp = serialized_json["temperature"].as_f64().unwrap();
+        assert!((original_temp - serialized_temp).abs() < 1e-6);
+
+        let original_top_p = original_json["top_p"].as_f64().unwrap();
+        let serialized_top_p = serialized_json["top_p"].as_f64().unwrap();
+        assert!((original_top_p - serialized_top_p).abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_anthropic_nested_types() {
+        // Create a comprehensive JSON object with nested types - a MessagesRequest with complex message content and tools
+        let original_json = json!({
+            "model": "claude-3-sonnet-20240229",
+            "max_tokens": 1000,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "What can you see in this image and what's the weather like?"
+                        },
+                        {
+                            "type": "image",
+                            "source": {
+                                "base64": {
+                                    "media_type": "image/jpeg",
+                                    "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
+                                }
+                            }
+                        }
+                    ]
+                },
+                {
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "thinking",
+                            "text": "Let me analyze the image and then check the weather..."
+                        },
+                        {
+                            "type": "text",
+                            "text": "I can see the image. Let me check the weather for you."
+                        },
+                        {
+                            "type": "tool_use",
+                            "id": "toolu_weather123",
+                            "name": "get_weather",
+                            "input": {
+                                "location": "San Francisco, CA"
+                            }
+                        }
+                    ]
+                }
+            ],
+            "tools": [
+                {
+                    "name": "get_weather",
+                    "description": "Get current weather information for a location",
+                    "input_schema": {
+                        "type": "object",
+                        "properties": {
+                            "location": {
+                                "type": "string",
+                                "description": "The city and state, e.g. San Francisco, CA"
+                            }
+                        },
+                        "required": ["location"]
+                    }
+                }
+            ],
+            "tool_choice": {
+                "type": "auto"
+            },
+            "system": [
+                {
+                    "type": "text",
+                    "text": "You are a helpful assistant that can analyze images and provide weather information."
+                }
+            ]
+        });
+
+        // Deserialize JSON into MessagesRequest
+        let deserialized_request: MessagesRequest = serde_json::from_value(original_json.clone()).unwrap();
+
+        // Validate top-level fields
+        assert_eq!(deserialized_request.model, "claude-3-sonnet-20240229");
+        assert_eq!(deserialized_request.max_tokens, 1000);
+        assert_eq!(deserialized_request.messages.len(), 2);
+
+        // Validate first message (user with text and image content)
+        let user_message = &deserialized_request.messages[0];
+        assert_eq!(user_message.role, MessagesRole::User);
+        if let MessagesMessageContent::Blocks(ref content_blocks) = user_message.content {
+            assert_eq!(content_blocks.len(), 2);
+
+            // Validate text content block
+            if let MessagesContentBlock::Text { text } = &content_blocks[0] {
+                assert_eq!(text, "What can you see in this image and what's the weather like?");
+            } else {
+                panic!("Expected text content block");
+            }
+
+            // Validate image content block
+            if let MessagesContentBlock::Image { ref source } = content_blocks[1] {
+                if let MessagesImageSource::Base64 { media_type, data } = source {
+                    assert_eq!(media_type, "image/jpeg");
+                    assert_eq!(data, "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==");
+                } else {
+                    panic!("Expected base64 image source");
+                }
+            } else {
+                panic!("Expected image content block");
+            }
+        } else {
+            panic!("Expected content blocks for user message");
+        }
+
+        // Validate second message (assistant with thinking, text, and tool use)
+        let assistant_message = &deserialized_request.messages[1];
+        assert_eq!(assistant_message.role, MessagesRole::Assistant);
+        if let MessagesMessageContent::Blocks(ref content_blocks) = assistant_message.content {
+            assert_eq!(content_blocks.len(), 3);
+
+            // Validate thinking content block
+            if let MessagesContentBlock::Thinking { text } = &content_blocks[0] {
+                assert_eq!(text, "Let me analyze the image and then check the weather...");
+            } else {
+                panic!("Expected thinking content block");
+            }
+
+            // Validate text content block
+            if let MessagesContentBlock::Text { text } = &content_blocks[1] {
+                assert_eq!(text, "I can see the image. Let me check the weather for you.");
+            } else {
+                panic!("Expected text content block");
+            }
+
+            // Validate tool use content block
+            if let MessagesContentBlock::ToolUse { ref id, ref name, ref input } = content_blocks[2] {
+                assert_eq!(id, "toolu_weather123");
+                assert_eq!(name, "get_weather");
+                assert_eq!(input["location"], "San Francisco, CA");
+            } else {
+                panic!("Expected tool use content block");
+            }
+        } else {
+            panic!("Expected content blocks for assistant message");
+        }
+
+        // Validate tools array
+        assert!(deserialized_request.tools.is_some());
+        let tools = deserialized_request.tools.as_ref().unwrap();
+        assert_eq!(tools.len(), 1);
+
+        let tool = &tools[0];
+        assert_eq!(tool.name, "get_weather");
+        assert_eq!(tool.description, Some("Get current weather information for a location".to_string()));
+        assert_eq!(tool.input_schema["type"], "object");
+        assert!(tool.input_schema["properties"]["location"].is_object());
+
+        // Validate tool choice
+        assert!(deserialized_request.tool_choice.is_some());
+        let tool_choice = deserialized_request.tool_choice.as_ref().unwrap();
+        assert_eq!(tool_choice.kind, MessagesToolChoiceType::Auto);
+        assert!(tool_choice.name.is_none());
+
+        // Validate system prompt with content blocks
+        assert!(deserialized_request.system.is_some());
+        if let Some(MessagesSystemPrompt::Blocks(ref system_blocks)) = deserialized_request.system {
+            assert_eq!(system_blocks.len(), 1);
+            if let MessagesContentBlock::Text { text } = &system_blocks[0] {
+                assert_eq!(text, "You are a helpful assistant that can analyze images and provide weather information.");
+            } else {
+                panic!("Expected text content block in system prompt");
+            }
+        } else {
+            panic!("Expected system prompt with content blocks");
+        }
+
+        // Serialize back to JSON and compare
+        let serialized_json = serde_json::to_value(&deserialized_request).unwrap();
+        assert_eq!(original_json, serialized_json);
+    }
+
+    #[test]
+    fn test_anthropic_mcp_server_configuration() {
+        // Test MCP Server configuration with JSON-first approach
+        let mcp_server_json = json!({
+            "name": "test-server",
+            "type": "url",
+            "url": "https://example.com/mcp",
+            "authorization_token": "secret-token",
+            "tool_configuration": {
+                "allowed_tools": ["tool1", "tool2"],
+                "enabled": true
+            }
+        });
+
+        let deserialized_mcp: McpServer = serde_json::from_value(mcp_server_json.clone()).unwrap();
+        assert_eq!(deserialized_mcp.name, "test-server");
+        assert_eq!(deserialized_mcp.server_type, McpServerType::Url);
+        assert_eq!(deserialized_mcp.url, "https://example.com/mcp");
+        assert_eq!(deserialized_mcp.authorization_token, Some("secret-token".to_string()));
+
+        if let Some(tool_config) = &deserialized_mcp.tool_configuration {
+            assert_eq!(tool_config.allowed_tools, Some(vec!["tool1".to_string(), "tool2".to_string()]));
+            assert_eq!(tool_config.enabled, Some(true));
+        } else {
+            panic!("Expected tool configuration");
+        }
+
+        let serialized_mcp_json = serde_json::to_value(&deserialized_mcp).unwrap();
+        assert_eq!(mcp_server_json, serialized_mcp_json);
+
+        // Test MCP Server with minimal configuration (optional fields as None)
+        let minimal_mcp_json = json!({
+            "name": "minimal-server",
+            "type": "url",
+            "url": "https://minimal.com/mcp"
+        });
+
+        let deserialized_minimal: McpServer = serde_json::from_value(minimal_mcp_json.clone()).unwrap();
+        assert_eq!(deserialized_minimal.name, "minimal-server");
+        assert_eq!(deserialized_minimal.server_type, McpServerType::Url);
+        assert_eq!(deserialized_minimal.url, "https://minimal.com/mcp");
+        assert!(deserialized_minimal.authorization_token.is_none());
+        assert!(deserialized_minimal.tool_configuration.is_none());
+
+        let serialized_minimal_json = serde_json::to_value(&deserialized_minimal).unwrap();
+        assert_eq!(minimal_mcp_json, serialized_minimal_json);
+    }
+
+    #[test]
+    fn test_anthropic_response_types() {
+        // Test MessagesResponse deserialization
+        let response_json = json!({
+            "id": "msg_01ABC123",
+            "type": "message",
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Hello! How can I help you today?"
+                }
+            ],
+            "model": "claude-3-sonnet-20240229",
+            "stop_reason": "end_turn",
+            "usage": {
+                "input_tokens": 10,
+                "output_tokens": 25,
+                "cache_creation_input_tokens": 5,
+                "cache_read_input_tokens": 3
+            }
+        });
+
+        let deserialized_response: MessagesResponse = serde_json::from_value(response_json.clone()).unwrap();
+        assert_eq!(deserialized_response.id, "msg_01ABC123");
+        assert_eq!(deserialized_response.obj_type, "message");
+        assert_eq!(deserialized_response.role, MessagesRole::Assistant);
+        assert_eq!(deserialized_response.model, "claude-3-sonnet-20240229");
+        assert_eq!(deserialized_response.stop_reason, MessagesStopReason::EndTurn);
+        assert!(deserialized_response.stop_sequence.is_none());
+        assert!(deserialized_response.container.is_none());
+
+        // Check content
+        assert_eq!(deserialized_response.content.len(), 1);
+        if let MessagesContentBlock::Text { text } = &deserialized_response.content[0] {
+            assert_eq!(text, "Hello! How can I help you today?");
+        } else {
+            panic!("Expected text content block");
+        }
+
+        // Check usage
+        assert_eq!(deserialized_response.usage.input_tokens, 10);
+        assert_eq!(deserialized_response.usage.output_tokens, 25);
+        assert_eq!(deserialized_response.usage.cache_creation_input_tokens, Some(5));
+        assert_eq!(deserialized_response.usage.cache_read_input_tokens, Some(3));
+
+        let serialized_response_json = serde_json::to_value(&deserialized_response).unwrap();
+        assert_eq!(response_json, serialized_response_json);
+
+        // Test streaming event
+        let stream_event_json = json!({
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {
+                "type": "text_delta",
+                "text": " How"
+            }
+        });
+
+        let deserialized_event: MessagesStreamEvent = serde_json::from_value(stream_event_json.clone()).unwrap();
+        if let MessagesStreamEvent::ContentBlockDelta { index, ref delta } = deserialized_event {
+            assert_eq!(index, 0);
+            if let MessagesContentDelta::TextDelta { text } = delta {
+                assert_eq!(text, " How");
+            } else {
+                panic!("Expected text delta");
+            }
+        } else {
+            panic!("Expected content block delta event");
+        }
+
+        let serialized_event_json = serde_json::to_value(&deserialized_event).unwrap();
+        assert_eq!(stream_event_json, serialized_event_json);
+    }
+
+    #[test]
+    fn test_anthropic_tool_use_content() {
+        // Test tool use and tool result content blocks
+        let tool_use_json = json!({
+            "type": "tool_use",
+            "id": "toolu_01ABC123",
+            "name": "get_weather",
+            "input": {
+                "location": "San Francisco, CA"
+            }
+        });
+
+        let deserialized_tool_use: MessagesContentBlock = serde_json::from_value(tool_use_json.clone()).unwrap();
+        if let MessagesContentBlock::ToolUse { ref id, ref name, ref input } = deserialized_tool_use {
+            assert_eq!(id, "toolu_01ABC123");
+            assert_eq!(name, "get_weather");
+            assert_eq!(input["location"], "San Francisco, CA");
+        } else {
+            panic!("Expected tool use content block");
+        }
+
+        let serialized_tool_use_json = serde_json::to_value(&deserialized_tool_use).unwrap();
+        assert_eq!(tool_use_json, serialized_tool_use_json);
+
+        // Test tool result content block
+        let tool_result_json = json!({
+            "type": "tool_result",
+            "tool_use_id": "toolu_01ABC123",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "The weather in San Francisco is sunny, 72°F"
+                }
+            ]
+        });
+
+        let deserialized_tool_result: MessagesContentBlock = serde_json::from_value(tool_result_json.clone()).unwrap();
+        if let MessagesContentBlock::ToolResult { ref tool_use_id, ref is_error, ref content } = deserialized_tool_result {
+            assert_eq!(tool_use_id, "toolu_01ABC123");
+            assert!(is_error.is_none());
+            assert_eq!(content.len(), 1);
+            if let MessagesContentBlock::Text { text } = &content[0] {
+                assert_eq!(text, "The weather in San Francisco is sunny, 72°F");
+            } else {
+                panic!("Expected text content in tool result");
+            }
+        } else {
+            panic!("Expected tool result content block");
+        }
+
+        let serialized_tool_result_json = serde_json::to_value(&deserialized_tool_result).unwrap();
+        assert_eq!(tool_result_json, serialized_tool_result_json);
+    }
+
+    #[test]
+    fn test_anthropic_api_provider_trait_implementation() {
+        // Test that AnthropicApi implements ApiDefinition trait correctly
+        let api = AnthropicApi::Messages;
+
+        // Test trait methods
+        assert_eq!(api.endpoint(), "/v1/messages");
+        assert!(api.supports_streaming());
+        assert!(api.supports_tools());
+        assert!(api.supports_vision());
+
+        // Test from_endpoint trait method
+        let found_api = AnthropicApi::from_endpoint("/v1/messages");
+        assert_eq!(found_api, Some(AnthropicApi::Messages));
+
+        let not_found = AnthropicApi::from_endpoint("/v1/unknown");
+        assert_eq!(not_found, None);
+
+        // Test all_variants
+        let all_variants = AnthropicApi::all_variants();
+        assert_eq!(all_variants.len(), 1);
+        assert_eq!(all_variants[0], AnthropicApi::Messages);
+    }
+}
diff --git a/crates/hermesllm/src/apis/mod.rs b/crates/hermesllm/src/apis/mod.rs
new file mode 100644
index 00000000..78b634d5
--- /dev/null
+++ b/crates/hermesllm/src/apis/mod.rs
@@ -0,0 +1,197 @@
+pub mod anthropic;
+pub mod openai;
+
+// Re-export all types for convenience
+pub use anthropic::*;
+pub use openai::*;
+
+/// Common trait that all API definitions must implement
+///
+/// This trait ensures consistency across different AI provider API definitions
+/// and makes it easy to add new providers like Gemini, Claude, etc.
+///
+/// Note: This is different from the `ApiProvider` enum in `clients::endpoints`
+/// which represents provider identification, while this trait defines API capabilities.
+///
+/// # Benefits
+///
+/// - **Consistency**: All API providers implement the same interface
+/// - **Extensibility**: Easy to add new providers without breaking existing code
+/// - **Type Safety**: Compile-time guarantees that all providers implement required methods
+/// - **Discoverability**: Clear documentation of what capabilities each API supports
+///
+/// # Example implementation for a new provider:
+///
+/// ```rust,ignore
+/// use serde::{Deserialize, Serialize};
+/// use super::ApiDefinition;
+///
+/// #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+/// pub enum GeminiApi {
+///     GenerateContent,
+///     ChatCompletions,
+/// }
+///
+/// impl GeminiApi {
+///     pub fn endpoint(&self) -> &'static str {
+///         match self {
+///             GeminiApi::GenerateContent => "/v1/models/gemini-pro:generateContent",
+///             GeminiApi::ChatCompletions => "/v1/models/gemini-pro:chat",
+///         }
+///     }
+///
+///     pub fn from_endpoint(endpoint: &str) -> Option<Self> {
+///         match endpoint {
+///             "/v1/models/gemini-pro:generateContent" => Some(GeminiApi::GenerateContent),
+///             "/v1/models/gemini-pro:chat" => Some(GeminiApi::ChatCompletions),
+///             _ => None,
+///         }
+///     }
+///
+///     pub fn supports_streaming(&self) -> bool {
+///         match self {
+///             GeminiApi::GenerateContent => true,
+///             GeminiApi::ChatCompletions => true,
+///         }
+///     }
+///
+///     pub fn supports_tools(&self) -> bool {
+///         match self {
+///             GeminiApi::GenerateContent => true,
+///             GeminiApi::ChatCompletions => false,
+///         }
+///     }
+///
+///     pub fn supports_vision(&self) -> bool {
+///         match self {
+///             GeminiApi::GenerateContent => true,
+///             GeminiApi::ChatCompletions => false,
+///         }
+///     }
+/// }
+///
+/// impl ApiDefinition for GeminiApi {
+///     fn endpoint(&self) -> &'static str {
+///         self.endpoint()
+///     }
+///
+///     fn from_endpoint(endpoint: &str) -> Option<Self> {
+///         Self::from_endpoint(endpoint)
+///     }
+///
+///     fn supports_streaming(&self) -> bool {
+///         self.supports_streaming()
+///     }
+///
+///     fn supports_tools(&self) -> bool {
+///         self.supports_tools()
+///     }
+///
+///     fn supports_vision(&self) -> bool {
+///         self.supports_vision()
+///     }
+/// }
+///
+/// // Now you can use generic code that works with any API:
+/// fn print_api_info<T: ApiDefinition>(api: &T) {
+///     println!("Endpoint: {}", api.endpoint());
+///     println!("Supports streaming: {}", api.supports_streaming());
+///     println!("Supports tools: {}", api.supports_tools());
+///     println!("Supports vision: {}", api.supports_vision());
+/// }
+///
+/// // Works with both OpenAI and Anthropic (and future Gemini)
+/// print_api_info(&OpenAIApi::ChatCompletions);
+/// print_api_info(&AnthropicApi::Messages);
+/// print_api_info(&GeminiApi::GenerateContent);
+/// ```
+pub trait ApiDefinition {
+    /// Returns the endpoint path for this API
+    fn endpoint(&self) -> &'static str;
+
+    /// Creates an API instance from an endpoint path
+    fn from_endpoint(endpoint: &str) -> Option<Self>
+    where
+        Self: Sized;
+
+    /// Returns whether this API supports streaming responses
+    fn supports_streaming(&self) -> bool;
+
+    /// Returns whether this API supports tool/function calling
+    fn supports_tools(&self) -> bool;
+
+    /// Returns whether this API supports vision/image processing
+    fn supports_vision(&self) -> bool;
+
+    /// Returns all variants of this API enum
+    fn all_variants() -> Vec<Self>
+    where
+        Self: Sized;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_generic_api_functionality() {
+        // Test that our generic API functionality works with both providers
+        fn test_api<T: ApiDefinition>(api: &T) {
+            let endpoint = api.endpoint();
+            assert!(!endpoint.is_empty());
+            assert!(endpoint.starts_with('/'));
+        }
+
+        test_api(&OpenAIApi::ChatCompletions);
+        test_api(&AnthropicApi::Messages);
+    }
+
+    #[test]
+    fn test_api_detection_from_endpoints() {
+        // Test that we can detect APIs from endpoints using the trait
+        let endpoints = vec![
+            "/v1/chat/completions",
+            "/v1/messages",
+            "/v1/unknown"
+        ];
+
+        let mut detected_apis = Vec::new();
+
+        for endpoint in endpoints {
+            if let Some(api) = OpenAIApi::from_endpoint(endpoint) {
+                detected_apis.push(format!("OpenAI: {:?}", api));
+            } else if let Some(api) = AnthropicApi::from_endpoint(endpoint) {
+                detected_apis.push(format!("Anthropic: {:?}", api));
+            } else {
+                detected_apis.push("Unknown API".to_string());
+            }
+        }
+
+        assert_eq!(detected_apis, vec![
+            "OpenAI: ChatCompletions",
+            "Anthropic: Messages",
+            "Unknown API"
+        ]);
+    }
+
+    #[test]
+    fn test_all_variants_method() {
+        // Test that all_variants returns the expected variants
+        let openai_variants = OpenAIApi::all_variants();
+        assert_eq!(openai_variants.len(), 1);
+        assert!(openai_variants.contains(&OpenAIApi::ChatCompletions));
+
+        let anthropic_variants = AnthropicApi::all_variants();
+        assert_eq!(anthropic_variants.len(), 1);
+        assert!(anthropic_variants.contains(&AnthropicApi::Messages));
+
+        // Verify each variant has a valid endpoint
+        for variant in openai_variants {
+            assert!(!variant.endpoint().is_empty());
+        }
+
+        for variant in anthropic_variants {
+            assert!(!variant.endpoint().is_empty());
+        }
+    }
+}
diff --git a/crates/hermesllm/src/apis/openai.rs b/crates/hermesllm/src/apis/openai.rs
new file mode 100644
index 00000000..7f75c6be
--- /dev/null
+++ b/crates/hermesllm/src/apis/openai.rs
@@ -0,0 +1,883 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use serde_with::skip_serializing_none;
+use std::collections::HashMap;
+
+use super::ApiDefinition;
+
+// ============================================================================
+// OPENAI API ENUMERATION
+// ============================================================================
+
+/// Enum for all supported OpenAI APIs
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum OpenAIApi {
+    ChatCompletions,
+    // Future APIs can be added here:
+    // Embeddings,
+    // FineTuning,
+    // etc.
+}
+
+impl ApiDefinition for OpenAIApi {
+    fn endpoint(&self) -> &'static str {
+        match self {
+            OpenAIApi::ChatCompletions => "/v1/chat/completions",
+        }
+    }
+
+    fn from_endpoint(endpoint: &str) -> Option<Self> {
+        match endpoint {
+            "/v1/chat/completions" => Some(OpenAIApi::ChatCompletions),
+            _ => None,
+        }
+    }
+
+    fn supports_streaming(&self) -> bool {
+        match self {
+            OpenAIApi::ChatCompletions => true,
+        }
+    }
+
+    fn supports_tools(&self) -> bool {
+         match self {
+            OpenAIApi::ChatCompletions => true,
+        }
+    }
+
+    fn supports_vision(&self) -> bool {
+        match self {
+            OpenAIApi::ChatCompletions => true,
+        }
+    }
+
+    fn all_variants() -> Vec<Self> {
+        vec![
+            OpenAIApi::ChatCompletions,
+        ]
+    }
+}
+
+/// Chat completions API request
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+pub struct ChatCompletionsRequest {
+    pub messages: Vec<Message>,
+    pub model: String,
+    // pub audio: Option<Audio> // GOOD FIRST ISSUE: future support for audio input
+    pub frequency_penalty: Option<f32>,
+    // Function calling configuration has been deprecated, but we keep it for compatibility
+    pub function_call: Option<FunctionChoice>,
+    pub functions: Option<Vec<Tool>>,
+    pub logit_bias: Option<HashMap<String, i32>>,
+    pub logprobs: Option<bool>,
+    pub max_completion_tokens: Option<u32>,
+    // Maximum tokens in the response has been deprecated, but we keep it for compatibility
+    pub max_tokens: Option<u32>,
+    pub modalities: Option<Vec<String>>,
+    pub metadata: Option<HashMap<String, String>>,
+    pub n: Option<u32>,
+    pub presence_penalty: Option<f32>,
+    pub parallel_tool_calls: Option<bool>,
+    pub prediction: Option<StaticContent>,
+    // pub reasoning_effect: Option<bool>, // GOOD FIRST ISSUE: Future support for reasoning effects
+    pub response_format: Option<Value>,
+    // pub safety_identifier: Option<String>, // GOOD FIRST ISSUE: Future support for safety identifiers
+    pub seed: Option<i32>,
+    pub service_tier: Option<String>,
+    pub stop: Option<Vec<String>>,
+    pub store: Option<bool>,
+    pub stream: Option<bool>,
+    pub stream_options: Option<StreamOptions>,
+    pub temperature: Option<f32>,
+    pub tool_choice: Option<ToolChoice>,
+    pub tools: Option<Vec<Tool>>,
+    pub top_p: Option<f32>,
+    pub top_logprobs: Option<u32>,
+    pub user: Option<String>,
+    // pub web_search: Option<bool>, // GOOD FIRST ISSUE: Future support for web search
+}
+
+// ============================================================================
+// CHAT COMPLETIONS API TYPES
+// ============================================================================
+
+/// Message role in a chat conversation
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum Role {
+    System,
+    User,
+    Assistant,
+    Tool,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Message {
+    pub content: MessageContent,
+    pub role: Role,
+    pub name: Option<String>,
+    /// Tool calls made by the assistant (only present for assistant role)
+    pub tool_calls: Option<Vec<ToolCall>>,
+    /// ID of the tool call that this message is responding to (only present for tool role)
+    pub tool_call_id: Option<String>,
+}
+
+
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ResponseMessage {
+    pub role: Role,
+    /// The contents of the message (can be null for some cases)
+    pub content: Option<String>,
+    /// The refusal message generated by the model
+    pub refusal: Option<String>,
+    /// Annotations for the message, when applicable, as when using the web search tool
+    pub annotations: Option<Vec<Value>>,
+    /// If the audio output modality is requested, this object contains data about the audio response
+    pub audio: Option<Value>,
+    /// Deprecated and replaced by tool_calls. The name and arguments of a function that should be called
+    pub function_call: Option<FunctionCall>,
+    /// The tool calls generated by the model, such as function calls
+    pub tool_calls: Option<Vec<ToolCall>>,
+}
+
+impl ResponseMessage {
+    /// Convert ResponseMessage to Message for internal processing
+    /// This is useful for transformations that need to work with the request Message type
+    pub fn to_message(&self) -> Message {
+        Message {
+            role: self.role.clone(),
+            content: self.content.as_ref()
+                .map(|s| MessageContent::Text(s.clone()))
+                .unwrap_or(MessageContent::Text(String::new())),
+            name: None, // Response messages don't have names in the same way request messages do
+            tool_calls: self.tool_calls.clone(),
+            tool_call_id: None, // Response messages don't have tool_call_id
+        }
+    }
+}
+
+/// In the OpenAI API, this is represented as either:
+/// - A string for simple text content
+/// - An array of content parts for multimodal content (text + images)
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum MessageContent {
+    Text(String),
+    Parts(Vec<ContentPart>),
+}
+
+/// Individual content part within a message (text or image)
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum ContentPart {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image_url")]
+    ImageUrl { image_url: ImageUrl },
+}
+
+/// Image URL configuration for vision capabilities
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ImageUrl {
+    pub url: String,
+    pub detail: Option<String>,
+}
+
+/// A single message in a chat conversation
+
+
+/// A tool call made by the assistant
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct ToolCall {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub call_type: String,
+    pub function: FunctionCall,
+}
+
+/// Function call within a tool call
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct FunctionCall {
+    pub name: String,
+    pub arguments: String,
+}
+
+/// Tool definition for function calling
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Tool {
+    #[serde(rename = "type")]
+    pub tool_type: String,
+    pub function: Function,
+}
+
+/// Function definition within a tool
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Function {
+    pub name: String,
+    pub description: Option<String>,
+    pub parameters: Value,
+    pub strict: Option<bool>,
+}
+
+/// Tool choice string values
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ToolChoiceType {
+    /// Let the model automatically decide whether to call tools
+    Auto,
+    /// Force the model to call at least one tool
+    Required,
+    /// Prevent the model from calling any tools
+    None,
+}
+
+/// Tool choice configuration
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+#[serde(untagged)]
+pub enum ToolChoice {
+    /// String-based tool choice (auto, required, none)
+    Type(ToolChoiceType),
+    /// Specific function to call
+    Function {
+        #[serde(rename = "type")]
+        choice_type: String,
+        function: FunctionChoice,
+    },
+}
+
+/// Specific function choice
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct FunctionChoice {
+    pub name: String,
+}
+
+/// Static content for prediction/prefill functionality
+///
+/// Static predicted output content, such as the content of a text file
+/// that is being regenerated.
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct StaticContent {
+    /// The type of the predicted content you want to provide.
+    /// This type is currently always "content".
+    #[serde(rename = "type")]
+    pub content_type: String,
+    /// The content that should be matched when generating a model response.
+    /// If generated tokens would match this content, the entire model response
+    /// can be returned much more quickly.
+    ///
+    /// Can be either:
+    /// - A string for simple text content
+    /// - An array of content parts for structured content
+    pub content: StaticContentType,
+}
+
+/// Content type for static/predicted content
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum StaticContentType {
+    /// Simple text content - the content used for a Predicted Output.
+    /// This is often the text of a file you are regenerating with minor changes.
+    Text(String),
+    /// An array of content parts with a defined type.
+    /// Can contain text inputs and other supported content types.
+    Parts(Vec<ContentPart>),
+}
+
+
+/// Chat completions API response
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ChatCompletionsResponse {
+    pub id: String,
+    pub object: String,
+    pub created: u64,
+    pub model: String,
+    pub choices: Vec<Choice>,
+    pub usage: Usage,
+    pub system_fingerprint: Option<String>,
+}
+
+/// Finish reason for completion
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum FinishReason {
+    Stop,
+    Length,
+    ToolCalls,
+    ContentFilter,
+    FunctionCall, // Legacy
+}
+
+/// Token usage information
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Usage {
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+    pub total_tokens: u32,
+    pub prompt_tokens_details: Option<PromptTokensDetails>,
+    pub completion_tokens_details: Option<CompletionTokensDetails>,
+}
+
+/// Detailed breakdown of prompt tokens
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct PromptTokensDetails {
+    pub cached_tokens: Option<u32>,
+    pub audio_tokens: Option<u32>,
+}
+
+/// Detailed breakdown of completion tokens
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CompletionTokensDetails {
+    pub reasoning_tokens: Option<u32>,
+    pub audio_tokens: Option<u32>,
+    pub accepted_prediction_tokens: Option<u32>,
+    pub rejected_prediction_tokens: Option<u32>,
+}
+
+/// A single choice in the response
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Choice {
+    pub index: u32,
+    pub message: ResponseMessage,
+    pub finish_reason: Option<FinishReason>,
+    pub logprobs: Option<Value>,
+}
+
+
+// ============================================================================
+// STREAMING API TYPES
+// ============================================================================
+
+/// Streaming response from chat completions API
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ChatCompletionsStreamResponse {
+    pub id: String,
+    pub object: String,
+    pub created: u64,
+    pub model: String,
+    pub choices: Vec<StreamChoice>,
+    pub usage: Option<Usage>, // Only in final chunk
+    pub system_fingerprint: Option<String>,
+    /// Specifies the processing type used for serving the request
+    pub service_tier: Option<String>,
+}
+
+
+/// A choice in a streaming response
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct StreamChoice {
+    pub index: u32,
+    pub delta: MessageDelta,
+    pub finish_reason: Option<FinishReason>,
+    pub logprobs: Option<Value>,
+}
+
+/// Message delta for streaming updates
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MessageDelta {
+    pub role: Option<Role>,
+    pub content: Option<String>,
+    /// The refusal message generated by the model
+    pub refusal: Option<String>,
+    /// Deprecated and replaced by tool_calls. The name and arguments of a function that should be called
+    pub function_call: Option<FunctionCall>,
+    pub tool_calls: Option<Vec<ToolCallDelta>>,
+}
+
+/// Tool call delta for streaming tool call updates
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct ToolCallDelta {
+    pub index: u32,
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub call_type: Option<String>,
+    pub function: Option<FunctionCallDelta>,
+}
+
+/// Function call delta for streaming function call updates
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct FunctionCallDelta {
+    pub name: Option<String>,
+    pub arguments: Option<String>,
+}
+
+/// Stream options for controlling streaming behavior
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct StreamOptions {
+    pub include_usage: Option<bool>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_required_fields() {
+        // Create a JSON object with only required fields
+        let original_json = json!({
+            "model": "gpt-4",
+            "messages": [
+                {
+                    "content": "Hello, world!",
+                    "role": "user"
+                }
+            ]
+        });
+
+        // Deserialize JSON into ChatCompletionsRequest
+        let deserialized_request: ChatCompletionsRequest = serde_json::from_value(original_json.clone()).unwrap();
+
+        // Validate required fields are properly set
+        assert_eq!(deserialized_request.model, "gpt-4");
+        assert_eq!(deserialized_request.messages.len(), 1);
+
+        let message = &deserialized_request.messages[0];
+        assert_eq!(message.role, Role::User);
+        if let MessageContent::Text(content) = &message.content {
+            assert_eq!(content, "Hello, world!");
+        } else {
+            panic!("Expected text content");
+        }
+
+        // Serialize the ChatCompletionsRequest back to JSON
+        let serialized_json = serde_json::to_value(&deserialized_request).unwrap();
+        assert_eq!(original_json, serialized_json);
+    }
+
+    #[test]
+    fn test_optional_fields_serialization() {
+        // Create a JSON object with optional fields set
+        let original_json = json!({
+            "model": "gpt-4",
+            "messages": [
+                {
+                    "content": "Test message",
+                    "role": "user",
+                    "name": "test_user"
+                }
+            ],
+            "temperature": 0.7,
+            "max_tokens": 150,
+            "stream": true,
+            "stream_options": {
+                "include_usage": true
+            },
+            "metadata": {
+                "user_id": "123"
+            }
+        });
+
+        // Deserialize JSON into ChatCompletionsRequest
+        let deserialized_request: ChatCompletionsRequest = serde_json::from_value(original_json.clone()).unwrap();
+
+        // Validate required fields
+        assert_eq!(deserialized_request.model, "gpt-4");
+        assert_eq!(deserialized_request.messages.len(), 1);
+
+        let message = &deserialized_request.messages[0];
+        assert_eq!(message.role, Role::User);
+        if let MessageContent::Text(content) = &message.content {
+            assert_eq!(content, "Test message");
+        } else {
+            panic!("Expected text content");
+        }
+        assert_eq!(message.name, Some("test_user".to_string()));
+
+        // Validate optional fields are properly set
+        assert!((deserialized_request.temperature.unwrap() - 0.7).abs() < 1e-6);
+        assert_eq!(deserialized_request.max_tokens, Some(150));
+        assert_eq!(deserialized_request.stream, Some(true));
+        assert!(deserialized_request.stream_options.is_some());
+        assert!(deserialized_request.metadata.is_some());
+
+        // Validate fields not in JSON are None
+        assert!(deserialized_request.top_p.is_none());
+        assert!(deserialized_request.frequency_penalty.is_none());
+        assert!(deserialized_request.presence_penalty.is_none());
+        assert!(deserialized_request.stop.is_none());
+        assert!(deserialized_request.tools.is_none());
+
+        // Serialize back to JSON and compare (handle floating point precision)
+        let serialized_json = serde_json::to_value(&deserialized_request).unwrap();
+
+        // Compare all fields except temperature which needs floating point comparison
+        assert_eq!(serialized_json["model"], original_json["model"]);
+        assert_eq!(serialized_json["messages"], original_json["messages"]);
+        assert_eq!(serialized_json["max_tokens"], original_json["max_tokens"]);
+        assert_eq!(serialized_json["stream"], original_json["stream"]);
+        assert_eq!(serialized_json["stream_options"], original_json["stream_options"]);
+        assert_eq!(serialized_json["metadata"], original_json["metadata"]);
+
+        // Handle temperature with floating point tolerance
+        let original_temp = original_json["temperature"].as_f64().unwrap();
+        let serialized_temp = serialized_json["temperature"].as_f64().unwrap();
+        assert!((original_temp - serialized_temp).abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_nested_types_serialization() {
+        // Create a comprehensive JSON object with nested types - a ChatCompletionsRequest with complex message content and tools
+        let original_json = json!({
+            "model": "gpt-4-vision-preview",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "What can you see in this image and what's the weather like in the location shown?"
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": "https://example.com/cityscape.jpg",
+                                "detail": "high"
+                            }
+                        }
+                    ]
+                },
+                {
+                    "role": "assistant",
+                    "content": "I can see a beautiful cityscape. Let me check the weather for you.",
+                    "tool_calls": [
+                        {
+                            "id": "call_weather123",
+                            "type": "function",
+                            "function": {
+                                "name": "get_weather",
+                                "arguments": "{\"location\": \"New York, NY\"}"
+                            }
+                        }
+                    ]
+                },
+                {
+                    "role": "tool",
+                    "content": "Current weather in New York: 72°F, sunny",
+                    "tool_call_id": "call_weather123"
+                }
+            ],
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "get_weather",
+                        "description": "Get current weather information for a location",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "location": {
+                                    "type": "string",
+                                    "description": "The city and state, e.g. San Francisco, CA"
+                                }
+                            },
+                            "required": ["location"]
+                        },
+                        "strict": true
+                    }
+                }
+            ],
+            "tool_choice": "auto",
+            "temperature": 0.7,
+            "max_tokens": 1000,
+            "prediction": {
+                "type": "content",
+                "content": "Based on the image analysis and weather data, I can provide you with comprehensive information."
+            }
+        });
+
+        // Deserialize JSON into ChatCompletionsRequest
+        let deserialized_request: ChatCompletionsRequest = serde_json::from_value(original_json.clone()).unwrap();
+
+        // Validate top-level fields
+        assert_eq!(deserialized_request.model, "gpt-4-vision-preview");
+        assert_eq!(deserialized_request.messages.len(), 3);
+        assert!((deserialized_request.temperature.unwrap() - 0.7).abs() < 1e-6);
+        assert_eq!(deserialized_request.max_tokens, Some(1000));
+
+        // Validate first message (user with multimodal content)
+        let user_message = &deserialized_request.messages[0];
+        assert_eq!(user_message.role, Role::User);
+        if let MessageContent::Parts(ref content_parts) = user_message.content {
+            assert_eq!(content_parts.len(), 2);
+
+            // Validate text content part
+            if let ContentPart::Text { text } = &content_parts[0] {
+                assert_eq!(text, "What can you see in this image and what's the weather like in the location shown?");
+            } else {
+                panic!("Expected text content part");
+            }
+
+            // Validate image URL content part
+            if let ContentPart::ImageUrl { ref image_url } = content_parts[1] {
+                assert_eq!(image_url.url, "https://example.com/cityscape.jpg");
+                assert_eq!(image_url.detail, Some("high".to_string()));
+            } else {
+                panic!("Expected image URL content part");
+            }
+        } else {
+            panic!("Expected multimodal content parts for user message");
+        }
+
+        // Validate second message (assistant with tool calls)
+        let assistant_message = &deserialized_request.messages[1];
+        assert_eq!(assistant_message.role, Role::Assistant);
+        if let MessageContent::Text(text) = &assistant_message.content {
+            assert_eq!(text, "I can see a beautiful cityscape. Let me check the weather for you.");
+        } else {
+            panic!("Expected text content for assistant message");
+        }
+
+        // Validate tool calls in assistant message
+        assert!(assistant_message.tool_calls.is_some());
+        let tool_calls = assistant_message.tool_calls.as_ref().unwrap();
+        assert_eq!(tool_calls.len(), 1);
+
+        let tool_call = &tool_calls[0];
+        assert_eq!(tool_call.id, "call_weather123");
+        assert_eq!(tool_call.call_type, "function");
+        assert_eq!(tool_call.function.name, "get_weather");
+        assert_eq!(tool_call.function.arguments, "{\"location\": \"New York, NY\"}");
+
+        // Validate third message (tool response)
+        let tool_message = &deserialized_request.messages[2];
+        assert_eq!(tool_message.role, Role::Tool);
+        if let MessageContent::Text(text) = &tool_message.content {
+            assert_eq!(text, "Current weather in New York: 72°F, sunny");
+        } else {
+            panic!("Expected text content for tool message");
+        }
+        assert_eq!(tool_message.tool_call_id, Some("call_weather123".to_string()));
+
+        // Validate tools array
+        assert!(deserialized_request.tools.is_some());
+        let tools = deserialized_request.tools.as_ref().unwrap();
+        assert_eq!(tools.len(), 1);
+
+        let tool = &tools[0];
+        assert_eq!(tool.tool_type, "function");
+        assert_eq!(tool.function.name, "get_weather");
+        assert_eq!(tool.function.description, Some("Get current weather information for a location".to_string()));
+        assert_eq!(tool.function.strict, Some(true));
+
+        // Validate tool parameters schema
+        let parameters = &tool.function.parameters;
+        assert_eq!(parameters["type"], "object");
+        assert!(parameters["properties"]["location"].is_object());
+        assert_eq!(parameters["required"], json!(["location"]));
+
+        // Validate tool choice
+        if let Some(ToolChoice::Type(choice)) = &deserialized_request.tool_choice {
+            assert_eq!(choice, &ToolChoiceType::Auto);
+        } else {
+            panic!("Expected auto tool choice");
+        }
+
+        // Validate prediction
+        assert!(deserialized_request.prediction.is_some());
+        let prediction = deserialized_request.prediction.as_ref().unwrap();
+        assert_eq!(prediction.content_type, "content");
+        if let StaticContentType::Text(text) = &prediction.content {
+            assert_eq!(text, "Based on the image analysis and weather data, I can provide you with comprehensive information.");
+        } else {
+            panic!("Expected text prediction content");
+        }
+
+        // Serialize back to JSON and compare (handle floating point precision)
+        let serialized_json = serde_json::to_value(&deserialized_request).unwrap();
+
+        // Compare all fields except floating point ones
+        assert_eq!(serialized_json["model"], original_json["model"]);
+        assert_eq!(serialized_json["messages"], original_json["messages"]);
+        assert_eq!(serialized_json["max_tokens"], original_json["max_tokens"]);
+        assert_eq!(serialized_json["tools"], original_json["tools"]);
+        assert_eq!(serialized_json["tool_choice"], original_json["tool_choice"]);
+        assert_eq!(serialized_json["prediction"], original_json["prediction"]);
+
+        // Handle floating point field with tolerance
+        let original_temp = original_json["temperature"].as_f64().unwrap();
+        let serialized_temp = serialized_json["temperature"].as_f64().unwrap();
+        assert!((original_temp - serialized_temp).abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_api_provider_trait() {
+        // Test the ApiDefinition trait implementation
+        let api = OpenAIApi::ChatCompletions;
+
+        // Test trait methods
+        assert_eq!(api.endpoint(), "/v1/chat/completions");
+        assert!(api.supports_streaming());
+        assert!(api.supports_tools());
+        assert!(api.supports_vision());
+
+        // Test from_endpoint
+        let found_api = OpenAIApi::from_endpoint("/v1/chat/completions");
+        assert_eq!(found_api, Some(OpenAIApi::ChatCompletions));
+
+        let not_found = OpenAIApi::from_endpoint("/v1/unknown");
+        assert_eq!(not_found, None);
+
+        // Test all_variants
+        let all_variants = OpenAIApi::all_variants();
+        assert_eq!(all_variants.len(), 1);
+        assert_eq!(all_variants[0], OpenAIApi::ChatCompletions);
+    }
+
+    #[test]
+    fn test_role_specific_behavior() {
+        // Test 1: User message - basic content, no tool-related fields
+        let user_json = json!({
+            "content": "Hello!",
+            "role": "user",
+            "name": "user123"
+        });
+
+        let deserialized_user: Message = serde_json::from_value(user_json.clone()).unwrap();
+        assert_eq!(deserialized_user.role, Role::User);
+        if let MessageContent::Text(content) = &deserialized_user.content {
+            assert_eq!(content, "Hello!");
+        } else {
+            panic!("Expected text content");
+        }
+        assert_eq!(deserialized_user.name, Some("user123".to_string()));
+        assert!(deserialized_user.tool_calls.is_none());
+        assert!(deserialized_user.tool_call_id.is_none());
+
+        let serialized_user_json = serde_json::to_value(&deserialized_user).unwrap();
+        assert_eq!(user_json, serialized_user_json);
+
+        // Test 2: Assistant message with tool calls
+        let assistant_json = json!({
+            "content": "I'll help with that.",
+            "role": "assistant",
+            "tool_calls": [
+                {
+                    "id": "call_456",
+                    "type": "function",
+                    "function": {
+                        "name": "get_weather",
+                        "arguments": r#"{"location":"SF"}"#
+                    }
+                }
+            ]
+        });
+
+        let deserialized_assistant: Message = serde_json::from_value(assistant_json.clone()).unwrap();
+        assert_eq!(deserialized_assistant.role, Role::Assistant);
+        if let MessageContent::Text(content) = &deserialized_assistant.content {
+            assert_eq!(content, "I'll help with that.");
+        } else {
+            panic!("Expected text content");
+        }
+        assert!(deserialized_assistant.tool_calls.is_some());
+        assert!(deserialized_assistant.tool_call_id.is_none());
+        assert!(deserialized_assistant.name.is_none());
+
+        let tool_calls = deserialized_assistant.tool_calls.as_ref().unwrap();
+        assert_eq!(tool_calls.len(), 1);
+        assert_eq!(tool_calls[0].id, "call_456");
+        assert_eq!(tool_calls[0].function.name, "get_weather");
+
+        let serialized_assistant_json = serde_json::to_value(&deserialized_assistant).unwrap();
+        assert_eq!(assistant_json, serialized_assistant_json);
+
+        // Test 3: Tool message responding to a call
+        let tool_json = json!({
+            "content": "Weather is sunny",
+            "role": "tool",
+            "tool_call_id": "call_456"
+        });
+
+        let deserialized_tool: Message = serde_json::from_value(tool_json.clone()).unwrap();
+        assert_eq!(deserialized_tool.role, Role::Tool);
+        if let MessageContent::Text(content) = &deserialized_tool.content {
+            assert_eq!(content, "Weather is sunny");
+        } else {
+            panic!("Expected text content");
+        }
+        assert_eq!(deserialized_tool.tool_call_id, Some("call_456".to_string()));
+        assert!(deserialized_tool.tool_calls.is_none());
+        assert!(deserialized_tool.name.is_none());
+
+        let serialized_tool_json = serde_json::to_value(&deserialized_tool).unwrap();
+        assert_eq!(tool_json, serialized_tool_json);
+
+        // Test 4: ResponseMessage vs Message differences
+        let response_json = json!({
+            "role": "assistant",
+            "content": "Response content",
+            "annotations": [
+                {"type": "citation"}
+            ]
+        });
+
+        let deserialized_response: ResponseMessage = serde_json::from_value(response_json.clone()).unwrap();
+        assert_eq!(deserialized_response.role, Role::Assistant);
+        assert_eq!(deserialized_response.content, Some("Response content".to_string()));
+        assert!(deserialized_response.annotations.is_some());
+        assert!(deserialized_response.refusal.is_none());
+        assert!(deserialized_response.function_call.is_none());
+        assert!(deserialized_response.tool_calls.is_none());
+
+        let serialized_response_json = serde_json::to_value(&deserialized_response).unwrap();
+        assert_eq!(response_json, serialized_response_json);
+
+        // Test conversion from ResponseMessage to Message
+        let converted = deserialized_response.to_message();
+        assert_eq!(converted.role, Role::Assistant);
+        if let MessageContent::Text(text) = converted.content {
+            assert_eq!(text, "Response content");
+        } else {
+            panic!("Expected text content");
+        }
+        assert!(converted.name.is_none());
+        assert!(converted.tool_call_id.is_none());
+    }
+
+    #[test]
+    fn test_tool_choice_type_serialization() {
+        // Test that the enum serializes to the correct string values
+        let auto_choice = ToolChoice::Type(ToolChoiceType::Auto);
+        let required_choice = ToolChoice::Type(ToolChoiceType::Required);
+        let none_choice = ToolChoice::Type(ToolChoiceType::None);
+
+        let auto_json = serde_json::to_value(&auto_choice).unwrap();
+        let required_json = serde_json::to_value(&required_choice).unwrap();
+        let none_json = serde_json::to_value(&none_choice).unwrap();
+
+        assert_eq!(auto_json, "auto");
+        assert_eq!(required_json, "required");
+        assert_eq!(none_json, "none");
+
+        // Test deserialization from string values
+        let auto_deserialized: ToolChoice = serde_json::from_value(json!("auto")).unwrap();
+        let required_deserialized: ToolChoice = serde_json::from_value(json!("required")).unwrap();
+        let none_deserialized: ToolChoice = serde_json::from_value(json!("none")).unwrap();
+
+        assert_eq!(auto_deserialized, ToolChoice::Type(ToolChoiceType::Auto));
+        assert_eq!(required_deserialized, ToolChoice::Type(ToolChoiceType::Required));
+        assert_eq!(none_deserialized, ToolChoice::Type(ToolChoiceType::None));
+
+        // Test that invalid string values fail deserialization (type safety!)
+        let invalid_result: Result<ToolChoice, _> = serde_json::from_value(json!("invalid"));
+        assert!(invalid_result.is_err());
+    }
+}
diff --git a/crates/hermesllm/src/clients/endpoints.rs b/crates/hermesllm/src/clients/endpoints.rs
new file mode 100644
index 00000000..bf0648a9
--- /dev/null
+++ b/crates/hermesllm/src/clients/endpoints.rs
@@ -0,0 +1,130 @@
+//! Supported endpoint registry for LLM APIs
+//!
+//! This module provides a simple registry to check which API endpoint paths
+//! we support across different providers.
+//!
+//! # Examples
+//!
+//! ```rust
+//! use hermesllm::clients::endpoints::{is_supported_endpoint, supported_endpoints};
+//!
+//! // Check if we support an endpoint
+//! assert!(is_supported_endpoint("/v1/chat/completions"));
+//! assert!(is_supported_endpoint("/v1/messages"));
+//! assert!(!is_supported_endpoint("/v1/unknown"));
+//!
+//! // Get all supported endpoints
+//! let endpoints = supported_endpoints();
+//! assert_eq!(endpoints.len(), 2);
+//! assert!(endpoints.contains(&"/v1/chat/completions"));
+//! assert!(endpoints.contains(&"/v1/messages"));
+//! ```
+
+use crate::apis::{AnthropicApi, OpenAIApi, ApiDefinition};
+
+/// Check if the given endpoint path is supported
+pub fn is_supported_endpoint(endpoint: &str) -> bool {
+    // Try OpenAI APIs
+    if OpenAIApi::from_endpoint(endpoint).is_some() {
+        return true;
+    }
+
+    // Try Anthropic APIs
+    if AnthropicApi::from_endpoint(endpoint).is_some() {
+        return true;
+    }
+
+    false
+}
+
+/// Get all supported endpoint paths
+pub fn supported_endpoints() -> Vec<&'static str> {
+    let mut endpoints = Vec::new();
+
+    // Add all OpenAI endpoints
+    for api in OpenAIApi::all_variants() {
+        endpoints.push(api.endpoint());
+    }
+
+    // Add all Anthropic endpoints
+    for api in AnthropicApi::all_variants() {
+        endpoints.push(api.endpoint());
+    }
+
+    endpoints
+}
+
+/// Identify which provider supports a given endpoint
+pub fn identify_provider(endpoint: &str) -> Option<&'static str> {
+    if OpenAIApi::from_endpoint(endpoint).is_some() {
+        return Some("openai");
+    }
+
+    if AnthropicApi::from_endpoint(endpoint).is_some() {
+        return Some("anthropic");
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_supported_endpoint() {
+        // OpenAI endpoints
+        assert!(is_supported_endpoint("/v1/chat/completions"));
+
+        // Anthropic endpoints
+        assert!(is_supported_endpoint("/v1/messages"));
+
+        // Unsupported endpoints
+        assert!(!is_supported_endpoint("/v1/unknown"));
+        assert!(!is_supported_endpoint("/v2/chat"));
+        assert!(!is_supported_endpoint(""));
+    }
+
+    #[test]
+    fn test_supported_endpoints() {
+        let endpoints = supported_endpoints();
+        assert_eq!(endpoints.len(), 2);
+        assert!(endpoints.contains(&"/v1/chat/completions"));
+        assert!(endpoints.contains(&"/v1/messages"));
+    }
+
+    #[test]
+    fn test_identify_provider() {
+        assert_eq!(identify_provider("/v1/chat/completions"), Some("openai"));
+        assert_eq!(identify_provider("/v1/messages"), Some("anthropic"));
+        assert_eq!(identify_provider("/v1/unknown"), None);
+    }
+
+    #[test]
+    fn test_endpoints_generated_from_api_definitions() {
+        let endpoints = supported_endpoints();
+
+        // Verify that we get endpoints from all API variants
+        let openai_endpoints: Vec<_> = OpenAIApi::all_variants()
+            .iter()
+            .map(|api| api.endpoint())
+            .collect();
+        let anthropic_endpoints: Vec<_> = AnthropicApi::all_variants()
+            .iter()
+            .map(|api| api.endpoint())
+            .collect();
+
+        // All OpenAI endpoints should be in the result
+        for endpoint in openai_endpoints {
+            assert!(endpoints.contains(&endpoint), "Missing OpenAI endpoint: {}", endpoint);
+        }
+
+        // All Anthropic endpoints should be in the result
+        for endpoint in anthropic_endpoints {
+            assert!(endpoints.contains(&endpoint), "Missing Anthropic endpoint: {}", endpoint);
+        }
+
+        // Total should match
+        assert_eq!(endpoints.len(), OpenAIApi::all_variants().len() + AnthropicApi::all_variants().len());
+    }
+}
diff --git a/crates/hermesllm/src/clients/lib.rs b/crates/hermesllm/src/clients/lib.rs
new file mode 100644
index 00000000..85b7e4c7
--- /dev/null
+++ b/crates/hermesllm/src/clients/lib.rs
@@ -0,0 +1,33 @@
+//! Helper functions and utilities for API transformations
+//! Contains error types and shared utilities
+
+use thiserror::Error;
+
+// ============================================================================
+// ERROR TYPES
+// ============================================================================
+
+#[derive(Error, Debug)]
+pub enum TransformError {
+    #[error("JSON serialization error: {0}")]
+    JsonError(#[from] serde_json::Error),
+    #[error("Unsupported content type: {0}")]
+    UnsupportedContent(String),
+    #[error("Invalid tool input format")]
+    InvalidToolInput,
+    #[error("Missing required field: {0}")]
+    MissingField(String),
+    #[error("Unsupported conversion: {0}")]
+    UnsupportedConversion(String),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_error_types() {
+        let error = TransformError::MissingField("test".to_string());
+        assert!(matches!(error, TransformError::MissingField(_)));
+    }
+}
diff --git a/crates/hermesllm/src/clients/mod.rs b/crates/hermesllm/src/clients/mod.rs
new file mode 100644
index 00000000..eb3032ce
--- /dev/null
+++ b/crates/hermesllm/src/clients/mod.rs
@@ -0,0 +1,9 @@
+pub mod lib;
+pub mod transformer;
+pub mod endpoints;
+
+// Re-export the main items for easier access
+pub use lib::*;
+pub use endpoints::{is_supported_endpoint, supported_endpoints, identify_provider};
+
+// Note: transformer module contains TryFrom trait implementations that are automatically available
diff --git a/crates/hermesllm/src/clients/transformer.rs b/crates/hermesllm/src/clients/transformer.rs
new file mode 100644
index 00000000..c6d524f4
--- /dev/null
+++ b/crates/hermesllm/src/clients/transformer.rs
@@ -0,0 +1,1722 @@
+//! API request/response transformers between Anthropic and OpenAI APIs
+//!
+//! This module provides clean, bidirectional conversion between different LLM API formats
+//! using Rust's standard `TryFrom` and `Into` traits. The organization follows a logical flow:
+//!
+//! 1. **Main Request Transformations** - Core TryFrom implementations for requests
+//! 2. **Main Response Transformations** - Core TryFrom implementations for responses
+//! 3. **Streaming Transformations** - Bidirectional streaming event conversion
+//! 4. **Standard Rust Trait Implementations** - Into/TryFrom implementations for type conversions
+//! 5. **Helper Functions** - Utility functions organized by domain
+//!
+//! # Examples
+//!
+//! ```rust
+//! use hermesllm::apis::{
+//!     AnthropicMessagesRequest, ChatCompletionsRequest, MessagesRole, MessagesMessage,
+//!     MessagesMessageContent, MessagesSystemPrompt,
+//! };
+//! use hermesllm::clients::TransformError;
+//! use std::convert::TryInto;
+//!
+//! // Transform Anthropic to OpenAI
+//! let anthropic_req = AnthropicMessagesRequest {
+//!     model: "claude-3-sonnet".to_string(),
+//!     system: None,
+//!     messages: vec![],
+//!     max_tokens: 1024,
+//!     container: None,
+//!     mcp_servers: None,
+//!     service_tier: None,
+//!     thinking: None,
+//!     temperature: None,
+//!     top_p: None,
+//!     top_k: None,
+//!     stream: None,
+//!     stop_sequences: None,
+//!     tools: None,
+//!     tool_choice: None,
+//!     metadata: None,
+//! };
+//! let openai_req: Result<ChatCompletionsRequest, TransformError> = anthropic_req.try_into();
+//! # Ok::<(), Box<dyn std::error::Error>>(())
+//! ```
+
+use serde_json::Value;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+// Import centralized types
+use crate::apis::*;
+use super::TransformError;
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+/// Default maximum tokens when converting from OpenAI to Anthropic and no max_tokens is specified
+const DEFAULT_MAX_TOKENS: u32 = 4096;
+
+// ============================================================================
+// UTILITY TRAITS - Shared traits for content manipulation
+// ============================================================================
+
+/// Trait for extracting text content from various types
+trait ExtractText {
+    fn extract_text(&self) -> String;
+}
+
+/// Trait for utility functions on content collections
+trait ContentUtils<T> {
+    fn extract_tool_calls(&self) -> Result<Option<Vec<ToolCall>>, TransformError>;
+    fn split_for_openai(&self) -> Result<(Vec<ContentPart>, Vec<ToolCall>, Vec<(String, String, bool)>), TransformError>;
+}
+
+// ============================================================================
+// MAIN REQUEST TRANSFORMATIONS
+// ============================================================================
+
+type AnthropicMessagesRequest = MessagesRequest;
+
+
+impl TryFrom<AnthropicMessagesRequest> for ChatCompletionsRequest {
+    type Error = TransformError;
+
+    fn try_from(req: AnthropicMessagesRequest) -> Result<Self, Self::Error> {
+        let mut openai_messages: Vec<Message> = Vec::new();
+
+        // Convert system prompt to system message if present
+        if let Some(system) = req.system {
+            openai_messages.push(system.into());
+        }
+
+        // Convert messages
+        for message in req.messages {
+            let converted_messages: Vec<Message> = message.try_into()?;
+            openai_messages.extend(converted_messages);
+        }
+
+        // Convert tools and tool choice
+        let openai_tools = req.tools.map(|tools| convert_anthropic_tools(tools));
+        let (openai_tool_choice, parallel_tool_calls) = convert_anthropic_tool_choice(req.tool_choice);
+
+        Ok(ChatCompletionsRequest {
+            model: req.model,
+            messages: openai_messages,
+            temperature: req.temperature,
+            top_p: req.top_p,
+            max_tokens: Some(req.max_tokens),
+            stream: req.stream,
+            stop: req.stop_sequences,
+            tools: openai_tools,
+            tool_choice: openai_tool_choice,
+            parallel_tool_calls,
+            ..Default::default()
+        })
+    }
+}
+
+impl TryFrom<ChatCompletionsRequest> for AnthropicMessagesRequest {
+    type Error = TransformError;
+
+    fn try_from(req: ChatCompletionsRequest) -> Result<Self, Self::Error> {
+        let mut system_prompt = None;
+        let mut messages = Vec::new();
+
+        for message in req.messages {
+            match message.role {
+                Role::System => {
+                    system_prompt = Some(message.into());
+                }
+                _ => {
+                    let anthropic_message: MessagesMessage = message.try_into()?;
+                    messages.push(anthropic_message);
+                }
+            }
+        }
+
+        // Convert tools and tool choice
+        let anthropic_tools = req.tools.map(|tools| convert_openai_tools(tools));
+        let anthropic_tool_choice = convert_openai_tool_choice(req.tool_choice, req.parallel_tool_calls);
+
+        Ok(AnthropicMessagesRequest {
+            model: req.model,
+            system: system_prompt,
+            messages,
+            max_tokens: req.max_tokens.unwrap_or(DEFAULT_MAX_TOKENS),
+            container: None,
+            mcp_servers: None,
+            service_tier: None,
+            thinking: None,
+            temperature: req.temperature,
+            top_p: req.top_p,
+            top_k: None, // OpenAI doesn't have top_k
+            stream: req.stream,
+            stop_sequences: req.stop,
+            tools: anthropic_tools,
+            tool_choice: anthropic_tool_choice,
+            metadata: None,
+        })
+    }
+}
+
+// ============================================================================
+// MAIN RESPONSE TRANSFORMATIONS
+// ============================================================================
+
+impl TryFrom<MessagesResponse> for ChatCompletionsResponse {
+    type Error = TransformError;
+
+    fn try_from(resp: MessagesResponse) -> Result<Self, Self::Error> {
+        let content = convert_anthropic_content_to_openai(&resp.content)?;
+        let finish_reason: FinishReason = resp.stop_reason.into();
+        let tool_calls = resp.content.extract_tool_calls()?;
+
+        // Convert MessageContent to String for response
+        let content_string = match content {
+            MessageContent::Text(text) => Some(text),
+            MessageContent::Parts(parts) => {
+                let text = parts.extract_text();
+                if text.is_empty() { None } else { Some(text) }
+            }
+        };
+
+        let message = ResponseMessage {
+            role: Role::Assistant,
+            content: content_string,
+            refusal: None,
+            annotations: None,
+            audio: None,
+            function_call: None,
+            tool_calls,
+        };
+
+        let choice = Choice {
+            index: 0,
+            message,
+            finish_reason: Some(finish_reason),
+            logprobs: None,
+        };
+
+        let usage = Usage {
+            prompt_tokens: resp.usage.input_tokens,
+            completion_tokens: resp.usage.output_tokens,
+            total_tokens: resp.usage.input_tokens + resp.usage.output_tokens,
+            prompt_tokens_details: None,
+            completion_tokens_details: None,
+        };
+
+        Ok(ChatCompletionsResponse {
+            id: resp.id,
+            object: "chat.completion".to_string(),
+            created: current_timestamp(),
+            model: resp.model,
+            choices: vec![choice],
+            usage,
+            system_fingerprint: None,
+        })
+    }
+}
+
+impl TryFrom<ChatCompletionsResponse> for MessagesResponse {
+    type Error = TransformError;
+
+    fn try_from(resp: ChatCompletionsResponse) -> Result<Self, Self::Error> {
+        let choice = resp.choices.into_iter().next()
+            .ok_or_else(|| TransformError::MissingField("choices".to_string()))?;
+
+        let content = convert_openai_message_to_anthropic_content(&choice.message.to_message())?;
+        let stop_reason = choice.finish_reason
+            .map(|fr| fr.into())
+            .unwrap_or(MessagesStopReason::EndTurn);
+
+        let usage = MessagesUsage {
+            input_tokens: resp.usage.prompt_tokens,
+            output_tokens: resp.usage.completion_tokens,
+            cache_creation_input_tokens: None,
+            cache_read_input_tokens: None,
+        };
+
+        Ok(MessagesResponse {
+            id: resp.id,
+            obj_type: "message".to_string(),
+            role: MessagesRole::Assistant,
+            content,
+            model: resp.model,
+            stop_reason,
+            stop_sequence: None,
+            usage,
+            container: None,
+        })
+    }
+}
+
+// ============================================================================
+// STREAMING TRANSFORMATIONS
+// ============================================================================
+
+impl TryFrom<MessagesStreamEvent> for ChatCompletionsStreamResponse {
+    type Error = TransformError;
+
+    fn try_from(event: MessagesStreamEvent) -> Result<Self, Self::Error> {
+        match event {
+            MessagesStreamEvent::MessageStart { message } => {
+                Ok(create_openai_chunk(
+                    &message.id,
+                    &message.model,
+                    MessageDelta {
+                        role: Some(Role::Assistant),
+                        content: None,
+                        refusal: None,
+                        function_call: None,
+                        tool_calls: None,
+                    },
+                    None,
+                    None,
+                ))
+            }
+
+            MessagesStreamEvent::ContentBlockStart { content_block, .. } => {
+                convert_content_block_start(content_block)
+            }
+
+            MessagesStreamEvent::ContentBlockDelta { delta, .. } => {
+                convert_content_delta(delta)
+            }
+
+            MessagesStreamEvent::ContentBlockStop { .. } => {
+                Ok(create_empty_openai_chunk())
+            }
+
+            MessagesStreamEvent::MessageDelta { delta, usage } => {
+                let finish_reason: Option<FinishReason> = Some(delta.stop_reason.into());
+                let openai_usage: Option<Usage> = Some(usage.into());
+
+                Ok(create_openai_chunk(
+                    "stream",
+                    "unknown",
+                    MessageDelta {
+                        role: None,
+                        content: None,
+                        refusal: None,
+                        function_call: None,
+                        tool_calls: None,
+                    },
+                    finish_reason,
+                    openai_usage,
+                ))
+            }
+
+            MessagesStreamEvent::MessageStop => {
+                Ok(create_openai_chunk(
+                    "stream",
+                    "unknown",
+                    MessageDelta {
+                        role: None,
+                        content: None,
+                        refusal: None,
+                        function_call: None,
+                        tool_calls: None,
+                    },
+                    Some(FinishReason::Stop),
+                    None,
+                ))
+            }
+
+            MessagesStreamEvent::Ping => {
+                Ok(ChatCompletionsStreamResponse {
+                    id: "stream".to_string(),
+                    object: "chat.completion.chunk".to_string(),
+                    created: current_timestamp(),
+                    model: "unknown".to_string(),
+                    choices: vec![],
+                    usage: None,
+                    system_fingerprint: None,
+                    service_tier: None,
+                })
+            }
+        }
+    }
+}
+
+impl TryFrom<ChatCompletionsStreamResponse> for MessagesStreamEvent {
+    type Error = TransformError;
+
+    fn try_from(resp: ChatCompletionsStreamResponse) -> Result<Self, Self::Error> {
+        if resp.choices.is_empty() {
+            return Ok(MessagesStreamEvent::Ping);
+        }
+
+        let choice = &resp.choices[0];
+
+        // Handle final chunk with usage
+        if let Some(usage) = resp.usage {
+            if let Some(finish_reason) = &choice.finish_reason {
+                let anthropic_stop_reason: MessagesStopReason = finish_reason.clone().into();
+                return Ok(MessagesStreamEvent::MessageDelta {
+                    delta: MessagesMessageDelta {
+                        stop_reason: anthropic_stop_reason,
+                        stop_sequence: None,
+                    },
+                    usage: usage.into(),
+                });
+            }
+        }
+
+        // Handle role start
+        if let Some(Role::Assistant) = choice.delta.role {
+            return Ok(MessagesStreamEvent::MessageStart {
+                message: MessagesStreamMessage {
+                    id: resp.id,
+                    obj_type: "message".to_string(),
+                    role: MessagesRole::Assistant,
+                    content: vec![],
+                    model: resp.model,
+                    stop_reason: None,
+                    stop_sequence: None,
+                    usage: MessagesUsage {
+                        input_tokens: 0,
+                        output_tokens: 0,
+                        cache_creation_input_tokens: None,
+                        cache_read_input_tokens: None,
+                    },
+                },
+            });
+        }
+
+        // Handle content delta
+        if let Some(content) = &choice.delta.content {
+            if !content.is_empty() {
+                return Ok(MessagesStreamEvent::ContentBlockDelta {
+                    index: 0,
+                    delta: MessagesContentDelta::TextDelta {
+                        text: content.clone(),
+                    },
+                });
+            }
+        }
+
+        // Handle tool calls
+        if let Some(tool_calls) = &choice.delta.tool_calls {
+            return convert_tool_call_deltas(tool_calls.clone());
+        }
+
+        // Handle finish reason
+        if let Some(finish_reason) = &choice.finish_reason {
+            if *finish_reason == FinishReason::Stop {
+                return Ok(MessagesStreamEvent::MessageStop);
+            }
+        }
+
+        // Default to ping for unhandled cases
+        Ok(MessagesStreamEvent::Ping)
+    }
+}
+
+// ============================================================================
+// STANDARD RUST TRAIT IMPLEMENTATIONS - Using Into/TryFrom for conversions
+// ============================================================================
+
+// System Prompt Conversions
+impl Into<Message> for MessagesSystemPrompt {
+    fn into(self) -> Message {
+        let system_content = match self {
+            MessagesSystemPrompt::Single(text) => MessageContent::Text(text),
+            MessagesSystemPrompt::Blocks(blocks) => {
+                MessageContent::Text(blocks.extract_text())
+            }
+        };
+
+        Message {
+            role: Role::System,
+            content: system_content,
+            name: None,
+            tool_calls: None,
+            tool_call_id: None,
+        }
+    }
+}
+
+impl Into<MessagesSystemPrompt> for Message {
+    fn into(self) -> MessagesSystemPrompt {
+        let system_text = match self.content {
+            MessageContent::Text(text) => text,
+            MessageContent::Parts(parts) => parts.extract_text()
+        };
+        MessagesSystemPrompt::Single(system_text)
+    }
+}
+
+// Message Conversions
+impl TryFrom<MessagesMessage> for Vec<Message> {
+    type Error = TransformError;
+
+    fn try_from(message: MessagesMessage) -> Result<Self, Self::Error> {
+        let mut result = Vec::new();
+
+        match message.content {
+            MessagesMessageContent::Single(text) => {
+                result.push(Message {
+                    role: message.role.into(),
+                    content: MessageContent::Text(text),
+                    name: None,
+                    tool_calls: None,
+                    tool_call_id: None,
+                });
+            }
+            MessagesMessageContent::Blocks(blocks) => {
+                let (content_parts, tool_calls, tool_results) = blocks.split_for_openai()?;
+
+                // Create main message
+                let content = build_openai_content(content_parts, &tool_calls);
+                let main_message = Message {
+                    role: message.role.into(),
+                    content,
+                    name: None,
+                    tool_calls: if tool_calls.is_empty() { None } else { Some(tool_calls) },
+                    tool_call_id: None,
+                };
+                result.push(main_message);
+
+                // Add tool result messages
+                for (tool_use_id, result_text, _is_error) in tool_results {
+                    result.push(Message {
+                        role: Role::Tool,
+                        content: MessageContent::Text(result_text),
+                        name: None,
+                        tool_calls: None,
+                        tool_call_id: Some(tool_use_id),
+                    });
+                }
+            }
+        }
+
+        Ok(result)
+    }
+}
+
+impl TryFrom<Message> for MessagesMessage {
+    type Error = TransformError;
+
+    fn try_from(message: Message) -> Result<Self, Self::Error> {
+        let role = match message.role {
+            Role::User => MessagesRole::User,
+            Role::Assistant => MessagesRole::Assistant,
+            Role::Tool => {
+                // Tool messages become user messages with tool results
+                let tool_call_id = message.tool_call_id
+                    .ok_or_else(|| TransformError::MissingField("tool_call_id required for Tool messages".to_string()))?;
+
+                return Ok(MessagesMessage {
+                    role: MessagesRole::User,
+                    content: MessagesMessageContent::Blocks(vec![
+                        MessagesContentBlock::ToolResult {
+                            tool_use_id: tool_call_id,
+                            is_error: None,
+                            content: vec![MessagesContentBlock::Text {
+                                text: message.content.extract_text(),
+                            }],
+                        },
+                    ]),
+                });
+            }
+            Role::System => {
+                return Err(TransformError::UnsupportedConversion("System messages should be handled separately".to_string()));
+            }
+        };
+
+        let content_blocks = convert_openai_message_to_anthropic_content(&message)?;
+        let content = build_anthropic_content(content_blocks);
+
+        Ok(MessagesMessage { role, content })
+    }
+}
+
+// Role Conversions
+impl Into<Role> for MessagesRole {
+    fn into(self) -> Role {
+        match self {
+            MessagesRole::User => Role::User,
+            MessagesRole::Assistant => Role::Assistant,
+        }
+    }
+}
+
+// Content Extraction
+impl ExtractText for MessageContent {
+    fn extract_text(&self) -> String {
+        match self {
+            MessageContent::Text(text) => text.clone(),
+            MessageContent::Parts(parts) => parts.extract_text()
+        }
+    }
+}
+
+impl ExtractText for Vec<ContentPart> {
+    fn extract_text(&self) -> String {
+        self.iter()
+            .filter_map(|part| match part {
+                ContentPart::Text { text } => Some(text.as_str()),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
+
+impl ExtractText for Vec<MessagesContentBlock> {
+    fn extract_text(&self) -> String {
+        self.iter()
+            .filter_map(|block| match block {
+                MessagesContentBlock::Text { text } => Some(text.as_str()),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
+
+// Content Utilities
+impl ContentUtils<ToolCall> for Vec<MessagesContentBlock> {
+    fn extract_tool_calls(&self) -> Result<Option<Vec<ToolCall>>, TransformError> {
+        let mut tool_calls = Vec::new();
+
+        for block in self {
+            match block {
+                MessagesContentBlock::ToolUse { id, name, input } |
+                MessagesContentBlock::ServerToolUse { id, name, input } |
+                MessagesContentBlock::McpToolUse { id, name, input } => {
+                    let arguments = serde_json::to_string(&input)?;
+                    tool_calls.push(ToolCall {
+                        id: id.clone(),
+                        call_type: "function".to_string(),
+                        function: FunctionCall { name: name.clone(), arguments },
+                    });
+                }
+                _ => continue,
+            }
+        }
+
+        Ok(if tool_calls.is_empty() { None } else { Some(tool_calls) })
+    }
+
+    fn split_for_openai(&self) -> Result<(Vec<ContentPart>, Vec<ToolCall>, Vec<(String, String, bool)>), TransformError> {
+        let mut content_parts = Vec::new();
+        let mut tool_calls = Vec::new();
+        let mut tool_results = Vec::new();
+
+        for block in self {
+            match block {
+                MessagesContentBlock::Text { text } => {
+                    content_parts.push(ContentPart::Text { text: text.clone() });
+                }
+                MessagesContentBlock::Image { source } => {
+                    let url = convert_image_source_to_url(source);
+                    content_parts.push(ContentPart::ImageUrl {
+                        image_url: ImageUrl {
+                            url,
+                            detail: Some("auto".to_string()),
+                        },
+                    });
+                }
+                MessagesContentBlock::ToolUse { id, name, input } |
+                MessagesContentBlock::ServerToolUse { id, name, input } |
+                MessagesContentBlock::McpToolUse { id, name, input } => {
+                    let arguments = serde_json::to_string(&input)?;
+                    tool_calls.push(ToolCall {
+                        id: id.clone(),
+                        call_type: "function".to_string(),
+                        function: FunctionCall { name: name.clone(), arguments },
+                    });
+                }
+                MessagesContentBlock::ToolResult { tool_use_id, content, is_error } |
+                MessagesContentBlock::WebSearchToolResult { tool_use_id, content, is_error } |
+                MessagesContentBlock::CodeExecutionToolResult { tool_use_id, content, is_error } |
+                MessagesContentBlock::McpToolResult { tool_use_id, content, is_error } => {
+                    let result_text = content.extract_text();
+                    tool_results.push((tool_use_id.clone(), result_text, is_error.unwrap_or(false)));
+                }
+                _ => {
+                    // Skip unsupported content types
+                    continue;
+                }
+            }
+        }
+
+        Ok((content_parts, tool_calls, tool_results))
+    }
+}
+
+// Stop Reason Conversions
+impl Into<FinishReason> for MessagesStopReason {
+    fn into(self) -> FinishReason {
+        match self {
+            MessagesStopReason::EndTurn => FinishReason::Stop,
+            MessagesStopReason::MaxTokens => FinishReason::Length,
+            MessagesStopReason::StopSequence => FinishReason::Stop,
+            MessagesStopReason::ToolUse => FinishReason::ToolCalls,
+            MessagesStopReason::PauseTurn => FinishReason::Stop,
+            MessagesStopReason::Refusal => FinishReason::ContentFilter,
+        }
+    }
+}
+
+impl Into<MessagesStopReason> for FinishReason {
+    fn into(self) -> MessagesStopReason {
+        match self {
+            FinishReason::Stop => MessagesStopReason::EndTurn,
+            FinishReason::Length => MessagesStopReason::MaxTokens,
+            FinishReason::ToolCalls => MessagesStopReason::ToolUse,
+            FinishReason::ContentFilter => MessagesStopReason::Refusal,
+            FinishReason::FunctionCall => MessagesStopReason::ToolUse,
+        }
+    }
+}
+
+// Usage Conversions
+impl Into<Usage> for MessagesUsage {
+    fn into(self) -> Usage {
+        Usage {
+            prompt_tokens: self.input_tokens,
+            completion_tokens: self.output_tokens,
+            total_tokens: self.input_tokens + self.output_tokens,
+            prompt_tokens_details: None,
+            completion_tokens_details: None,
+        }
+    }
+}
+
+impl Into<MessagesUsage> for Usage {
+    fn into(self) -> MessagesUsage {
+        MessagesUsage {
+            input_tokens: self.prompt_tokens,
+            output_tokens: self.completion_tokens,
+            cache_creation_input_tokens: None,
+            cache_read_input_tokens: None,
+        }
+    }
+}
+
+// ============================================================================
+// HELPER FUNCTIONS - Organized by domain
+// ============================================================================
+
+/// Helper to create a current unix timestamp
+fn current_timestamp() -> u64 {
+    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
+}
+
+/// Helper to create OpenAI streaming chunk
+fn create_openai_chunk(
+    id: &str,
+    model: &str,
+    delta: MessageDelta,
+    finish_reason: Option<FinishReason>,
+    usage: Option<Usage>
+) -> ChatCompletionsStreamResponse {
+    ChatCompletionsStreamResponse {
+        id: id.to_string(),
+        object: "chat.completion.chunk".to_string(),
+        created: current_timestamp(),
+        model: model.to_string(),
+        choices: vec![StreamChoice {
+            index: 0,
+            delta,
+            finish_reason,
+            logprobs: None,
+        }],
+        usage,
+        system_fingerprint: None,
+        service_tier: None,
+    }
+}
+
+/// Helper to create empty OpenAI streaming chunk
+fn create_empty_openai_chunk() -> ChatCompletionsStreamResponse {
+    create_openai_chunk(
+        "stream",
+        "unknown",
+        MessageDelta {
+            role: None,
+            content: None,
+            refusal: None,
+            function_call: None,
+            tool_calls: None,
+        },
+        None,
+        None,
+    )
+}
+
+/// Convert Anthropic tools to OpenAI format
+fn convert_anthropic_tools(tools: Vec<MessagesTool>) -> Vec<Tool> {
+    tools.into_iter()
+        .map(|tool| Tool {
+            tool_type: "function".to_string(),
+            function: Function {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema,
+                strict: None,
+            },
+        })
+        .collect()
+}
+
+/// Convert OpenAI tools to Anthropic format
+fn convert_openai_tools(tools: Vec<Tool>) -> Vec<MessagesTool> {
+    tools.into_iter()
+        .map(|tool| MessagesTool {
+            name: tool.function.name,
+            description: tool.function.description,
+            input_schema: tool.function.parameters,
+        })
+        .collect()
+}
+
+/// Convert Anthropic tool choice to OpenAI format
+fn convert_anthropic_tool_choice(tool_choice: Option<MessagesToolChoice>) -> (Option<ToolChoice>, Option<bool>) {
+    match tool_choice {
+        Some(choice) => {
+            let openai_choice = match choice.kind {
+                MessagesToolChoiceType::Auto => ToolChoice::Type(ToolChoiceType::Auto),
+                MessagesToolChoiceType::Any => ToolChoice::Type(ToolChoiceType::Required),
+                MessagesToolChoiceType::None => ToolChoice::Type(ToolChoiceType::None),
+                MessagesToolChoiceType::Tool => {
+                    if let Some(name) = choice.name {
+                        ToolChoice::Function {
+                            choice_type: "function".to_string(),
+                            function: FunctionChoice { name },
+                        }
+                    } else {
+                        ToolChoice::Type(ToolChoiceType::Auto)
+                    }
+                }
+            };
+            let parallel = choice.disable_parallel_tool_use.map(|disable| !disable);
+            (Some(openai_choice), parallel)
+        }
+        None => (None, None)
+    }
+}
+
+/// Convert OpenAI tool choice to Anthropic format
+fn convert_openai_tool_choice(
+    tool_choice: Option<ToolChoice>,
+    parallel_tool_calls: Option<bool>
+) -> Option<MessagesToolChoice> {
+    tool_choice.map(|choice| {
+        match choice {
+            ToolChoice::Type(tool_type) => match tool_type {
+                ToolChoiceType::Auto => MessagesToolChoice {
+                    kind: MessagesToolChoiceType::Auto,
+                    name: None,
+                    disable_parallel_tool_use: parallel_tool_calls.map(|p| !p),
+                },
+                ToolChoiceType::Required => MessagesToolChoice {
+                    kind: MessagesToolChoiceType::Any,
+                    name: None,
+                    disable_parallel_tool_use: parallel_tool_calls.map(|p| !p),
+                },
+                ToolChoiceType::None => MessagesToolChoice {
+                    kind: MessagesToolChoiceType::None,
+                    name: None,
+                    disable_parallel_tool_use: None,
+                },
+            },
+            ToolChoice::Function { function, .. } => MessagesToolChoice {
+                kind: MessagesToolChoiceType::Tool,
+                name: Some(function.name),
+                disable_parallel_tool_use: parallel_tool_calls.map(|p| !p),
+            },
+        }
+    })
+}
+
+/// Build OpenAI message content from parts and tool calls
+fn build_openai_content(content_parts: Vec<ContentPart>, tool_calls: &[ToolCall]) -> MessageContent {
+    if content_parts.len() == 1 && tool_calls.is_empty() {
+        match &content_parts[0] {
+            ContentPart::Text { text } => MessageContent::Text(text.clone()),
+            _ => MessageContent::Parts(content_parts),
+        }
+    } else if content_parts.is_empty() {
+        MessageContent::Text("".to_string())
+    } else {
+        MessageContent::Parts(content_parts)
+    }
+}
+
+/// Build Anthropic message content from content blocks
+fn build_anthropic_content(content_blocks: Vec<MessagesContentBlock>) -> MessagesMessageContent {
+    if content_blocks.len() == 1 {
+        match &content_blocks[0] {
+            MessagesContentBlock::Text { text } => MessagesMessageContent::Single(text.clone()),
+            _ => MessagesMessageContent::Blocks(content_blocks),
+        }
+    } else if content_blocks.is_empty() {
+        MessagesMessageContent::Single("".to_string())
+    } else {
+        MessagesMessageContent::Blocks(content_blocks)
+    }
+}
+
+/// Convert Anthropic content blocks to OpenAI message content
+fn convert_anthropic_content_to_openai(content: &[MessagesContentBlock]) -> Result<MessageContent, TransformError> {
+    let mut text_parts = Vec::new();
+
+    for block in content {
+        match block {
+            MessagesContentBlock::Text { text } => {
+                text_parts.push(text.clone());
+            }
+            MessagesContentBlock::Thinking { text } => {
+                // Include thinking as regular text for OpenAI
+                text_parts.push(format!("[Thinking: {}]", text));
+            }
+            _ => {
+                // Skip other content types for basic text conversion
+                continue;
+            }
+        }
+    }
+
+    Ok(MessageContent::Text(text_parts.join("\n")))
+}
+
+/// Convert OpenAI message to Anthropic content blocks
+fn convert_openai_message_to_anthropic_content(message: &Message) -> Result<Vec<MessagesContentBlock>, TransformError> {
+    let mut blocks = Vec::new();
+
+    // Handle regular content
+    match &message.content {
+        MessageContent::Text(text) => {
+            if !text.is_empty() {
+                blocks.push(MessagesContentBlock::Text { text: text.clone() });
+            }
+        }
+        MessageContent::Parts(parts) => {
+            for part in parts {
+                match part {
+                    ContentPart::Text { text } => {
+                        blocks.push(MessagesContentBlock::Text { text: text.clone() });
+                    }
+                    ContentPart::ImageUrl { image_url } => {
+                        let source = convert_image_url_to_source(image_url);
+                        blocks.push(MessagesContentBlock::Image { source });
+                    }
+                }
+            }
+        }
+    }
+
+    // Handle tool calls
+    if let Some(tool_calls) = &message.tool_calls {
+        for tool_call in tool_calls {
+            let input: Value = serde_json::from_str(&tool_call.function.arguments)?;
+            blocks.push(MessagesContentBlock::ToolUse {
+                id: tool_call.id.clone(),
+                name: tool_call.function.name.clone(),
+                input,
+            });
+        }
+    }
+
+    Ok(blocks)
+}
+
+/// Convert image source to URL
+fn convert_image_source_to_url(source: &MessagesImageSource) -> String {
+    match source {
+        MessagesImageSource::Base64 { media_type, data } => {
+            format!("data:{};base64,{}", media_type, data)
+        }
+        MessagesImageSource::Url { url } => url.clone(),
+    }
+}
+
+/// Convert image URL to Anthropic image source
+fn convert_image_url_to_source(image_url: &ImageUrl) -> MessagesImageSource {
+    if image_url.url.starts_with("data:") {
+        // Parse data URL
+        let parts: Vec<&str> = image_url.url.splitn(2, ',').collect();
+        if parts.len() == 2 {
+            let header = parts[0];
+            let data = parts[1];
+            let media_type = header
+                .strip_prefix("data:")
+                .and_then(|s| s.split(';').next())
+                .unwrap_or("image/jpeg")
+                .to_string();
+
+            MessagesImageSource::Base64 {
+                media_type,
+                data: data.to_string(),
+            }
+        } else {
+            MessagesImageSource::Url { url: image_url.url.clone() }
+        }
+    } else {
+        MessagesImageSource::Url { url: image_url.url.clone() }
+    }
+}
+
+/// Convert content block start to OpenAI chunk
+fn convert_content_block_start(content_block: MessagesContentBlock) -> Result<ChatCompletionsStreamResponse, TransformError> {
+    match content_block {
+        MessagesContentBlock::Text { .. } => {
+            // No immediate output for text block start
+            Ok(create_empty_openai_chunk())
+        }
+        MessagesContentBlock::ToolUse { id, name, .. } |
+        MessagesContentBlock::ServerToolUse { id, name, .. } |
+        MessagesContentBlock::McpToolUse { id, name, .. } => {
+            // Tool use start → OpenAI chunk with tool_calls
+            Ok(create_openai_chunk(
+                "stream",
+                "unknown",
+                MessageDelta {
+                    role: None,
+                    content: None,
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: Some(vec![ToolCallDelta {
+                        index: 0,
+                        id: Some(id),
+                        call_type: Some("function".to_string()),
+                        function: Some(FunctionCallDelta {
+                            name: Some(name),
+                            arguments: Some("".to_string()),
+                        }),
+                    }]),
+                },
+                None,
+                None,
+            ))
+        }
+        _ => Err(TransformError::UnsupportedContent("Unsupported content block type in stream start".to_string())),
+    }
+}
+
+/// Convert content delta to OpenAI chunk
+fn convert_content_delta(delta: MessagesContentDelta) -> Result<ChatCompletionsStreamResponse, TransformError> {
+    match delta {
+        MessagesContentDelta::TextDelta { text } => {
+            Ok(create_openai_chunk(
+                "stream",
+                "unknown",
+                MessageDelta {
+                    role: None,
+                    content: Some(text),
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: None,
+                },
+                None,
+                None,
+            ))
+        }
+        MessagesContentDelta::InputJsonDelta { partial_json } => {
+            Ok(create_openai_chunk(
+                "stream",
+                "unknown",
+                MessageDelta {
+                    role: None,
+                    content: None,
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: Some(vec![ToolCallDelta {
+                        index: 0,
+                        id: None,
+                        call_type: None,
+                        function: Some(FunctionCallDelta {
+                            name: None,
+                            arguments: Some(partial_json),
+                        }),
+                    }]),
+                },
+                None,
+                None,
+            ))
+        }
+    }
+}
+
+/// Convert tool call deltas to Anthropic stream events
+fn convert_tool_call_deltas(tool_calls: Vec<ToolCallDelta>) -> Result<MessagesStreamEvent, TransformError> {
+    for tool_call in tool_calls {
+        if let Some(id) = &tool_call.id {
+            // Tool call start
+            if let Some(function) = &tool_call.function {
+                if let Some(name) = &function.name {
+                    return Ok(MessagesStreamEvent::ContentBlockStart {
+                        index: tool_call.index,
+                        content_block: MessagesContentBlock::ToolUse {
+                            id: id.clone(),
+                            name: name.clone(),
+                            input: Value::Object(serde_json::Map::new()),
+                        },
+                    });
+                }
+            }
+        } else if let Some(function) = &tool_call.function {
+            if let Some(arguments) = &function.arguments {
+                // Tool arguments delta
+                return Ok(MessagesStreamEvent::ContentBlockDelta {
+                    index: tool_call.index,
+                    delta: MessagesContentDelta::InputJsonDelta {
+                        partial_json: arguments.clone(),
+                    },
+                });
+            }
+        }
+    }
+
+    // Fallback to ping if no valid tool call found
+    Ok(MessagesStreamEvent::Ping)
+}
+
+// ============================================================================
+// TESTS
+// ============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_anthropic_to_openai_basic_request() {
+        let anthropic_req = AnthropicMessagesRequest {
+            model: "claude-3-sonnet-20240229".to_string(),
+            system: Some(MessagesSystemPrompt::Single("You are helpful".to_string())),
+            messages: vec![MessagesMessage {
+                role: MessagesRole::User,
+                content: MessagesMessageContent::Single("Hello, world!".to_string()),
+            }],
+            max_tokens: 1024,
+            container: None,
+            mcp_servers: None,
+            service_tier: None,
+            thinking: None,
+            temperature: Some(0.7),
+            top_p: Some(0.9),
+            top_k: Some(50),
+            stream: Some(false),
+            stop_sequences: Some(vec!["STOP".to_string()]),
+            tools: None,
+            tool_choice: None,
+            metadata: None,
+        };
+
+        let openai_req: ChatCompletionsRequest = anthropic_req.try_into().unwrap();
+
+        assert_eq!(openai_req.model, "claude-3-sonnet-20240229");
+        assert_eq!(openai_req.messages.len(), 2); // system + user message
+        assert_eq!(openai_req.max_tokens, Some(1024));
+        assert_eq!(openai_req.temperature, Some(0.7));
+        assert_eq!(openai_req.top_p, Some(0.9));
+        assert_eq!(openai_req.stream, Some(false));
+        assert_eq!(openai_req.stop, Some(vec!["STOP".to_string()]));
+    }
+
+    #[test]
+    fn test_roundtrip_consistency() {
+        // Test that converting back and forth maintains consistency
+        let original_anthropic = AnthropicMessagesRequest {
+            model: "claude-3-sonnet".to_string(),
+            system: Some(MessagesSystemPrompt::Single("System prompt".to_string())),
+            messages: vec![MessagesMessage {
+                role: MessagesRole::User,
+                content: MessagesMessageContent::Single("User message".to_string()),
+            }],
+            max_tokens: 1000,
+            container: None,
+            mcp_servers: None,
+            service_tier: None,
+            thinking: None,
+            temperature: Some(0.5),
+            top_p: Some(1.0),
+            top_k: None,
+            stream: Some(false),
+            stop_sequences: None,
+            tools: None,
+            tool_choice: None,
+            metadata: None,
+        };
+
+        // Convert to OpenAI and back
+        let openai_req: ChatCompletionsRequest = original_anthropic.clone().try_into().unwrap();
+        let roundtrip_anthropic: AnthropicMessagesRequest = openai_req.try_into().unwrap();
+
+        // Check key fields are preserved
+        assert_eq!(original_anthropic.model, roundtrip_anthropic.model);
+        assert_eq!(original_anthropic.max_tokens, roundtrip_anthropic.max_tokens);
+        assert_eq!(original_anthropic.temperature, roundtrip_anthropic.temperature);
+        assert_eq!(original_anthropic.top_p, roundtrip_anthropic.top_p);
+        assert_eq!(original_anthropic.stream, roundtrip_anthropic.stream);
+        assert_eq!(original_anthropic.messages.len(), roundtrip_anthropic.messages.len());
+    }
+
+    #[test]
+    fn test_tool_choice_auto() {
+        let anthropic_req = AnthropicMessagesRequest {
+            model: "claude-3".to_string(),
+            system: None,
+            messages: vec![],
+            max_tokens: 100,
+            container: None,
+            mcp_servers: None,
+            service_tier: None,
+            thinking: None,
+            temperature: None,
+            top_p: None,
+            top_k: None,
+            stream: None,
+            stop_sequences: None,
+            tools: Some(vec![MessagesTool {
+                name: "test_tool".to_string(),
+                description: Some("A test tool".to_string()),
+                input_schema: json!({"type": "object"}),
+            }]),
+            tool_choice: Some(MessagesToolChoice {
+                kind: MessagesToolChoiceType::Auto,
+                name: None,
+                disable_parallel_tool_use: Some(true),
+            }),
+            metadata: None,
+        };
+
+        let openai_req: ChatCompletionsRequest = anthropic_req.try_into().unwrap();
+
+        assert!(openai_req.tools.is_some());
+        assert_eq!(openai_req.tools.as_ref().unwrap().len(), 1);
+
+        if let Some(ToolChoice::Type(choice)) = openai_req.tool_choice {
+            assert_eq!(choice, ToolChoiceType::Auto);
+        } else {
+            panic!("Expected auto tool choice");
+        }
+
+        assert_eq!(openai_req.parallel_tool_calls, Some(false));
+    }
+
+    #[test]
+    fn test_default_max_tokens_used_when_openai_has_none() {
+        // Test that DEFAULT_MAX_TOKENS is used when OpenAI request has no max_tokens
+        let openai_req = ChatCompletionsRequest {
+            model: "gpt-4".to_string(),
+            messages: vec![Message {
+                role: Role::User,
+                content: MessageContent::Text("Hello".to_string()),
+                name: None,
+                tool_calls: None,
+                tool_call_id: None,
+            }],
+            max_tokens: None, // No max_tokens specified
+            ..Default::default()
+        };
+
+        let anthropic_req: AnthropicMessagesRequest = openai_req.try_into().unwrap();
+
+        assert_eq!(anthropic_req.max_tokens, DEFAULT_MAX_TOKENS);
+    }
+
+    #[test]
+    fn test_anthropic_message_start_streaming() {
+        let event = MessagesStreamEvent::MessageStart {
+            message: MessagesStreamMessage {
+                id: "msg_stream_123".to_string(),
+                obj_type: "message".to_string(),
+                role: MessagesRole::Assistant,
+                content: vec![],
+                model: "claude-3".to_string(),
+                stop_reason: None,
+                stop_sequence: None,
+                usage: MessagesUsage {
+                    input_tokens: 5,
+                    output_tokens: 0,
+                    cache_creation_input_tokens: None,
+                    cache_read_input_tokens: None,
+                },
+            },
+        };
+
+        let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+
+        assert_eq!(openai_resp.id, "msg_stream_123");
+        assert_eq!(openai_resp.object, "chat.completion.chunk");
+        assert_eq!(openai_resp.model, "claude-3");
+        assert_eq!(openai_resp.choices.len(), 1);
+
+        let choice = &openai_resp.choices[0];
+        assert_eq!(choice.index, 0);
+        assert_eq!(choice.delta.role, Some(Role::Assistant));
+        assert_eq!(choice.delta.content, None);
+        assert_eq!(choice.finish_reason, None);
+    }
+
+    #[test]
+    fn test_anthropic_content_block_delta_streaming() {
+        let event = MessagesStreamEvent::ContentBlockDelta {
+            index: 0,
+            delta: MessagesContentDelta::TextDelta {
+                text: "Hello, world!".to_string(),
+            },
+        };
+
+        let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+
+        assert_eq!(openai_resp.object, "chat.completion.chunk");
+        assert_eq!(openai_resp.choices.len(), 1);
+
+        let choice = &openai_resp.choices[0];
+        assert_eq!(choice.index, 0);
+        assert_eq!(choice.delta.content, Some("Hello, world!".to_string()));
+        assert_eq!(choice.delta.role, None);
+        assert_eq!(choice.finish_reason, None);
+    }
+
+    #[test]
+    fn test_anthropic_tool_use_streaming() {
+        // Test tool use start
+        let tool_start = MessagesStreamEvent::ContentBlockStart {
+            index: 0,
+            content_block: MessagesContentBlock::ToolUse {
+                id: "call_123".to_string(),
+                name: "get_weather".to_string(),
+                input: json!({}),
+            },
+        };
+
+        let openai_resp: ChatCompletionsStreamResponse = tool_start.try_into().unwrap();
+
+        assert_eq!(openai_resp.choices.len(), 1);
+        let choice = &openai_resp.choices[0];
+        assert!(choice.delta.tool_calls.is_some());
+
+        let tool_calls = choice.delta.tool_calls.as_ref().unwrap();
+        assert_eq!(tool_calls.len(), 1);
+        assert_eq!(tool_calls[0].id, Some("call_123".to_string()));
+        assert_eq!(tool_calls[0].function.as_ref().unwrap().name, Some("get_weather".to_string()));
+    }
+
+    #[test]
+    fn test_anthropic_tool_input_delta_streaming() {
+        let event = MessagesStreamEvent::ContentBlockDelta {
+            index: 0,
+            delta: MessagesContentDelta::InputJsonDelta {
+                partial_json: r#"{"location": "San Francisco"#.to_string(),
+            },
+        };
+
+        let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+
+        assert_eq!(openai_resp.choices.len(), 1);
+        let choice = &openai_resp.choices[0];
+        assert!(choice.delta.tool_calls.is_some());
+
+        let tool_calls = choice.delta.tool_calls.as_ref().unwrap();
+        assert_eq!(tool_calls.len(), 1);
+        assert_eq!(tool_calls[0].function.as_ref().unwrap().arguments, Some(r#"{"location": "San Francisco"#.to_string()));
+    }
+
+    #[test]
+    fn test_anthropic_message_delta_with_usage() {
+        let event = MessagesStreamEvent::MessageDelta {
+            delta: MessagesMessageDelta {
+                stop_reason: MessagesStopReason::EndTurn,
+                stop_sequence: None,
+            },
+            usage: MessagesUsage {
+                input_tokens: 10,
+                output_tokens: 25,
+                cache_creation_input_tokens: None,
+                cache_read_input_tokens: None,
+            },
+        };
+
+        let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+
+        assert_eq!(openai_resp.choices.len(), 1);
+        let choice = &openai_resp.choices[0];
+        assert_eq!(choice.finish_reason, Some(FinishReason::Stop));
+
+        assert!(openai_resp.usage.is_some());
+        let usage = openai_resp.usage.unwrap();
+        assert_eq!(usage.prompt_tokens, 10);
+        assert_eq!(usage.completion_tokens, 25);
+        assert_eq!(usage.total_tokens, 35);
+    }
+
+    #[test]
+    fn test_anthropic_message_stop_streaming() {
+        let event = MessagesStreamEvent::MessageStop;
+
+        let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+
+        assert_eq!(openai_resp.choices.len(), 1);
+        let choice = &openai_resp.choices[0];
+        assert_eq!(choice.finish_reason, Some(FinishReason::Stop));
+    }
+
+    #[test]
+    fn test_anthropic_ping_streaming() {
+        let event = MessagesStreamEvent::Ping;
+
+        let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+
+        assert_eq!(openai_resp.object, "chat.completion.chunk");
+        assert_eq!(openai_resp.choices.len(), 0); // Ping has no choices
+    }
+
+    #[test]
+    fn test_openai_to_anthropic_streaming_role_start() {
+        let openai_resp = ChatCompletionsStreamResponse {
+            id: "chatcmpl-123".to_string(),
+            object: "chat.completion.chunk".to_string(),
+            created: 1234567890,
+            model: "gpt-4".to_string(),
+            choices: vec![StreamChoice {
+                index: 0,
+                delta: MessageDelta {
+                    role: Some(Role::Assistant),
+                    content: None,
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: None,
+                },
+                finish_reason: None,
+                logprobs: None,
+            }],
+            usage: None,
+            system_fingerprint: None,
+            service_tier: None,
+        };
+
+        let anthropic_event: MessagesStreamEvent = openai_resp.try_into().unwrap();
+
+        match anthropic_event {
+            MessagesStreamEvent::MessageStart { message } => {
+                assert_eq!(message.id, "chatcmpl-123");
+                assert_eq!(message.role, MessagesRole::Assistant);
+                assert_eq!(message.model, "gpt-4");
+            }
+            _ => panic!("Expected MessageStart event"),
+        }
+    }
+
+    #[test]
+    fn test_openai_to_anthropic_streaming_content_delta() {
+        let openai_resp = ChatCompletionsStreamResponse {
+            id: "chatcmpl-123".to_string(),
+            object: "chat.completion.chunk".to_string(),
+            created: 1234567890,
+            model: "gpt-4".to_string(),
+            choices: vec![StreamChoice {
+                index: 0,
+                delta: MessageDelta {
+                    role: None,
+                    content: Some("Hello there!".to_string()),
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: None,
+                },
+                finish_reason: None,
+                logprobs: None,
+            }],
+            usage: None,
+            system_fingerprint: None,
+            service_tier: None,
+        };
+
+        let anthropic_event: MessagesStreamEvent = openai_resp.try_into().unwrap();
+
+        match anthropic_event {
+            MessagesStreamEvent::ContentBlockDelta { index, delta } => {
+                assert_eq!(index, 0);
+                match delta {
+                    MessagesContentDelta::TextDelta { text } => {
+                        assert_eq!(text, "Hello there!");
+                    }
+                    _ => panic!("Expected TextDelta"),
+                }
+            }
+            _ => panic!("Expected ContentBlockDelta event"),
+        }
+    }
+
+    #[test]
+    fn test_openai_to_anthropic_streaming_tool_calls() {
+        let openai_resp = ChatCompletionsStreamResponse {
+            id: "chatcmpl-123".to_string(),
+            object: "chat.completion.chunk".to_string(),
+            created: 1234567890,
+            model: "gpt-4".to_string(),
+            choices: vec![StreamChoice {
+                index: 0,
+                delta: MessageDelta {
+                    role: None,
+                    content: None,
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: Some(vec![ToolCallDelta {
+                        index: 0,
+                        id: Some("call_abc123".to_string()),
+                        call_type: Some("function".to_string()),
+                        function: Some(FunctionCallDelta {
+                            name: Some("get_current_weather".to_string()),
+                            arguments: Some("".to_string()),
+                        }),
+                    }]),
+                },
+                finish_reason: None,
+                logprobs: None,
+            }],
+            usage: None,
+            system_fingerprint: None,
+            service_tier: None,
+        };
+
+        let anthropic_event: MessagesStreamEvent = openai_resp.try_into().unwrap();
+
+        match anthropic_event {
+            MessagesStreamEvent::ContentBlockStart { index, content_block } => {
+                assert_eq!(index, 0);
+                match content_block {
+                    MessagesContentBlock::ToolUse { id, name, .. } => {
+                        assert_eq!(id, "call_abc123");
+                        assert_eq!(name, "get_current_weather");
+                    }
+                    _ => panic!("Expected ToolUse content block"),
+                }
+            }
+            _ => panic!("Expected ContentBlockStart event"),
+        }
+    }
+
+    #[test]
+    fn test_openai_to_anthropic_streaming_final_usage() {
+        let openai_resp = ChatCompletionsStreamResponse {
+            id: "chatcmpl-123".to_string(),
+            object: "chat.completion.chunk".to_string(),
+            created: 1234567890,
+            model: "gpt-4".to_string(),
+            choices: vec![StreamChoice {
+                index: 0,
+                delta: MessageDelta {
+                    role: None,
+                    content: None,
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: None,
+                },
+                finish_reason: Some(FinishReason::Stop),
+                logprobs: None,
+            }],
+            usage: Some(Usage {
+                prompt_tokens: 15,
+                completion_tokens: 30,
+                total_tokens: 45,
+                prompt_tokens_details: None,
+                completion_tokens_details: None,
+            }),
+            system_fingerprint: None,
+            service_tier: None,
+        };
+
+        let anthropic_event: MessagesStreamEvent = openai_resp.try_into().unwrap();
+
+        match anthropic_event {
+            MessagesStreamEvent::MessageDelta { delta, usage } => {
+                assert_eq!(delta.stop_reason, MessagesStopReason::EndTurn);
+                assert_eq!(usage.input_tokens, 15);
+                assert_eq!(usage.output_tokens, 30);
+            }
+            _ => panic!("Expected MessageDelta event"),
+        }
+    }
+
+    #[test]
+    fn test_openai_empty_choices_to_anthropic_ping() {
+        let openai_resp = ChatCompletionsStreamResponse {
+            id: "chatcmpl-123".to_string(),
+            object: "chat.completion.chunk".to_string(),
+            created: 1234567890,
+            model: "gpt-4".to_string(),
+            choices: vec![], // Empty choices
+            usage: None,
+            system_fingerprint: None,
+            service_tier: None,
+        };
+
+        let anthropic_event: MessagesStreamEvent = openai_resp.try_into().unwrap();
+
+        match anthropic_event {
+            MessagesStreamEvent::Ping => {
+                // Expected behavior
+            }
+            _ => panic!("Expected Ping event for empty choices"),
+        }
+    }
+
+    #[test]
+    fn test_streaming_roundtrip_consistency() {
+        // Test that streaming events can roundtrip through conversions
+        let original_event = MessagesStreamEvent::ContentBlockDelta {
+            index: 0,
+            delta: MessagesContentDelta::TextDelta {
+                text: "Test message".to_string(),
+            },
+        };
+
+        // Convert to OpenAI and back
+        let openai_resp: ChatCompletionsStreamResponse = original_event.try_into().unwrap();
+        let roundtrip_event: MessagesStreamEvent = openai_resp.try_into().unwrap();
+
+        // Verify the roundtrip maintains the essential information
+        match roundtrip_event {
+            MessagesStreamEvent::ContentBlockDelta { index, delta } => {
+                assert_eq!(index, 0);
+                match delta {
+                    MessagesContentDelta::TextDelta { text } => {
+                        assert_eq!(text, "Test message");
+                    }
+                    _ => panic!("Expected TextDelta after roundtrip"),
+                }
+            }
+            _ => panic!("Expected ContentBlockDelta after roundtrip"),
+        }
+    }
+
+    #[test]
+    fn test_streaming_tool_argument_accumulation() {
+        // Test multiple tool argument deltas that should accumulate
+        let tool_start = MessagesStreamEvent::ContentBlockStart {
+            index: 0,
+            content_block: MessagesContentBlock::ToolUse {
+                id: "call_weather".to_string(),
+                name: "get_weather".to_string(),
+                input: json!({}),
+            },
+        };
+
+        let arg_delta1 = MessagesStreamEvent::ContentBlockDelta {
+            index: 0,
+            delta: MessagesContentDelta::InputJsonDelta {
+                partial_json: r#"{"location": "#.to_string(),
+            },
+        };
+
+        let arg_delta2 = MessagesStreamEvent::ContentBlockDelta {
+            index: 0,
+            delta: MessagesContentDelta::InputJsonDelta {
+                partial_json: r#"San Francisco", "unit": "fahrenheit"}"#.to_string(),
+            },
+        };
+
+        // Test that each delta converts properly to OpenAI format
+        let openai_start: ChatCompletionsStreamResponse = tool_start.try_into().unwrap();
+        let openai_delta1: ChatCompletionsStreamResponse = arg_delta1.try_into().unwrap();
+        let openai_delta2: ChatCompletionsStreamResponse = arg_delta2.try_into().unwrap();
+
+        // Verify tool start
+        let tool_calls = &openai_start.choices[0].delta.tool_calls.as_ref().unwrap();
+        assert_eq!(tool_calls[0].id, Some("call_weather".to_string()));
+        assert_eq!(tool_calls[0].function.as_ref().unwrap().name, Some("get_weather".to_string()));
+
+        // Verify argument deltas
+        let args1 = &openai_delta1.choices[0].delta.tool_calls.as_ref().unwrap()[0]
+            .function.as_ref().unwrap().arguments;
+        assert_eq!(args1, &Some(r#"{"location": "#.to_string()));
+
+        let args2 = &openai_delta2.choices[0].delta.tool_calls.as_ref().unwrap()[0]
+            .function.as_ref().unwrap().arguments;
+        assert_eq!(args2, &Some(r#"San Francisco", "unit": "fahrenheit"}"#.to_string()));
+    }
+
+    #[test]
+    fn test_streaming_multiple_finish_reasons() {
+        // Test different finish reasons in streaming
+        let test_cases = vec![
+            (MessagesStopReason::EndTurn, FinishReason::Stop),
+            (MessagesStopReason::MaxTokens, FinishReason::Length),
+            (MessagesStopReason::ToolUse, FinishReason::ToolCalls),
+            (MessagesStopReason::StopSequence, FinishReason::Stop),
+        ];
+
+        for (anthropic_reason, expected_openai_reason) in test_cases {
+            let event = MessagesStreamEvent::MessageDelta {
+                delta: MessagesMessageDelta {
+                    stop_reason: anthropic_reason.clone(),
+                    stop_sequence: None,
+                },
+                usage: MessagesUsage {
+                    input_tokens: 10,
+                    output_tokens: 20,
+                    cache_creation_input_tokens: None,
+                    cache_read_input_tokens: None,
+                },
+            };
+
+            let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+            assert_eq!(openai_resp.choices[0].finish_reason, Some(expected_openai_reason));
+
+            // Test reverse conversion
+            let roundtrip_event: MessagesStreamEvent = openai_resp.try_into().unwrap();
+            match roundtrip_event {
+                MessagesStreamEvent::MessageDelta { delta, .. } => {
+                    // Note: Some precision may be lost in roundtrip due to mapping differences
+                    assert!(matches!(delta.stop_reason, MessagesStopReason::EndTurn | MessagesStopReason::MaxTokens | MessagesStopReason::ToolUse | MessagesStopReason::StopSequence));
+                }
+                _ => panic!("Expected MessageDelta after roundtrip"),
+            }
+        }
+    }
+
+    #[test]
+    fn test_streaming_error_handling() {
+        // Test that malformed streaming events are handled gracefully
+        let openai_resp_with_missing_data = ChatCompletionsStreamResponse {
+            id: "test".to_string(),
+            object: "chat.completion.chunk".to_string(),
+            created: 1234567890,
+            model: "test".to_string(),
+            choices: vec![StreamChoice {
+                index: 0,
+                delta: MessageDelta {
+                    role: None,
+                    content: None,
+                    refusal: None,
+                    function_call: None,
+                    tool_calls: None,
+                },
+                finish_reason: None,
+                logprobs: None,
+            }],
+            usage: None,
+            system_fingerprint: None,
+            service_tier: None,
+        };
+
+        // Should convert to Ping when no meaningful content
+        let anthropic_event: MessagesStreamEvent = openai_resp_with_missing_data.try_into().unwrap();
+        assert!(matches!(anthropic_event, MessagesStreamEvent::Ping));
+    }
+
+    #[test]
+    fn test_streaming_content_block_stop() {
+        let event = MessagesStreamEvent::ContentBlockStop { index: 0 };
+
+        let openai_resp: ChatCompletionsStreamResponse = event.try_into().unwrap();
+
+        // ContentBlockStop should produce an empty chunk
+        assert_eq!(openai_resp.object, "chat.completion.chunk");
+        assert_eq!(openai_resp.choices.len(), 1);
+
+        let choice = &openai_resp.choices[0];
+        assert_eq!(choice.delta.role, None);
+        assert_eq!(choice.delta.content, None);
+        assert_eq!(choice.delta.tool_calls, None);
+        assert_eq!(choice.finish_reason, None);
+    }
+}
diff --git a/crates/hermesllm/src/lib.rs b/crates/hermesllm/src/lib.rs
index 002d8159..169467a1 100644
--- a/crates/hermesllm/src/lib.rs
+++ b/crates/hermesllm/src/lib.rs
@@ -1,10 +1,12 @@
 //! hermesllm: A library for translating LLM API requests and responses
 //! between Mistral, Grok, Gemini, and OpenAI-compliant formats.
 
-use std::fmt::Display;
-
 pub mod providers;
+pub mod apis;
+pub mod clients;
 
+
+use std::fmt::Display;
 pub enum Provider {
     Arch,
     Mistral,
diff --git a/crates/hermesllm/src/mod.rs b/crates/hermesllm/src/mod.rs
new file mode 100644
index 00000000..87090835
--- /dev/null
+++ b/crates/hermesllm/src/mod.rs
@@ -0,0 +1,2 @@
+pub mod providers;
+pub mod clients;