Skip to main content

rigspark_runtime/
agent.rs

1use crate::{
2    harness::{DeltaSink, HarnessError},
3    mcp::{Manager, ReviewedCall},
4    ollama_inference::{ChatInput, ChatMessage, ChatResult, Tool},
5    tool_policy::{SessionGrants, ToolRisk, redact_arguments, redact_result},
6};
7use serde::Serialize;
8use serde_json::Value;
9use std::{
10    collections::BTreeMap,
11    time::{Duration, Instant},
12};
13use tokio_util::sync::CancellationToken;
14
15#[async_trait::async_trait]
16pub trait AgentChat: Send + Sync {
17    async fn chat(
18        &self,
19        input: &ChatInput,
20        cancel: &CancellationToken,
21        sink: &mut DeltaSink<'_>,
22    ) -> Result<ChatResult, HarnessError>;
23}
24#[derive(Clone, Copy)]
25pub enum Decision {
26    ApproveOnce,
27    AllowSession,
28    Deny,
29}
30#[async_trait::async_trait]
31pub trait ToolApprover: Send + Sync {
32    async fn decide(
33        &self,
34        call_id: &str,
35        call: &ReviewedCall,
36        cancel: &CancellationToken,
37    ) -> Result<Decision, HarnessError>;
38}
39#[derive(Serialize)]
40#[serde(tag = "type", rename_all = "lowercase")]
41pub enum AgentEvent {
42    Delta { content: String },
43    Tool(ToolEvent),
44}
45#[derive(Default, Serialize)]
46#[serde(rename_all = "camelCase")]
47pub struct ToolEvent {
48    pub phase: String,
49    pub call_id: String,
50    pub name: String,
51    #[serde(skip_serializing_if = "Option::is_none")]
52    pub connector: Option<String>,
53    #[serde(skip_serializing_if = "Option::is_none")]
54    pub risk: Option<ToolRisk>,
55    #[serde(skip_serializing_if = "Option::is_none")]
56    pub arguments: Option<Value>,
57    #[serde(skip_serializing_if = "Option::is_none")]
58    pub result: Option<String>,
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub result_truncated: Option<bool>,
61    #[serde(skip_serializing_if = "Option::is_none")]
62    pub is_error: Option<bool>,
63    #[serde(skip_serializing_if = "Option::is_none")]
64    pub duration_ms: Option<u64>,
65}
66pub type EventSink<'sink> = dyn FnMut(AgentEvent) -> Result<(), HarnessError> + Send + 'sink;
67pub struct AgentOptions<'request> {
68    pub session_id: &'request str,
69    pub workspace_id: Option<&'request str>,
70    pub model: &'request str,
71    pub messages: Vec<ChatMessage>,
72    pub temperature: Option<f64>,
73    pub max_steps: usize,
74}
75fn feedback(text: &str) -> String {
76    if text.len() <= 8192 {
77        return text.into();
78    }
79    let mut end = 8192;
80    while !text.is_char_boundary(end) {
81        end -= 1;
82    }
83    format!("{}\n... [truncated]", &text[..end])
84}
85fn tool_event(phase: &str, call_id: &str, name: &str) -> ToolEvent {
86    ToolEvent {
87        phase: phase.into(),
88        call_id: call_id.into(),
89        name: name.into(),
90        ..Default::default()
91    }
92}
93async fn model_step(
94    chat: &dyn AgentChat,
95    input: &ChatInput,
96    cancel: &CancellationToken,
97    sink: &mut EventSink<'_>,
98    output: &mut String,
99) -> Result<ChatResult, HarnessError> {
100    if serde_json::to_vec(input)
101        .map_err(|_| HarnessError::Invalid)?
102        .len()
103        > 4 * 1024 * 1024
104    {
105        return Err(HarnessError::Limit);
106    }
107    let mut streamed = String::new();
108    let mut emit = |text: &str| {
109        if output.len().saturating_add(text.len()) > 16 * 1024 * 1024 {
110            return Err(HarnessError::Limit);
111        }
112        if cancel.is_cancelled() {
113            return Err(HarnessError::Cancelled);
114        }
115        if !text.is_empty() {
116            sink(AgentEvent::Delta {
117                content: text.into(),
118            })?;
119            output.push_str(text);
120            streamed.push_str(text);
121        }
122        Ok(())
123    };
124    let result = tokio::select! {
125        biased;
126        _ = cancel.cancelled() => return Err(HarnessError::Cancelled),
127        result = tokio::time::timeout(Duration::from_secs(120), chat.chat(input, cancel, &mut emit)) => result.map_err(|_| HarnessError::Timeout)??,
128    };
129    if result.content.len() > 16 * 1024 * 1024 || result.tool_calls.len() > 32 {
130        return Err(HarnessError::Limit);
131    }
132    if result.tool_calls.is_empty() {
133        let remainder = result
134            .content
135            .strip_prefix(&streamed)
136            .ok_or(HarnessError::Response)?;
137        if output.len().saturating_add(remainder.len()) > 16 * 1024 * 1024 {
138            return Err(HarnessError::Limit);
139        }
140        if !remainder.is_empty() {
141            sink(AgentEvent::Delta {
142                content: remainder.into(),
143            })?;
144            output.push_str(remainder);
145        }
146    }
147    Ok(result)
148}
149pub async fn run_turn(
150    chat: &dyn AgentChat,
151    manager: &mut Manager,
152    grants: &mut SessionGrants,
153    approver: Option<&dyn ToolApprover>,
154    options: AgentOptions<'_>,
155    cancel: &CancellationToken,
156    sink: &mut EventSink<'_>,
157) -> Result<String, HarnessError> {
158    if options.session_id.is_empty()
159        || options.session_id.len() > 128
160        || options.max_steps == 0
161        || options.max_steps > 16
162        || options.messages.len() > 10000
163        || options.temperature.is_some_and(|value| !value.is_finite())
164    {
165        return Err(HarnessError::Invalid);
166    }
167    grants.select(options.session_id, options.workspace_id);
168    let mut routing = BTreeMap::new();
169    let mut tools = Vec::new();
170    for (connector, tool) in manager.tools() {
171        let name = tool.name.clone();
172        if routing.contains_key(&name) {
173            continue;
174        }
175        tools.push(Tool {
176            name: name.clone(),
177            description: tool.description.clone(),
178            parameters: serde_json::from_value(tool.input_schema.clone())
179                .map_err(|_| HarnessError::Invalid)?,
180        });
181        routing.insert(name, (connector, tool));
182    }
183    if tools.len() > 1024 {
184        return Err(HarnessError::Limit);
185    }
186    let mut input = ChatInput {
187        model: options.model.into(),
188        messages: options.messages,
189        tools,
190        temperature: options.temperature,
191        slot: None,
192        max_tokens: None,
193    };
194    let mut output = String::new();
195    let mut call_count = 0usize;
196    for _ in 0..options.max_steps {
197        let result = model_step(chat, &input, cancel, sink, &mut output).await?;
198        if result.tool_calls.is_empty() {
199            return Ok(output);
200        }
201        input.messages.push(ChatMessage {
202            role: "assistant".into(),
203            content: result.content,
204            tool_calls: result.tool_calls.clone(),
205            tool_name: None,
206        });
207        for call in result.tool_calls {
208            if cancel.is_cancelled() {
209                return Err(HarnessError::Cancelled);
210            }
211            call_count += 1;
212            if call_count > 64 {
213                return Err(HarnessError::Limit);
214            }
215            let call_id = uuid::Uuid::new_v4().to_string();
216            let arguments =
217                serde_json::to_value(&call.arguments).map_err(|_| HarnessError::Invalid)?;
218            if serde_json::to_vec(&arguments)
219                .map_err(|_| HarnessError::Invalid)?
220                .len()
221                > 65536
222            {
223                return Err(HarnessError::Limit);
224            }
225            let route = routing.get(&call.name);
226            let reviewed = route.and_then(|(connector, tool)| {
227                manager
228                    .review(connector, &tool.name, arguments.clone())
229                    .ok()
230            });
231            let mut proposed = tool_event("proposed", &call_id, &call.name);
232            proposed.connector = route.map(|(connector, _)| connector.clone());
233            proposed.risk = Some(
234                reviewed
235                    .as_ref()
236                    .map(|review| review.risk)
237                    .unwrap_or(ToolRisk::Unknown),
238            );
239            proposed.arguments = Some(redact_arguments(&arguments));
240            sink(AgentEvent::Tool(proposed))?;
241            let mut approval = None;
242            if let Some(reviewed) = reviewed {
243                approval = manager.session_approval(reviewed, grants).ok();
244            }
245            if approval.is_none()
246                && let Some((connector, tool)) = route
247            {
248                let reviewed = manager
249                    .review(connector, &tool.name, arguments.clone())
250                    .map_err(|_| HarnessError::Drift)?;
251                let mut required = tool_event("approval-required", &call_id, &call.name);
252                required.connector = Some(connector.clone());
253                required.risk = Some(reviewed.risk);
254                required.arguments = Some(redact_arguments(&arguments));
255                sink(AgentEvent::Tool(required))?;
256                let decision = if let Some(approver) = approver {
257                    tokio::select! { biased; _ = cancel.cancelled() => return Err(HarnessError::Cancelled), result = tokio::time::timeout(Duration::from_secs(120), approver.decide(&call_id, &reviewed, cancel)) => result.ok().and_then(Result::ok).unwrap_or(Decision::Deny) }
258                } else {
259                    Decision::Deny
260                };
261                approval = match decision {
262                    Decision::ApproveOnce => {
263                        Some(manager.approve(reviewed).map_err(|_| HarnessError::Drift)?)
264                    }
265                    Decision::AllowSession => Some(
266                        manager
267                            .approve_session(reviewed, grants)
268                            .map_err(|_| HarnessError::Drift)?,
269                    ),
270                    Decision::Deny => None,
271                };
272            }
273            if cancel.is_cancelled() {
274                return Err(HarnessError::Cancelled);
275            }
276            let content = if let (Some(approval), Some((connector, tool))) = (approval, route) {
277                sink(AgentEvent::Tool(tool_event("start", &call_id, &call.name)))?;
278                let started = Instant::now();
279                let result = manager
280                    .call(connector, &tool.name, arguments, Some(approval), cancel)
281                    .await;
282                if cancel.is_cancelled() {
283                    return Err(HarnessError::Cancelled);
284                }
285                let (content, is_error) = match result {
286                    Ok(result) => (feedback(&result.content), result.is_error),
287                    Err(_) => ("Tool execution failed.".into(), true),
288                };
289                let preview = redact_result(&content);
290                let mut event = tool_event("done", &call_id, &call.name);
291                event.result = Some(preview.text);
292                event.result_truncated = Some(preview.truncated);
293                event.is_error = Some(is_error);
294                event.duration_ms =
295                    Some(started.elapsed().as_millis().min(u64::MAX as u128) as u64);
296                sink(AgentEvent::Tool(event))?;
297                content
298            } else {
299                sink(AgentEvent::Tool(tool_event("denied", &call_id, &call.name)))?;
300                "The user denied this tool call.".into()
301            };
302            input.messages.push(ChatMessage {
303                role: "tool".into(),
304                content,
305                tool_calls: vec![],
306                tool_name: Some(call.name),
307            });
308        }
309    }
310    input.tools.clear();
311    let final_reply = model_step(chat, &input, cancel, sink, &mut output).await?;
312    if !final_reply.tool_calls.is_empty() {
313        return Err(HarnessError::Response);
314    }
315    Ok(output)
316}