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