@mmmbuto/anthmorph 0.1.0

package/src/main.rs

@@ -0,0 +1,120 @@
+mod config;
+mod error;
+mod models;
+mod proxy;
+mod transform;
+
+use axum::{routing::post, Extension, Router};
+use clap::Parser;
+use config::BackendProfile;
+use proxy::{build_cors_layer, Config};
+use reqwest::Client;
+use std::sync::Arc;
+use tower_http::trace::TraceLayer;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+#[derive(Parser, Debug)]
+#[command(name = "anthmorph")]
+#[command(about = "Anthropic to OpenAI-compatible proxy")]
+struct Cli {
+    #[arg(long, default_value = "3000")]
+    port: Option<u16>,
+    #[arg(long)]
+    backend_url: Option<String>,
+    #[arg(long)]
+    model: Option<String>,
+    #[arg(long)]
+    reasoning_model: Option<String>,
+    #[arg(long)]
+    api_key: Option<String>,
+    #[arg(long, value_enum)]
+    backend_profile: Option<BackendProfile>,
+    #[arg(long)]
+    ingress_api_key: Option<String>,
+    #[arg(long)]
+    allow_origin: Vec<String>,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let cli = Cli::parse();
+
+    let mut config = Config::from_env();
+
+    if let Some(port) = cli.port {
+        config.port = port;
+    }
+    if let Some(url) = cli.backend_url {
+        config.backend_url = url;
+    }
+    if let Some(m) = cli.model {
+        config.model = m;
+    }
+    if let Some(m) = cli.reasoning_model {
+        config.reasoning_model = Some(m);
+    }
+    if let Some(k) = cli.api_key {
+        config.api_key = Some(k);
+    }
+    if let Some(profile) = cli.backend_profile {
+        config.backend_profile = profile;
+    }
+    if let Some(k) = cli.ingress_api_key {
+        config.ingress_api_key = Some(k);
+    }
+    if !cli.allow_origin.is_empty() {
+        config.allow_origins = cli.allow_origin;
+    }
+
+    tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "anthmorph=debug".into()),
+        )
+        .with(tracing_subscriber::fmt::layer())
+        .init();
+
+    tracing::info!("AnthMorph v{}", env!("CARGO_PKG_VERSION"));
+    tracing::info!("Backend URL: {}", config.backend_url);
+    tracing::info!("Backend Profile: {}", config.backend_profile.as_str());
+    tracing::info!("Model: {}", config.model);
+    if let Some(ref m) = config.reasoning_model {
+        tracing::info!("Reasoning Model: {}", m);
+    }
+    tracing::info!("Port: {}", config.port);
+
+    let client = Client::builder()
+        .timeout(std::time::Duration::from_secs(300))
+        .connect_timeout(std::time::Duration::from_secs(10))
+        .pool_max_idle_per_host(10)
+        .build()?;
+
+    let config = Arc::new(config);
+
+    let app = Router::new()
+        .route("/v1/messages", post(proxy::proxy_handler))
+        .route("/health", axum::routing::get(health_handler))
+        .layer(Extension(config.clone()))
+        .layer(Extension(client))
+        .layer(TraceLayer::new_for_http());
+
+    let app = if let Some(cors) = build_cors_layer(&config)? {
+        app.layer(cors)
+    } else {
+        app
+    };
+
+    let addr = format!("0.0.0.0:{}", config.port);
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+
+    tracing::info!("Listening on {}", addr);
+    tracing::info!("Proxy ready");
+
+    axum::serve(listener, app).await?;
+
+    Ok(())
+}
+
+async fn health_handler() -> &'static str {
+    "OK"
+}

package/src/models/anthropic.rs

@@ -0,0 +1,274 @@
+use serde::{Deserialize, Serialize};
+
+// ============================================================================
+// Anthropic Request
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct AnthropicRequest {
+    pub model: String,
+    pub messages: Vec<Message>,
+    #[serde(default)]
+    pub system: Option<SystemPrompt>,
+    #[serde(default)]
+    pub stream: Option<bool>,
+    #[serde(default)]
+    pub max_tokens: usize,
+    #[serde(default)]
+    pub temperature: Option<f32>,
+    #[serde(default)]
+    pub top_p: Option<f32>,
+    #[serde(default)]
+    pub top_k: Option<i32>,
+    #[serde(default)]
+    pub tools: Option<Vec<Tool>>,
+    #[serde(default)]
+    pub stop_sequences: Option<Vec<String>>,
+    #[serde(flatten)]
+    pub extra: serde_json::Map<String, serde_json::Value>,
+}
+
+#[derive(Debug, Clone)]
+pub enum SystemPrompt {
+    Single(String),
+    Multiple(Vec<SystemMessage>),
+}
+
+impl<'de> Deserialize<'de> for SystemPrompt {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = serde_json::Value::deserialize(deserializer)?;
+        match value {
+            serde_json::Value::String(s) => Ok(SystemPrompt::Single(s)),
+            serde_json::Value::Array(arr) => {
+                let messages: Vec<SystemMessage> =
+                    serde_json::from_value(serde_json::Value::Array(arr))
+                        .map_err(|e| serde::de::Error::custom(e))?;
+                Ok(SystemPrompt::Multiple(messages))
+            }
+            serde_json::Value::Object(obj) => {
+                // Check if it's the "Single" or "Multiple" tagged format
+                if let Some(text) = obj.get("Single").and_then(|v| v.as_str()) {
+                    Ok(SystemPrompt::Single(text.to_string()))
+                } else if let Some(arr) = obj.get("Multiple").and_then(|v| v.as_array()) {
+                    let messages: Vec<SystemMessage> =
+                        serde_json::from_value(serde_json::Value::Array(arr.clone()))
+                            .map_err(|e| serde::de::Error::custom(e))?;
+                    Ok(SystemPrompt::Multiple(messages))
+                } else {
+                    Err(serde::de::Error::custom("expected Single or Multiple"))
+                }
+            }
+            _ => Err(serde::de::Error::custom("expected string or array")),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SystemMessage {
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Message {
+    pub role: String,
+    pub content: MessageContent,
+}
+
+#[derive(Debug, Clone)]
+pub enum MessageContent {
+    Text(String),
+    Blocks(Vec<ContentBlock>),
+}
+
+impl<'de> Deserialize<'de> for MessageContent {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = serde_json::Value::deserialize(deserializer)?;
+        match value {
+            serde_json::Value::String(s) => Ok(MessageContent::Text(s)),
+            serde_json::Value::Array(arr) => {
+                let blocks: Vec<ContentBlock> =
+                    match serde_json::from_value(serde_json::Value::Array(arr.clone())) {
+                        Ok(b) => b,
+                        Err(_) => {
+                            // If array doesn't match ContentBlock variants, treat as text
+                            let text = serde_json::to_string(&arr).unwrap_or_default();
+                            return Ok(MessageContent::Text(text));
+                        }
+                    };
+                Ok(MessageContent::Blocks(blocks))
+            }
+            _ => Err(serde::de::Error::custom("expected string or array")),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+pub enum ContentBlock {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image")]
+    Image { source: ImageSource },
+    #[serde(rename = "tool_use")]
+    ToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+    #[serde(rename = "tool_result")]
+    ToolResult {
+        tool_use_id: String,
+        content: ToolResultContent,
+        #[serde(default)]
+        is_error: Option<bool>,
+    },
+    #[serde(rename = "thinking")]
+    Thinking { thinking: String },
+    #[serde(other)]
+    Other,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ImageSource {
+    pub media_type: String,
+    pub data: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Tool {
+    pub name: String,
+    pub description: Option<String>,
+    #[serde(rename = "input_schema")]
+    pub input_schema: serde_json::Value,
+    #[serde(rename = "type")]
+    pub tool_type: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(untagged)]
+pub enum ToolResultContent {
+    Text(String),
+    Blocks(Vec<serde_json::Value>),
+}
+
+// ============================================================================
+// Anthropic Response
+// ============================================================================
+
+#[derive(Debug, Clone, Serialize)]
+pub struct AnthropicResponse {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub response_type: String,
+    pub role: String,
+    pub content: Vec<ResponseContent>,
+    pub model: String,
+    #[serde(rename = "stop_reason")]
+    pub stop_reason: Option<String>,
+    #[serde(rename = "stop_sequence")]
+    pub stop_sequence: Option<()>,
+    pub usage: Usage,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type")]
+pub enum ResponseContent {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "thinking")]
+    Thinking { thinking: String },
+    #[serde(rename = "tool_use")]
+    ToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Usage {
+    #[serde(rename = "input_tokens")]
+    pub input_tokens: usize,
+    #[serde(rename = "output_tokens")]
+    pub output_tokens: usize,
+}
+
+// ============================================================================
+// Anthropic SSE Events
+// ============================================================================
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type")]
+pub enum StreamEvent {
+    #[serde(rename = "message_start")]
+    MessageStart { message: MessageStartData },
+    #[serde(rename = "content_block_start")]
+    ContentBlockStart {
+        index: usize,
+        content_block: ContentBlockStartData,
+    },
+    #[serde(rename = "content_block_delta")]
+    ContentBlockDelta {
+        index: usize,
+        delta: ContentBlockDeltaData,
+    },
+    #[serde(rename = "content_block_stop")]
+    ContentBlockStop { index: usize },
+    #[serde(rename = "message_delta")]
+    MessageDelta {
+        delta: MessageDeltaData,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        usage: Option<MessageDeltaUsage>,
+    },
+    #[serde(rename = "message_stop")]
+    MessageStop,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct MessageStartData {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub message_type: String,
+    pub role: String,
+    pub model: String,
+    pub usage: Usage,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type", content = "content_block")]
+pub enum ContentBlockStartData {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "thinking")]
+    Thinking { thinking: String },
+    #[serde(rename = "tool_use")]
+    ToolUse { id: String, name: String },
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ContentBlockDeltaData {
+    TextDelta { text: String },
+    ThinkingDelta { thinking: String },
+    InputJsonDelta { partial_json: String },
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct MessageDeltaData {
+    #[serde(rename = "stop_reason")]
+    pub stop_reason: Option<String>,
+    #[serde(rename = "stop_sequence")]
+    pub stop_sequence: (),
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct MessageDeltaUsage {
+    #[serde(rename = "output_tokens")]
+    pub output_tokens: usize,
+}

package/src/models/mod.rs

@@ -0,0 +1,2 @@
+pub mod anthropic;
+pub mod openai;

package/src/models/openai.rs

@@ -0,0 +1,230 @@
+use serde::{Deserialize, Serialize};
+
+// ============================================================================
+// OpenAI Request
+// ============================================================================
+
+#[derive(Debug, Clone, Serialize)]
+pub struct OpenAIRequest {
+    pub model: String,
+    pub messages: Vec<Message>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_tokens: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_k: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stream: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<Tool>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_choice: Option<ToolChoice>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Message {
+    pub role: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<MessageContent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_calls: Option<Vec<ToolCall>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_call_id: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub enum MessageContent {
+    Text(String),
+    Parts(Vec<ContentPart>),
+}
+
+impl Serialize for MessageContent {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            MessageContent::Text(s) => s.serialize(serializer),
+            MessageContent::Parts(parts) => parts.serialize(serializer),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ContentPart {
+    Text { data: String },
+    ImageUrl { image_url: ImageUrl },
+}
+
+impl Serialize for ContentPart {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        #[derive(Serialize)]
+        struct TextPart {
+            #[serde(rename = "type")]
+            part_type: &'static str,
+            text: String,
+        }
+        #[derive(Serialize)]
+        struct ImageUrlPart {
+            #[serde(rename = "type")]
+            part_type: &'static str,
+            image_url: ImageUrl,
+        }
+
+        match self {
+            ContentPart::Text { data } => TextPart {
+                part_type: "text",
+                text: data.clone(),
+            }
+            .serialize(serializer),
+            ContentPart::ImageUrl { image_url } => ImageUrlPart {
+                part_type: "image_url",
+                image_url: image_url.clone(),
+            }
+            .serialize(serializer),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ImageUrl {
+    pub url: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Tool {
+    #[serde(rename = "type")]
+    pub tool_type: String,
+    pub function: Function,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Function {
+    pub name: String,
+    pub description: Option<String>,
+    pub parameters: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCall {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub call_type: String,
+    pub function: FunctionCall,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FunctionCall {
+    pub name: String,
+    pub arguments: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ToolChoice {
+    String(String),
+    Object {
+        #[serde(rename = "type")]
+        tool_type: String,
+        function: ToolChoiceFunction,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolChoiceFunction {
+    pub name: String,
+}
+
+// ============================================================================
+// OpenAI Response
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct OpenAIResponse {
+    pub id: Option<String>,
+    pub model: Option<String>,
+    pub choices: Vec<Choice>,
+    pub usage: Usage,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Choice {
+    pub message: ChoiceMessage,
+    #[serde(rename = "finish_reason")]
+    pub finish_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ChoiceMessage {
+    pub content: Option<String>,
+    #[serde(rename = "tool_calls")]
+    pub tool_calls: Option<Vec<ToolCall>>,
+    #[serde(rename = "reasoning_content")]
+    pub reasoning_content: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Usage {
+    #[serde(rename = "prompt_tokens")]
+    pub prompt_tokens: usize,
+    #[serde(rename = "completion_tokens")]
+    pub completion_tokens: usize,
+}
+
+// ============================================================================
+// OpenAI Streaming Chunk
+// ============================================================================
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct StreamChunk {
+    pub id: Option<String>,
+    pub model: Option<String>,
+    pub choices: Vec<StreamChoice>,
+    pub usage: Option<StreamUsage>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct StreamChoice {
+    pub delta: StreamDelta,
+    #[serde(rename = "finish_reason")]
+    pub finish_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct StreamDelta {
+    #[serde(default)]
+    pub content: Option<String>,
+    #[serde(default)]
+    pub reasoning: Option<String>,
+    #[serde(rename = "tool_calls")]
+    pub tool_calls: Option<Vec<StreamToolCall>>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct StreamToolCall {
+    pub index: Option<usize>,
+    pub id: Option<String>,
+    pub function: Option<StreamFunctionCall>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct StreamFunctionCall {
+    pub name: Option<String>,
+    pub arguments: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct StreamUsage {
+    #[serde(rename = "completion_tokens")]
+    pub completion_tokens: Option<usize>,
+}