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    };
193    let mut output = String::new();
194    let mut call_count = 0usize;
195    for _ in 0..options.max_steps {
196        let result = model_step(chat, &input, cancel, sink, &mut output).await?;
197        if result.tool_calls.is_empty() {
198            return Ok(output);
199        }
200        input.messages.push(ChatMessage {
201            role: "assistant".into(),
202            content: result.content,
203            tool_calls: result.tool_calls.clone(),
204            tool_name: None,
205        });
206        for call in result.tool_calls {
207            if cancel.is_cancelled() {
208                return Err(HarnessError::Cancelled);
209            }
210            call_count += 1;
211            if call_count > 64 {
212                return Err(HarnessError::Limit);
213            }
214            let call_id = uuid::Uuid::new_v4().to_string();
215            let arguments =
216                serde_json::to_value(&call.arguments).map_err(|_| HarnessError::Invalid)?;
217            if serde_json::to_vec(&arguments)
218                .map_err(|_| HarnessError::Invalid)?
219                .len()
220                > 65536
221            {
222                return Err(HarnessError::Limit);
223            }
224            let route = routing.get(&call.name);
225            let reviewed = route.and_then(|(connector, tool)| {
226                manager
227                    .review(connector, &tool.name, arguments.clone())
228                    .ok()
229            });
230            let mut proposed = tool_event("proposed", &call_id, &call.name);
231            proposed.connector = route.map(|(connector, _)| connector.clone());
232            proposed.risk = Some(
233                reviewed
234                    .as_ref()
235                    .map(|review| review.risk)
236                    .unwrap_or(ToolRisk::Unknown),
237            );
238            proposed.arguments = Some(redact_arguments(&arguments));
239            sink(AgentEvent::Tool(proposed))?;
240            let mut approval = None;
241            if let Some(reviewed) = reviewed {
242                approval = manager.session_approval(reviewed, grants).ok();
243            }
244            if approval.is_none()
245                && let Some((connector, tool)) = route
246            {
247                let reviewed = manager
248                    .review(connector, &tool.name, arguments.clone())
249                    .map_err(|_| HarnessError::Drift)?;
250                let mut required = tool_event("approval-required", &call_id, &call.name);
251                required.connector = Some(connector.clone());
252                required.risk = Some(reviewed.risk);
253                required.arguments = Some(redact_arguments(&arguments));
254                sink(AgentEvent::Tool(required))?;
255                let decision = if let Some(approver) = approver {
256                    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) }
257                } else {
258                    Decision::Deny
259                };
260                approval = match decision {
261                    Decision::ApproveOnce => {
262                        Some(manager.approve(reviewed).map_err(|_| HarnessError::Drift)?)
263                    }
264                    Decision::AllowSession => Some(
265                        manager
266                            .approve_session(reviewed, grants)
267                            .map_err(|_| HarnessError::Drift)?,
268                    ),
269                    Decision::Deny => None,
270                };
271            }
272            if cancel.is_cancelled() {
273                return Err(HarnessError::Cancelled);
274            }
275            let content = if let (Some(approval), Some((connector, tool))) = (approval, route) {
276                sink(AgentEvent::Tool(tool_event("start", &call_id, &call.name)))?;
277                let started = Instant::now();
278                let result = manager
279                    .call(connector, &tool.name, arguments, Some(approval), cancel)
280                    .await;
281                if cancel.is_cancelled() {
282                    return Err(HarnessError::Cancelled);
283                }
284                let (content, is_error) = match result {
285                    Ok(result) => (feedback(&result.content), result.is_error),
286                    Err(_) => ("Tool execution failed.".into(), true),
287                };
288                let preview = redact_result(&content);
289                let mut event = tool_event("done", &call_id, &call.name);
290                event.result = Some(preview.text);
291                event.result_truncated = Some(preview.truncated);
292                event.is_error = Some(is_error);
293                event.duration_ms =
294                    Some(started.elapsed().as_millis().min(u64::MAX as u128) as u64);
295                sink(AgentEvent::Tool(event))?;
296                content
297            } else {
298                sink(AgentEvent::Tool(tool_event("denied", &call_id, &call.name)))?;
299                "The user denied this tool call.".into()
300            };
301            input.messages.push(ChatMessage {
302                role: "tool".into(),
303                content,
304                tool_calls: vec![],
305                tool_name: Some(call.name),
306            });
307        }
308    }
309    input.tools.clear();
310    let final_reply = model_step(chat, &input, cancel, sink, &mut output).await?;
311    if !final_reply.tool_calls.is_empty() {
312        return Err(HarnessError::Response);
313    }
314    Ok(output)
315}