@mmmbuto/anthmorph 0.1.2 → 0.1.3

package/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "AnthMorph"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "anyhow",
  "async-stream",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "AnthMorph"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 description = "Anthropic to OpenAI-compatible proxy"
 license = "MIT"

package/README.md

@@ -83,7 +83,7 @@ anthmorphctl stop
 Direct binary usage is also available:
 
 ```bash
-anthmorph --port 3107 --backend-profile chutes --backend-url https://llm.chutes.ai/v1 --model Qwen/Qwen3-Coder-Next-TEE --api-key "$CHUTES_API_KEY"
+anthmorph --port 3107 --backend-profile chutes --backend-url https://llm.chutes.ai/v1 --model Qwen/Qwen3.5-397B-A17B-TEE,zai-org/GLM-5-TEE,deepseek-ai/DeepSeek-V3.2-TEE --api-key "$CHUTES_API_KEY"
 ```
 
 ## Architecture

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/anthmorph",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Chutes-first Anthropic /v1/messages proxy for Chutes and OpenAI-compatible backends",
   "license": "MIT",
   "author": "DioNanos <noreply@github.com>",

package/scripts/anthmorphctl

@@ -216,7 +216,7 @@ init_cmd() {
     chutes)
       BACKEND_PROFILE=chutes
       BACKEND_URL=https://llm.chutes.ai/v1
-      MODEL=Qwen/Qwen3-Coder-Next-TEE
+      MODEL=Qwen/Qwen3.5-397B-A17B-TEE,zai-org/GLM-5-TEE,deepseek-ai/DeepSeek-V3.2-TEE
       API_KEY_ENV=CHUTES_API_KEY
       ;;
     minimax)

package/scripts/smoke_test.sh

@@ -11,7 +11,7 @@ case "$BACKEND" in
   chutes)
     PROFILE=chutes
     BACKEND_URL=${CHUTES_BASE_URL:-https://llm.chutes.ai/v1}
-    MODEL=${CHUTES_MODEL:-Qwen/Qwen3-Coder-Next-TEE}
+    MODEL=${CHUTES_MODEL:-Qwen/Qwen3.5-397B-A17B-TEE,zai-org/GLM-5-TEE,deepseek-ai/DeepSeek-V3.2-TEE}
     API_KEY=${CHUTES_API_KEY:?CHUTES_API_KEY is required}
     ;;
   alibaba)

package/src/models/anthropic.rs

@@ -236,12 +236,17 @@ pub struct MessageStartData {
     #[serde(rename = "type")]
     pub message_type: String,
     pub role: String,
+    pub content: Vec<serde_json::Value>,
     pub model: String,
+    #[serde(rename = "stop_reason")]
+    pub stop_reason: Option<serde_json::Value>,
+    #[serde(rename = "stop_sequence")]
+    pub stop_sequence: Option<serde_json::Value>,
     pub usage: Usage,
 }
 
 #[derive(Debug, Clone, Serialize)]
-#[serde(tag = "type", content = "content_block")]
+#[serde(tag = "type")]
 pub enum ContentBlockStartData {
     #[serde(rename = "text")]
     Text { text: String },

package/src/proxy.rs

@@ -255,9 +255,12 @@ fn create_sse_stream(
                                             id: message_id.clone().unwrap_or_else(generate_message_id),
                                             message_type: "message".to_string(),
                                             role: "assistant".to_string(),
+                                            content: vec![],
                                             model: current_model
                                                 .clone()
                                                 .unwrap_or_else(|| fallback_model.clone()),
+                                            stop_reason: None,
+                                            stop_sequence: None,
                                             usage: anthropic::Usage {
                                                 input_tokens: 0,
                                                 output_tokens: 0,
@@ -413,8 +416,10 @@ impl Config {
                 .ok()
                 .and_then(|v| v.parse().ok())
                 .unwrap_or(BackendProfile::Chutes),
-            model: std::env::var("ANTHMORPH_MODEL")
-                .unwrap_or_else(|_| "Qwen/Qwen3-Coder-Next-TEE".to_string()),
+            model: std::env::var("ANTHMORPH_MODEL").unwrap_or_else(|_| {
+                "Qwen/Qwen3.5-397B-A17B-TEE,zai-org/GLM-5-TEE,deepseek-ai/DeepSeek-V3.2-TEE"
+                    .to_string()
+            }),
             reasoning_model: std::env::var("ANTHMORPH_REASONING_MODEL").ok(),
             api_key: std::env::var("ANTHMORPH_API_KEY").ok(),
             ingress_api_key: std::env::var("ANTHMORPH_INGRESS_API_KEY").ok(),
@@ -744,6 +749,61 @@ mod tests {
         assert_eq!(joined.matches("event: content_block_start").count(), 1);
     }
 
+    #[test]
+    fn message_start_sse_includes_required_anthropic_fields() {
+        let event = anthropic::StreamEvent::MessageStart {
+            message: anthropic::MessageStartData {
+                id: "msg_test".to_string(),
+                message_type: "message".to_string(),
+                role: "assistant".to_string(),
+                content: vec![],
+                model: "glm-5.1".to_string(),
+                stop_reason: None,
+                stop_sequence: None,
+                usage: anthropic::Usage {
+                    input_tokens: 0,
+                    output_tokens: 0,
+                },
+            },
+        };
+
+        let serialized = sse_event("message_start", &event);
+        let payload = serialized
+            .lines()
+            .find_map(|line| line.strip_prefix("data: "))
+            .expect("message_start data line");
+        let parsed: serde_json::Value = serde_json::from_str(payload).expect("valid json");
+
+        assert_eq!(parsed["message"]["type"], "message");
+        assert_eq!(parsed["message"]["role"], "assistant");
+        assert_eq!(parsed["message"]["content"], json!([]));
+        assert!(parsed["message"]["stop_reason"].is_null());
+        assert!(parsed["message"]["stop_sequence"].is_null());
+    }
+
+    #[test]
+    fn content_block_start_tool_use_has_flat_anthropic_shape() {
+        let payload = start_block_sse(
+            0,
+            anthropic::ContentBlockStartData::ToolUse {
+                id: "toolu_123".to_string(),
+                name: "mcp__memory__memory_read".to_string(),
+                input: json!({}),
+            },
+        )
+        .lines()
+        .find_map(|line| line.strip_prefix("data: "))
+        .expect("content_block_start data line")
+        .to_string();
+
+        let parsed: serde_json::Value = serde_json::from_str(&payload).expect("valid json");
+        assert_eq!(parsed["content_block"]["type"], "tool_use");
+        assert_eq!(parsed["content_block"]["id"], "toolu_123");
+        assert_eq!(parsed["content_block"]["name"], "mcp__memory__memory_read");
+        assert_eq!(parsed["content_block"]["input"], json!({}));
+        assert!(parsed["content_block"].get("content_block").is_none());
+    }
+
     #[test]
     fn extracts_multi_line_sse_data() {
         let block = "event: message\ndata: first\ndata: second\n";

package/src/transform.rs

@@ -61,27 +61,23 @@ pub fn anthropic_to_openai(
     let mut openai_messages = Vec::new();
 
     if let Some(system) = req.system {
-        match system {
-            anthropic::SystemPrompt::Single(text) => {
-                openai_messages.push(openai::Message {
-                    role: "system".to_string(),
-                    content: Some(openai::MessageContent::Text(text)),
-                    name: None,
-                    tool_calls: None,
-                    tool_call_id: None,
-                });
-            }
-            anthropic::SystemPrompt::Multiple(messages) => {
-                for msg in messages {
-                    openai_messages.push(openai::Message {
-                        role: "system".to_string(),
-                        content: Some(openai::MessageContent::Text(msg.text)),
-                        name: None,
-                        tool_calls: None,
-                        tool_call_id: None,
-                    });
-                }
-            }
+        let system_text = match system {
+            anthropic::SystemPrompt::Single(text) => text,
+            anthropic::SystemPrompt::Multiple(messages) => messages
+                .into_iter()
+                .map(|msg| msg.text)
+                .collect::<Vec<_>>()
+                .join("\n\n"),
+        };
+
+        if !system_text.is_empty() {
+            openai_messages.push(openai::Message {
+                role: "system".to_string(),
+                content: Some(openai::MessageContent::Text(system_text)),
+                name: None,
+                tool_calls: None,
+                tool_call_id: None,
+            });
         }
     }
 
@@ -354,7 +350,7 @@ pub fn map_stop_reason(finish_reason: Option<&str>) -> Option<String> {
 mod tests {
     use super::*;
     use crate::models::anthropic::{
-        AnthropicRequest, ContentBlock, Message, MessageContent, SystemPrompt, Tool,
+        AnthropicRequest, ContentBlock, Message, MessageContent, SystemMessage, SystemPrompt, Tool,
     };
 
     fn sample_request() -> AnthropicRequest {
@@ -409,6 +405,41 @@ mod tests {
         assert!(err.to_string().contains("thinking blocks"));
     }
 
+    #[test]
+    fn collapses_multiple_system_prompts_into_single_openai_message() {
+        let req = AnthropicRequest {
+            model: "claude".to_string(),
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: MessageContent::Text("hi".to_string()),
+            }],
+            system: Some(SystemPrompt::Multiple(vec![
+                SystemMessage {
+                    text: "one".to_string(),
+                },
+                SystemMessage {
+                    text: "two".to_string(),
+                },
+            ])),
+            max_tokens: 64,
+            temperature: None,
+            top_p: None,
+            top_k: None,
+            stop_sequences: None,
+            stream: None,
+            tools: None,
+            extra: Default::default(),
+        };
+
+        let out = anthropic_to_openai(req, "model", BackendProfile::Chutes).unwrap();
+        assert_eq!(out.messages[0].role, "system");
+        match out.messages[0].content.as_ref().unwrap() {
+            openai::MessageContent::Text(text) => assert_eq!(text, "one\n\ntwo"),
+            other => panic!("expected text system prompt, got {other:?}"),
+        }
+        assert_eq!(out.messages[1].role, "user");
+    }
+
     #[test]
     fn maps_reasoning_to_thinking_block_for_chutes() {
         let resp = openai::OpenAIResponse {

package/tests/real_backends.rs

@@ -153,7 +153,7 @@ fn chutes_real_backend_smoke() {
     let server = start_server(
         "chutes",
         &env::var("CHUTES_BASE_URL").unwrap_or_else(|_| "https://llm.chutes.ai/v1".to_string()),
-        &env::var("CHUTES_MODEL").unwrap_or_else(|_| "Qwen/Qwen3-Coder-Next-TEE".to_string()),
+        &env::var("CHUTES_MODEL").unwrap_or_else(|_| "deepseek-ai/DeepSeek-V3.2-TEE".to_string()),
         &api_key,
     );