systemprompt-ai 0.1.21

Core AI module for systemprompt.io
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

use anyhow::Result;
use async_trait::async_trait;
use futures::Stream;
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 super::service::AiService;

#[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) -> Result<AiResponse> {
        Self::generate(self, request).await
    }

    async fn generate_stream(
        &self,
        request: &AiRequest,
    ) -> Result<Pin<Box<dyn Stream<Item = Result<StreamChunk>> + Send>>> {
        Self::generate_stream(self, request).await
    }

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

    async fn generate_with_tools_stream(
        &self,
        request: &AiRequest,
    ) -> Result<Pin<Box<dyn Stream<Item = Result<StreamChunk>> + Send>>> {
        Self::generate_with_tools_stream(self, request).await
    }

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

    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,
    ) -> Result<Vec<McpTool>> {
        Self::list_available_tools_for_agent(self, agent_name, context).await
    }

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

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

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

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