anyllm_translate 0.9.7

Pure translation layer between Anthropic Messages API and OpenAI Chat Completions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// crates/translator/src/anthropic/batch.rs
// Anthropic Message Batches API types.
// See https://docs.anthropic.com/en/api/creating-message-batches

use crate::anthropic::errors::ErrorDetail;
use crate::anthropic::messages::{MessageCreateRequest, MessageResponse};
use serde::{Deserialize, Serialize};

/// One entry in a POST /v1/messages/batches request body.
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct BatchRequestItem {
    pub custom_id: String,
    pub params: MessageCreateRequest,
}

/// POST /v1/messages/batches request body.
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct CreateBatchRequest {
    pub requests: Vec<BatchRequestItem>,
}

/// Processing lifecycle of a message batch.
#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ProcessingStatus {
    InProgress,
    Canceling,
    Ended,
}

/// Per-status request counts within a batch.
#[derive(Deserialize, Serialize, Debug, Clone, Default)]
pub struct BatchRequestCounts {
    pub processing: u32,
    pub succeeded: u32,
    pub errored: u32,
    pub canceled: u32,
    pub expired: u32,
}

/// Message batch object returned by the API.
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct MessageBatch {
    pub id: String,
    #[serde(rename = "type")]
    pub type_: String,
    pub processing_status: ProcessingStatus,
    pub request_counts: BatchRequestCounts,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ended_at: Option<i64>,
    pub created_at: i64,
    pub expires_at: i64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub archived_at: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cancel_initiated_at: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub results_url: Option<String>,
}

/// Result type for a single batch request.
#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(tag = "type", rename_all = "snake_case")]
#[allow(clippy::large_enum_variant)]
pub enum BatchResultVariant {
    Succeeded { message: MessageResponse },
    Errored { error: ErrorDetail },
    Canceled,
    Expired,
}

/// One line in the results JSONL file.
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct BatchResultItem {
    pub custom_id: String,
    pub result: BatchResultVariant,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn deserialize_create_batch_request() {
        let json = serde_json::json!({
            "requests": [
                {
                    "custom_id": "req-1",
                    "params": {
                        "model": "claude-3-5-sonnet-20241022",
                        "max_tokens": 100,
                        "messages": [{"role": "user", "content": "Hello"}]
                    }
                }
            ]
        });
        let req: CreateBatchRequest = serde_json::from_value(json).unwrap();
        assert_eq!(req.requests.len(), 1);
        assert_eq!(req.requests[0].custom_id, "req-1");
        assert_eq!(req.requests[0].params.model, "claude-3-5-sonnet-20241022");
    }

    #[test]
    fn serialize_message_batch_in_progress() {
        let batch = MessageBatch {
            id: "msgbatch_abc".to_string(),
            type_: "message_batch".to_string(),
            processing_status: ProcessingStatus::InProgress,
            request_counts: BatchRequestCounts {
                processing: 2,
                succeeded: 0,
                errored: 0,
                canceled: 0,
                expired: 0,
            },
            ended_at: None,
            created_at: 1_700_000_000,
            expires_at: 1_700_086_400,
            archived_at: None,
            cancel_initiated_at: None,
            results_url: None,
        };
        let v = serde_json::to_value(&batch).unwrap();
        assert_eq!(v["id"], "msgbatch_abc");
        assert_eq!(v["processing_status"], "in_progress");
        assert_eq!(v["request_counts"]["processing"], 2);
    }

    #[test]
    fn serialize_batch_result_succeeded() {
        // BatchResultVariant::Succeeded wraps a MessageResponse.
        // The "type" discriminant should serialize to "succeeded".
        let v = serde_json::to_value(BatchResultVariant::Canceled).unwrap();
        assert_eq!(v["type"], "canceled");
    }
}