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

use crate::BridgeReport;
use serde_json::Value;
use siumai_core::types::{ProviderDefinedTool, Tool};

pub(crate) type ProviderToolArgsMapper = fn(usize, &Value, &mut BridgeReport) -> Value;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum TargetToolNamePolicy {
    PreserveSourceName,
    Fixed(&'static str),
}

#[derive(Clone, Copy)]
pub(crate) struct ProviderToolTranslationRule {
    pub(crate) source_tool_types: &'static [&'static str],
    pub(crate) target_tool_id: &'static str,
    pub(crate) target_tool_name: TargetToolNamePolicy,
    pub(crate) choice_name: Option<&'static str>,
    pub(crate) aliases: &'static [&'static str],
    pub(crate) args_mapper: ProviderToolArgsMapper,
}

impl ProviderToolTranslationRule {
    pub(crate) fn matches(self, provider_tool: &ProviderDefinedTool) -> bool {
        let Some(tool_type) = provider_tool.tool_type() else {
            return false;
        };

        self.source_tool_types.contains(&tool_type)
    }

    pub(crate) fn translate_tool(
        self,
        index: usize,
        provider_tool: &ProviderDefinedTool,
        report: &mut BridgeReport,
    ) -> Tool {
        let tool_name = match self.target_tool_name {
            TargetToolNamePolicy::PreserveSourceName => provider_tool.name.clone(),
            TargetToolNamePolicy::Fixed(name) => name.to_string(),
        };

        Tool::provider_defined(self.target_tool_id, tool_name).with_args((self.args_mapper)(
            index,
            &provider_tool.args,
            report,
        ))
    }

    pub(crate) fn choice_name(self, provider_tool: &ProviderDefinedTool) -> String {
        self.choice_name
            .map(str::to_string)
            .unwrap_or_else(|| match self.target_tool_name {
                TargetToolNamePolicy::PreserveSourceName => provider_tool.name.clone(),
                TargetToolNamePolicy::Fixed(name) => name.to_string(),
            })
    }

    pub(crate) fn aliases(self, provider_tool: &ProviderDefinedTool) -> Vec<String> {
        let mut aliases = Vec::with_capacity(1 + self.aliases.len());
        aliases.push(provider_tool.name.clone());
        aliases.extend(self.aliases.iter().map(|alias| (*alias).to_string()));
        aliases
    }
}

pub(crate) fn find_provider_tool_translation_rule<'a>(
    provider_tool: &ProviderDefinedTool,
    rules: &'a [ProviderToolTranslationRule],
) -> Option<&'a ProviderToolTranslationRule> {
    rules.iter().find(|rule| rule.matches(provider_tool))
}