systemprompt-ai 0.14.5

Provider-agnostic LLM integration for systemprompt.io AI governance — Anthropic, OpenAI, Gemini, and local models unified behind one governed pipeline with cost tracking and audit.
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

use async_trait::async_trait;
use futures::{Stream, StreamExt};
use std::collections::HashMap;
use std::pin::Pin;

use systemprompt_identifiers::AgentName;
use systemprompt_models::RequestContext;
use systemprompt_models::ai::{
    AiProvider, AiRequest, AiResponse, CallToolResult, GenerateResponseParams, GoogleSearchParams,
    McpTool, PlanningResult, SearchGroundedResponse, StreamChunk, ToolCall, ToolModelOverrides,
};
use systemprompt_models::errors::ProviderResult;

use super::service::AiService;

fn boxed_err<E: std::fmt::Display>(e: E) -> Box<dyn std::error::Error + Send + Sync> {
    Box::<dyn std::error::Error + Send + Sync>::from(e.to_string())
}

#[async_trait]
impl AiProvider for AiService {
    fn default_provider(&self) -> &str {
        Self::default_provider(self)
    }

    fn default_model(&self) -> &str {
        Self::default_model(self)
    }

    fn default_max_output_tokens(&self) -> u32 {
        Self::default_max_output_tokens(self)
    }

    async fn generate(&self, request: &AiRequest) -> ProviderResult<AiResponse> {
        Self::generate(self, request).await.map_err(boxed_err)
    }

    async fn generate_stream(
        &self,
        request: &AiRequest,
    ) -> ProviderResult<Pin<Box<dyn Stream<Item = ProviderResult<StreamChunk>> + Send>>> {
        let stream = Self::generate_stream(self, request)
            .await
            .map_err(boxed_err)?;
        let mapped = stream.map(|item| item.map_err(boxed_err));
        Ok(Box::pin(mapped))
    }

    async fn generate_with_tools(&self, request: &AiRequest) -> ProviderResult<AiResponse> {
        Self::generate_with_tools(self, request)
            .await
            .map_err(boxed_err)
    }

    async fn generate_with_tools_stream(
        &self,
        request: &AiRequest,
    ) -> ProviderResult<Pin<Box<dyn Stream<Item = ProviderResult<StreamChunk>> + Send>>> {
        let stream = Self::generate_with_tools_stream(self, request)
            .await
            .map_err(boxed_err)?;
        let mapped = stream.map(|item| item.map_err(boxed_err));
        Ok(Box::pin(mapped))
    }

    async fn generate_single_turn(
        &self,
        request: &AiRequest,
    ) -> ProviderResult<(AiResponse, Vec<ToolCall>)> {
        Self::generate_single_turn(self, request)
            .await
            .map_err(boxed_err)
    }

    async fn execute_tools(
        &self,
        tool_calls: Vec<ToolCall>,
        tools: &[McpTool],
        context: &RequestContext,
        agent_overrides: Option<&ToolModelOverrides>,
    ) -> (Vec<ToolCall>, Vec<CallToolResult>) {
        Self::execute_tools(self, tool_calls, tools, context, agent_overrides).await
    }

    async fn list_available_tools_for_agent(
        &self,
        agent_name: &AgentName,
        context: &RequestContext,
    ) -> ProviderResult<Vec<McpTool>> {
        Self::list_available_tools_for_agent(self, agent_name, context)
            .await
            .map_err(boxed_err)
    }

    async fn generate_with_google_search(
        &self,
        params: GoogleSearchParams<'_>,
    ) -> ProviderResult<SearchGroundedResponse> {
        Self::generate_with_google_search(self, params)
            .await
            .map_err(boxed_err)
    }

    async fn health_check(&self) -> ProviderResult<HashMap<String, bool>> {
        Self::health_check(self).await.map_err(boxed_err)
    }

    async fn generate_plan(
        &self,
        request: &AiRequest,
        available_tools: &[McpTool],
    ) -> ProviderResult<PlanningResult> {
        Self::generate_plan(self, request, available_tools)
            .await
            .map_err(boxed_err)
    }

    async fn generate_response(
        &self,
        params: GenerateResponseParams<'_>,
    ) -> ProviderResult<String> {
        Self::generate_response(self, params)
            .await
            .map_err(boxed_err)
    }
}