siumai-bridge 0.11.0-beta.9

Protocol bridge helpers for siumai gateway and facade integrations
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

//! High-value direct request bridge pairs.
//!
//! These pair modules host the request bridge implementations that are worth
//! maintaining directly instead of routing through the normalized backbone.

#[cfg(all(feature = "anthropic", feature = "openai"))]
mod anthropic_messages_to_openai_responses;
#[cfg(all(feature = "anthropic", feature = "openai"))]
mod mcp;
#[cfg(all(feature = "anthropic", feature = "openai"))]
mod openai_responses_to_anthropic_messages;
#[cfg(all(feature = "anthropic", feature = "openai"))]
mod tool_rules;

use crate::BridgeReport;
use crate::BridgeTarget;
use siumai_core::LlmError;
use siumai_core::types::ChatRequest;

/// Explicit direct request bridge pairs worth implementing.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DirectRequestBridgePair {
    AnthropicMessagesToOpenAiResponses,
    OpenAiResponsesToAnthropicMessages,
}

impl DirectRequestBridgePair {
    pub const fn source(self) -> BridgeTarget {
        match self {
            Self::AnthropicMessagesToOpenAiResponses => BridgeTarget::AnthropicMessages,
            Self::OpenAiResponsesToAnthropicMessages => BridgeTarget::OpenAiResponses,
        }
    }

    pub const fn target(self) -> BridgeTarget {
        match self {
            Self::AnthropicMessagesToOpenAiResponses => BridgeTarget::OpenAiResponses,
            Self::OpenAiResponsesToAnthropicMessages => BridgeTarget::AnthropicMessages,
        }
    }

    pub const fn as_str(self) -> &'static str {
        match self {
            Self::AnthropicMessagesToOpenAiResponses => "anthropic-messages-to-openai-responses",
            Self::OpenAiResponsesToAnthropicMessages => "openai-responses-to-anthropic-messages",
        }
    }
}

/// Return a direct bridge pair for the given source/target combination when one exists.
pub const fn direct_request_bridge_pair(
    source: BridgeTarget,
    target: BridgeTarget,
) -> Option<DirectRequestBridgePair> {
    match (source, target) {
        (BridgeTarget::AnthropicMessages, BridgeTarget::OpenAiResponses) => {
            Some(DirectRequestBridgePair::AnthropicMessagesToOpenAiResponses)
        }
        (BridgeTarget::OpenAiResponses, BridgeTarget::AnthropicMessages) => {
            Some(DirectRequestBridgePair::OpenAiResponsesToAnthropicMessages)
        }
        _ => None,
    }
}

/// Serialize a request via a direct pair bridge when implemented.
pub(crate) fn serialize_direct_request_bridge_pair(
    pair: DirectRequestBridgePair,
    request: &ChatRequest,
    report: &mut BridgeReport,
) -> Result<serde_json::Value, LlmError> {
    match pair {
        DirectRequestBridgePair::AnthropicMessagesToOpenAiResponses => {
            #[cfg(all(feature = "anthropic", feature = "openai"))]
            {
                anthropic_messages_to_openai_responses::serialize_anthropic_messages_to_openai_responses(
                    request, report,
                )
            }
            #[cfg(not(all(feature = "anthropic", feature = "openai")))]
            {
                let _ = (request, report);
                Err(LlmError::UnsupportedOperation(
                    "anthropic/openai direct bridge requires both features".to_string(),
                ))
            }
        }
        DirectRequestBridgePair::OpenAiResponsesToAnthropicMessages => {
            #[cfg(all(feature = "anthropic", feature = "openai"))]
            {
                openai_responses_to_anthropic_messages::serialize_openai_responses_to_anthropic_messages(
                    request, report,
                )
            }
            #[cfg(not(all(feature = "anthropic", feature = "openai")))]
            {
                let _ = (request, report);
                Err(LlmError::UnsupportedOperation(
                    "anthropic/openai direct bridge requires both features".to_string(),
                ))
            }
        }
    }
}