1use std::{
4 collections::VecDeque,
5 sync::{Arc, Mutex, MutexGuard},
6};
7
8use crate::driver::{Exchange, Model, Opened, Opening, Transport};
9use crate::error::{EncodeError, ProviderError};
10use crate::lock;
11use crate::operation::Completion;
12use crate::wire::{Capabilities, Descriptor, Mode, Wire};
13use crate::{
14 completion::{AssistantContent, CompletionRequest, CompletionResponse, Usage},
15 message::{ToolCall, ToolFunction},
16};
17
18use super::streaming::{MOCK_PROVIDER, MockDecoder, MockDocument, MockFrame, MockStreamEvent};
19
20#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
22pub enum MockError {
23 Provider(String),
25 Request(String),
27 ProviderResponse(crate::provider_response::ProviderResponseError),
29 Stalled(std::time::Duration),
31}
32
33impl MockError {
34 pub fn provider(message: impl Into<String>) -> Self {
36 Self::Provider(message.into())
37 }
38
39 pub fn request(message: impl Into<String>) -> Self {
41 Self::Request(message.into())
42 }
43
44 pub(crate) fn into_completion_error(self) -> ProviderError {
45 match self {
46 Self::Provider(message) => ProviderError::Provider(message),
47 Self::Request(message) => ProviderError::request(message),
48 Self::ProviderResponse(response) => ProviderError::ProviderResponse(response),
49 Self::Stalled(idle) => ProviderError::Stalled(idle),
50 }
51 }
52}
53
54#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
59pub struct MockTurn {
60 response: Result<MockTurnResponse, MockError>,
61}
62
63#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
64struct MockTurnResponse {
65 choice: Vec<AssistantContent>,
66 usage: Usage,
67 response_id: Option<String>,
68 provider_request_id: Option<String>,
69 finish_reason: Option<crate::completion::FinishReason>,
70 #[serde(
75 default,
76 skip_serializing_if = "Option::is_none",
77 deserialize_with = "deserialize_scripted_raw"
78 )]
79 raw: Option<serde_json::Value>,
80}
81
82fn deserialize_scripted_raw<'de, D: serde::Deserializer<'de>>(
83 deserializer: D,
84) -> Result<Option<serde_json::Value>, D::Error> {
85 serde::Deserialize::deserialize(deserializer).map(Some)
87}
88
89impl MockTurn {
90 pub fn text(text: impl Into<String>) -> Self {
92 Self::from_content(AssistantContent::text(text.into()))
93 }
94
95 pub fn tool_call(
98 id: impl Into<String>,
99 name: impl Into<String>,
100 arguments: serde_json::Value,
101 ) -> Self {
102 match crate::message::ToolName::new(name) {
103 Ok(name) => Self::from_content(AssistantContent::ToolCall(ToolCall::from_wire(
104 id,
105 ToolFunction::new(name, arguments),
106 ))),
107 Err(error) => Self::error(error.to_string()),
108 }
109 }
110
111 pub fn error(message: impl Into<String>) -> Self {
113 Self {
114 response: Err(MockError::provider(message)),
115 }
116 }
117
118 pub fn provider_response_error(
122 status: http::StatusCode,
123 body: impl Into<String>,
124 request_id: impl Into<String>,
125 ) -> Self {
126 Self {
127 response: Err(MockError::ProviderResponse(
128 crate::provider_response::ProviderResponseError::new(status, body)
129 .with_provider_request_id(Some(request_id.into())),
130 )),
131 }
132 }
133
134 pub fn request_error(message: impl Into<String>) -> Self {
136 Self {
137 response: Err(MockError::request(message)),
138 }
139 }
140
141 pub fn from_content(content: AssistantContent) -> Self {
143 Self {
144 response: Ok(MockTurnResponse {
145 choice: vec![content],
146 usage: Usage::default(),
147 response_id: None,
148 provider_request_id: None,
149 finish_reason: None,
150 raw: None,
151 }),
152 }
153 }
154
155 pub fn from_contents(content: impl IntoIterator<Item = AssistantContent>) -> Self {
160 Self {
161 response: Ok(MockTurnResponse {
162 choice: content.into_iter().collect(),
163 usage: Usage::default(),
164 response_id: None,
165 provider_request_id: None,
166 finish_reason: None,
167 raw: None,
168 }),
169 }
170 }
171
172 pub fn with_call_id(mut self, call_id: impl Into<String>) -> Self {
174 let call_id = call_id.into();
175 if let Ok(response) = &mut self.response {
176 for content in response.choice.iter_mut() {
177 if let AssistantContent::ToolCall(tool_call) = content {
178 tool_call.id = crate::message::CallId::from_wire(call_id);
179 break;
180 }
181 }
182 }
183 self
184 }
185
186 pub fn with_usage(mut self, usage: Usage) -> Self {
188 if let Ok(response) = &mut self.response {
189 response.usage = usage;
190 }
191 self
192 }
193
194 pub fn with_response_id(mut self, response_id: impl Into<String>) -> Self {
196 if let Ok(response) = &mut self.response {
197 response.response_id = Some(response_id.into());
198 }
199 self
200 }
201
202 pub fn with_provider_request_id(mut self, request_id: impl Into<String>) -> Self {
204 if let Ok(response) = &mut self.response {
205 response.provider_request_id = Some(request_id.into());
206 }
207 self
208 }
209
210 pub fn with_finish_reason(mut self, finish_reason: crate::completion::FinishReason) -> Self {
217 if let Ok(response) = &mut self.response {
218 response.finish_reason = Some(finish_reason);
219 }
220 self
221 }
222
223 pub fn raw(&self) -> Result<serde_json::Value, ProviderError> {
229 let response = self
230 .response
231 .as_ref()
232 .map_err(|error| error.clone().into_completion_error())?;
233 match &response.raw {
234 Some(raw) => Ok(raw.clone()),
235 None => Ok(serde_json::to_value(response)?),
236 }
237 }
238
239 fn into_completion_response(self) -> Result<CompletionResponse, ProviderError> {
240 let raw = self.raw()?;
241 let response = self.response.map_err(MockError::into_completion_error)?;
242 let mut origin = crate::message::Origin::new(MOCK_API, MOCK_PROVIDER, "");
243 origin.response_id = response.response_id;
244 let mut completion = CompletionResponse::new(response.choice, response.usage, origin, raw)
245 .with_optional_finish_reason(response.finish_reason);
246 completion.provider_request_id = response.provider_request_id;
247 Ok(completion)
248 }
249}
250
251#[derive(Default)]
252struct MockScriptState {
253 turns: Mutex<VecDeque<MockTurn>>,
254 stream_turns: Mutex<VecDeque<Vec<MockStreamEvent>>>,
255 requests: Mutex<Vec<CompletionRequest>>,
256}
257
258#[derive(Clone, Debug, PartialEq, Eq)]
263pub struct MockScript {
264 name: String,
265 id: Option<String>,
266 capabilities: Capabilities,
267 facts: crate::catalog::ModelFacts,
269}
270
271impl MockScript {
272 pub fn new(name: impl Into<String>) -> Self {
275 Self {
276 name: name.into(),
277 id: None,
278 capabilities: Capabilities::default(),
279 facts: crate::catalog::ModelFacts::default(),
280 }
281 }
282
283 pub fn with_id(mut self, id: impl Into<String>) -> Self {
285 self.id = Some(id.into());
286 self
287 }
288
289 pub fn with_capabilities(mut self, capabilities: Capabilities) -> Self {
291 self.capabilities = capabilities;
292 self
293 }
294
295 pub fn priced_as(self, spec: impl Into<std::sync::Arc<crate::catalog::ModelSpec>>) -> Self {
300 let spec = spec.into();
301 Self {
302 name: spec.provider.vendor().to_owned(),
303 id: Some(spec.id.clone()),
304 facts: crate::catalog::ModelFacts::new(spec),
305 ..self
306 }
307 }
308}
309
310pub const MOCK_API: crate::message::Api = crate::message::Api::from_static("mock.script");
312
313pub const MOCK_MODEL: &str = "mock-model";
315
316impl crate::completion::ReplayTarget for MockScript {
317 fn api(&self) -> crate::message::Api {
318 MOCK_API
319 }
320
321 fn map_options(
324 &self,
325 _request: &crate::completion::CompletionRequest,
326 fields: crate::completion::options::OptionFields<'_>,
327 ) -> crate::completion::options::OptionMap {
328 each_set(fields, || {
329 crate::completion::options::Mapping::Omit("a scripted reply ignores options")
330 })
331 }
332
333 fn states_finish_reason(&self) -> bool {
335 false
336 }
337
338 fn provider(&self) -> &str {
339 &self.name
340 }
341
342 fn model(&self) -> &str {
344 self.id.as_deref().unwrap_or(MOCK_MODEL)
345 }
346
347 fn accepts(&self, _model: &str) -> crate::completion::Accepts {
348 crate::completion::Accepts::ALL
349 }
350}
351
352impl Default for MockScript {
353 fn default() -> Self {
354 Self::new(MOCK_PROVIDER)
355 }
356}
357
358impl Wire for MockScript {
359 type Op = Completion;
360 type Payload = CompletionRequest;
361 type Frame = MockFrame;
362 type Event = MockFrame;
363 type Decoder<'id> = MockDecoder<'id>;
364 type Reassembler = MockDocument;
365
366 fn describe(&self) -> Descriptor<'_> {
367 Descriptor::new(&self.name)
368 .model(self.id.as_deref())
369 .capabilities(self.capabilities)
370 .facts(&self.facts)
371 .replay(self)
372 }
373
374 fn encode(
377 &self,
378 request: CompletionRequest,
379 _mode: Mode,
380 ) -> Result<CompletionRequest, EncodeError> {
381 Ok(request)
382 }
383
384 fn decoder<'id>(&self) -> MockDecoder<'id> {
385 MockDecoder::default()
386 }
387}
388
389#[derive(Clone, Default)]
396pub struct MockRuntime {
397 state: Arc<MockScriptState>,
398}
399
400pub type MockCompletionModel = Model<MockScript, MockRuntime>;
403
404impl MockCompletionModel {
405 pub fn text(text: impl Into<String>) -> Self {
407 Self::from_turns([MockTurn::text(text)])
408 }
409
410 pub fn from_turns(turns: impl IntoIterator<Item = MockTurn>) -> Self {
412 Self::scripted(turns.into_iter().collect(), VecDeque::new())
413 }
414
415 pub fn from_stream_turns(
417 stream_turns: impl IntoIterator<Item = impl IntoIterator<Item = MockStreamEvent>>,
418 ) -> Self {
419 Self::scripted(
420 VecDeque::new(),
421 stream_turns
422 .into_iter()
423 .map(|turn| turn.into_iter().collect())
424 .collect(),
425 )
426 }
427
428 fn scripted(turns: VecDeque<MockTurn>, stream_turns: VecDeque<Vec<MockStreamEvent>>) -> Self {
429 Model::new(
430 MockScript::default(),
431 MockRuntime {
432 state: Arc::new(MockScriptState {
433 turns: Mutex::new(turns),
434 stream_turns: Mutex::new(stream_turns),
435 requests: Mutex::new(Vec::new()),
436 }),
437 },
438 )
439 }
440
441 pub fn priced_as(mut self, spec: impl Into<std::sync::Arc<crate::catalog::ModelSpec>>) -> Self {
445 self.wire = self.wire.priced_as(spec);
446 self
447 }
448
449 pub fn requests(&self) -> Vec<CompletionRequest> {
451 self.transport.requests_guard().clone()
452 }
453
454 pub fn request_count(&self) -> usize {
456 self.transport.requests_guard().len()
457 }
458
459 pub fn script(&self) -> Vec<MockTurn> {
462 lock(&self.transport.state.turns).iter().cloned().collect()
463 }
464}
465
466impl MockRuntime {
467 fn requests_guard(&self) -> MutexGuard<'_, Vec<CompletionRequest>> {
468 lock(&self.state.requests)
469 }
470}
471
472impl Transport<MockScript> for MockRuntime {
473 fn send(&self, request: CompletionRequest, exchange: Exchange) -> Opening<MockFrame> {
474 let mode = exchange.mode;
475 self.requests_guard().push(request);
476 match mode {
477 Mode::Unary => {
480 let Some(turn) = lock(&self.state.turns).pop_front() else {
481 return Opening::failed(ProviderError::Provider(
482 "mock completion model has no scripted completion turn".to_string(),
483 ));
484 };
485 match turn.into_completion_response() {
486 Ok(response) => {
487 let document = response.raw.clone();
488 let request_id = response.provider_request_id.clone();
489 Opening::ready(
490 Opened::new(futures::stream::iter([Ok(MockFrame::Response(
491 Box::new(response),
492 ))]))
493 .with_document(document)
494 .with_request_id(request_id),
495 )
496 }
497 Err(error) => Opening::ready(Opened::failed(error)),
498 }
499 }
500 Mode::Streaming => {
501 let Some(turn) = lock(&self.state.stream_turns).pop_front() else {
502 return Opening::failed(ProviderError::Provider(
503 "mock completion model has no scripted streaming turn".to_string(),
504 ));
505 };
506 let request_id = turn.iter().find_map(|event| match event {
507 MockStreamEvent::RequestId(id) => Some(id.clone()),
508 _ => None,
509 });
510 Opening::ready(
511 Opened::new(futures::stream::iter(
512 turn.into_iter()
513 .filter(|event| !matches!(event, MockStreamEvent::RequestId(_)))
514 .map(|event| Ok(MockFrame::Event(event))),
515 ))
516 .with_request_id(request_id),
517 )
518 }
519 }
520 }
521}
522
523#[cfg(test)]
524mod tests;
525
526pub fn refuse_options(
528 fields: crate::completion::options::OptionFields<'_>,
529) -> crate::completion::options::OptionMap {
530 each_set(fields, || {
531 crate::completion::options::Mapping::unsupported("the test target takes no options")
532 })
533}
534
535fn each_set(
537 fields: crate::completion::options::OptionFields<'_>,
538 answer: impl Fn() -> crate::completion::options::Mapping,
539) -> crate::completion::options::OptionMap {
540 use crate::completion::options::{Mapping, OptionMap, OptionName};
541 let each = |option| match fields.is_set(option) {
542 true => answer(),
543 false => Mapping::Nothing,
544 };
545 OptionMap {
546 reasoning: each(OptionName::Reasoning),
547 cache: each(OptionName::Cache),
548 service_tier: each(OptionName::ServiceTier),
549 verbosity: each(OptionName::Verbosity),
550 parallel_tool_calls: each(OptionName::ParallelToolCalls),
551 top_p: each(OptionName::TopP),
552 seed: each(OptionName::Seed),
553 stop: each(OptionName::Stop),
554 cache_key: Mapping::unrouted(fields.cache_key),
555 }
556}