anchor-chain 0.4.2

A statically typed async framework for building LLM-based applications.
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

//! Contains generic message types that can be used with multiple LLM models.
//!
//! These types are used to represent messages that can be sent to and received
//! from LLM models. They are designed to be generic and reusable across
//! different models and applications. This module also provides conversion
//! traits to convert these generic message types into model-specific message
//! types for use with specific LLM models.

use async_openai::types::{
    ChatCompletionRequestAssistantMessageArgs, ChatCompletionRequestMessage,
    ChatCompletionRequestUserMessageArgs,
};

use crate::models::claude_3::{ClaudeMessage, ClaudeMessageContent};

pub enum ChatMessage {
    User(UserChatMessage),
    Assistant(AssistantChatMessage),
}

#[allow(dead_code)]
enum ChatMessageContent {
    Text(String),
    Image(String),
}

pub struct UserChatMessage {
    content: ChatMessageContent,
}

pub struct AssistantChatMessage {
    content: ChatMessageContent,
}

struct ChatMessageVec {
    messages: Vec<ChatMessage>,
}

impl From<ChatMessage> for ChatCompletionRequestMessage {
    fn from(message: ChatMessage) -> ChatCompletionRequestMessage {
        match message {
            ChatMessage::User(user_message) => user_message.into(),
            ChatMessage::Assistant(assistant_message) => assistant_message.into(),
        }
    }
}

impl From<ChatMessage> for ClaudeMessage {
    fn from(message: ChatMessage) -> ClaudeMessage {
        match message {
            ChatMessage::User(user_message) => user_message.into(),
            ChatMessage::Assistant(assistant_message) => assistant_message.into(),
        }
    }
}

impl From<UserChatMessage> for ChatCompletionRequestMessage {
    fn from(message: UserChatMessage) -> ChatCompletionRequestMessage {
        match message.content {
            ChatMessageContent::Text(text) => ChatCompletionRequestUserMessageArgs::default()
                .content(text)
                .build()
                .unwrap()
                .into(),
            ChatMessageContent::Image(_image) => todo!("Image support"),
        }
    }
}

impl From<UserChatMessage> for ClaudeMessage {
    fn from(message: UserChatMessage) -> ClaudeMessage {
        match message.content {
            ChatMessageContent::Text(text) => ClaudeMessage {
                role: Some("user".to_string()),
                content: vec![ClaudeMessageContent {
                    content_type: "text".to_string(),
                    text: Some(text),
                    source: None,
                }],
            },
            ChatMessageContent::Image(_image) => todo!("Image support"),
        }
    }
}

impl From<AssistantChatMessage> for ChatCompletionRequestMessage {
    fn from(message: AssistantChatMessage) -> ChatCompletionRequestMessage {
        match message.content {
            ChatMessageContent::Text(text) => ChatCompletionRequestAssistantMessageArgs::default()
                .content(text)
                .build()
                .unwrap()
                .into(),
            ChatMessageContent::Image(_image) => todo!("Image support"),
        }
    }
}

impl From<AssistantChatMessage> for ClaudeMessage {
    fn from(message: AssistantChatMessage) -> ClaudeMessage {
        match message.content {
            ChatMessageContent::Text(text) => ClaudeMessage {
                role: Some("assistant".to_string()),
                content: vec![ClaudeMessageContent {
                    content_type: "text".to_string(),
                    text: Some(text),
                    source: None,
                }],
            },
            ChatMessageContent::Image(_image) => todo!("Image support"),
        }
    }
}

impl From<Vec<ChatMessage>> for ChatMessageVec {
    fn from(messages: Vec<ChatMessage>) -> ChatMessageVec {
        ChatMessageVec { messages }
    }
}

impl From<ChatMessageVec> for Vec<ChatCompletionRequestMessage> {
    fn from(messages: ChatMessageVec) -> Vec<ChatCompletionRequestMessage> {
        messages.messages.into_iter().map(|m| m.into()).collect()
    }
}