1use std::future::Future;
21use std::pin::Pin;
22use std::sync::{Arc, Mutex};
23use std::task::{Context, Poll};
24use std::time::Duration;
25
26use futures::StreamExt;
27use tracing::Instrument;
28
29use crate::error::ProviderError;
30use crate::lock;
31use crate::streaming::{Item, Streamed};
32use crate::wasm_compat::{WasmBoxedFuture, WasmBoxedStream, WasmCompatSend, WasmCompatSync};
33use crate::wire::document::Reassemble;
34use crate::wire::{
35 Call, Capabilities, Decoder, Descriptor, Flow, Mode, Operation, Out, Request, Response, Shared,
36 Wire, WireEvent,
37};
38
39mod dyn_model;
40pub(crate) mod http_transport;
41mod local;
42
43pub use dyn_model::DynModel;
44pub use local::{Local, Step};
45
46#[derive(Clone, Debug, PartialEq)]
53pub struct Model<W, T = crate::http_client::DynHttpClient> {
54 pub wire: W,
56 pub transport: T,
58 prepared: crate::wire::Prepared,
60 idle_timeout: Option<Duration>,
62}
63
64pub const STREAM_IDLE_TIMEOUT: Duration = Duration::from_secs(300);
71
72impl<W: Default, T: Default> Default for Model<W, T> {
73 fn default() -> Self {
74 Self::new(W::default(), T::default())
75 }
76}
77
78impl<W, T> Model<W, T> {
79 pub fn new(wire: W, transport: T) -> Self {
82 Self {
83 wire,
84 transport,
85 prepared: crate::wire::Prepared::default(),
86 idle_timeout: Some(STREAM_IDLE_TIMEOUT),
87 }
88 }
89
90 pub fn with_idle_timeout(mut self, timeout: Option<Duration>) -> Self {
97 self.idle_timeout = timeout;
98 self
99 }
100}
101
102impl<W, T> Model<W, T>
103where
104 W: Wire<Op = crate::operation::Completion>,
105 T: Transport<W>,
106{
107 pub fn check(
130 &self,
131 request: &crate::completion::CompletionRequest,
132 ) -> Result<(), crate::completion::CheckError> {
133 check_with(request, |request| self.dry_run(request))
134 }
135}
136
137pub(crate) fn check_with(
143 request: &crate::completion::CompletionRequest,
144 run: impl FnOnce(crate::completion::CompletionRequest) -> Result<(), ProviderError>,
145) -> Result<(), crate::completion::CheckError> {
146 use crate::completion::{CheckError, OnUnsupported};
147 let mut request = without_messages(request);
148 if !request.options.is_default() {
149 request.options.on_unsupported = Some(OnUnsupported::Ignore);
150 }
151 match crate::completion::options::collect_refusals(|| run(request)) {
152 (Err(error), _) => Err(CheckError::Invalid(error)),
153 (Ok(()), refusals) if refusals.is_empty() => Ok(()),
154 (Ok(()), refusals) => Err(CheckError::Unsupported(refusals)),
155 }
156}
157
158pub(crate) fn without_messages(
161 request: &crate::completion::CompletionRequest,
162) -> crate::completion::CompletionRequest {
163 use crate::completion::{CompletionRequest, Message};
164 let CompletionRequest {
165 model,
166 chat_history,
167 documents,
168 tools,
169 temperature,
170 max_tokens,
171 tool_choice,
172 additional_params,
173 output_schema,
174 record_telemetry_content,
175 accept_unknown_finish_reasons,
176 foreign_reasoning,
177 options,
178 provider_options,
179 cache_points,
180 } = request;
181 let system = chat_history
182 .first()
183 .filter(|message| matches!(&***message, Message::System { .. }));
184 CompletionRequest {
185 model: model.clone(),
186 chat_history: system
187 .cloned()
188 .into_iter()
189 .chain([std::sync::Arc::new(Message::user("check"))])
190 .collect(),
191 documents: documents.clone(),
192 tools: tools.clone(),
193 temperature: *temperature,
194 max_tokens: *max_tokens,
195 tool_choice: tool_choice.clone(),
196 additional_params: additional_params.clone(),
197 output_schema: output_schema.clone(),
198 record_telemetry_content: *record_telemetry_content,
199 accept_unknown_finish_reasons: *accept_unknown_finish_reasons,
200 foreign_reasoning: *foreign_reasoning,
201 options: options.clone(),
202 provider_options: provider_options.clone(),
203 cache_points: cache_points.clone(),
204 }
205}
206
207pub trait Transport<W: Wire>: Clone + WasmCompatSend + WasmCompatSync + 'static {
214 fn send(&self, payload: W::Payload, exchange: Exchange) -> Opening<W::Frame>;
219}
220
221#[derive(Clone)]
223pub struct Exchange {
224 pub mode: Mode,
226 pub(crate) extensions: http::Extensions,
229}
230
231#[derive(Default)]
234pub(crate) struct Sending {
235 pub(crate) extensions: http::Extensions,
236}
237
238pub struct Opening<F> {
240 open: WasmBoxedFuture<'static, Result<Opened<F>, ProviderError>>,
241}
242
243impl<F: WasmCompatSend + 'static> Opening<F> {
244 pub fn new(
246 open: impl Future<Output = Result<Opened<F>, ProviderError>> + WasmCompatSend + 'static,
247 ) -> Self {
248 Self {
249 open: Box::pin(open),
250 }
251 }
252
253 pub fn ready(opened: Opened<F>) -> Self {
255 Self::new(std::future::ready(Ok(opened)))
256 }
257
258 pub fn failed(error: ProviderError) -> Self {
260 Self::new(std::future::ready(Err(error)))
261 }
262}
263
264impl<F> Future for Opening<F> {
265 type Output = Result<Opened<F>, ProviderError>;
266
267 fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
268 self.open.as_mut().poll(cx)
269 }
270}
271
272pub struct Opened<F> {
275 pub(crate) frames: WasmBoxedStream<'static, Result<F, ProviderError>>,
276 pub(crate) request_id: Option<String>,
277 pub(crate) status: Option<http::StatusCode>,
278 pub(crate) headers: Option<http::HeaderMap>,
279 pub(crate) route: Option<String>,
280 pub(crate) document: Option<serde_json::Value>,
281}
282
283impl<F: WasmCompatSend + 'static> Opened<F> {
284 pub fn new(
286 frames: impl futures::Stream<Item = Result<F, ProviderError>> + WasmCompatSend + 'static,
287 ) -> Self {
288 Self {
289 frames: Box::pin(frames),
290 request_id: None,
291 status: None,
292 headers: None,
293 route: None,
294 document: None,
295 }
296 }
297
298 pub fn failed(error: ProviderError) -> Self {
300 Self::new(futures::stream::once(async move { Err(error) }))
301 }
302
303 pub fn with_request_id(mut self, request_id: Option<String>) -> Self {
306 self.request_id = crate::provider_response::reported(request_id);
307 self
308 }
309
310 pub fn with_http(mut self, status: http::StatusCode, headers: http::HeaderMap) -> Self {
312 self.status = Some(status);
313 self.headers = Some(headers);
314 self
315 }
316
317 pub fn with_route(mut self, route: impl Into<String>) -> Self {
319 self.route = Some(route.into());
320 self
321 }
322
323 pub fn with_document(mut self, document: serde_json::Value) -> Self {
326 self.document = Some(document);
327 self
328 }
329
330 pub fn map_frames<S>(
333 mut self,
334 frames: impl FnOnce(WasmBoxedStream<'static, Result<F, ProviderError>>) -> S,
335 ) -> Self
336 where
337 S: futures::Stream<Item = Result<F, ProviderError>> + WasmCompatSend + 'static,
338 {
339 self.frames = Box::pin(frames(self.frames));
340 self
341 }
342}
343
344impl<W, T> Model<W, T>
345where
346 W: Wire,
347 T: Transport<W>,
348{
349 pub fn name(&self) -> &str {
351 self.wire.describe().name
352 }
353
354 pub fn id(&self) -> Option<&str> {
356 self.wire.describe().model
357 }
358
359 pub fn capabilities(&self) -> Capabilities {
362 self.wire.describe().capabilities
363 }
364
365 pub fn call(
370 &self,
371 request: impl Into<Request<W>>,
372 ) -> impl Future<Output = Result<Response<W>, ProviderError>> + WasmCompatSend + 'static {
373 self.finished(request.into(), Sending::default())
374 }
375
376 fn finished(
379 &self,
380 request: Request<W>,
381 sending: Sending,
382 ) -> impl Future<Output = Result<Response<W>, ProviderError>> + WasmCompatSend + 'static {
383 let model = self.clone();
384 async move { model.open(request, Mode::Unary, sending)?.finish().await }
385 }
386
387 pub fn stream(&self, request: impl Into<Request<W>>) -> Result<Streamed<W::Op>, ProviderError> {
391 self.open(request.into(), Mode::Streaming, Sending::default())
392 }
393
394 pub(crate) async fn call_routed(
397 &self,
398 request: Request<W>,
399 ) -> Result<Response<W>, (ProviderError, String)> {
400 self.open(request, Mode::Unary, Sending::default())
401 .map_err(|error| (error, String::new()))?
402 .finish_routed()
403 .await
404 }
405
406 pub(crate) fn dry_run(&self, request: Request<W>) -> Result<(), ProviderError> {
409 let describe = Descriptor {
410 prepared: Some(&self.prepared),
411 ..self.wire.describe()
412 };
413 let request = <W::Op as Operation>::prepare(request, &describe)?;
414 self.wire.encode(request, Mode::Unary)?;
415 Ok(())
416 }
417
418 pub(crate) fn open(
422 &self,
423 request: Request<W>,
424 mode: Mode,
425 sending: Sending,
426 ) -> Result<Streamed<W::Op>, ProviderError> {
427 let describe = Descriptor {
428 prepared: Some(&self.prepared),
429 ..self.wire.describe()
430 };
431 let request = <W::Op as Operation>::prepare(request, &describe)?;
432 let provider = describe.name.to_owned();
433 let mut call = Call::new(&describe, mode);
434 let fold = <W::Op as Operation>::fold(&request, &mut call);
435 let span = call.span;
436 let payload = self.wire.encode(request, mode)?;
437 let exchange = Exchange {
438 mode,
439 extensions: sending.extensions,
440 };
441 let opening = self.transport.send(payload, exchange);
442 let shared = Arc::new(Mutex::new(Shared::new(fold)));
443 let idle = match mode {
445 Mode::Streaming => self.idle_timeout,
446 Mode::Unary => None,
447 };
448 let reading = read(
449 self.wire.clone(),
450 opening,
451 Arc::clone(&shared),
452 span.clone(),
453 (mode, idle),
454 );
455 Ok(Streamed::new(reading, shared, span, provider))
456 }
457}
458
459fn read<W: Wire>(
470 wire: W,
471 opening: Opening<W::Frame>,
472 shared: Arc<Mutex<Shared<W::Op>>>,
473 span: tracing::Span,
474 (mode, idle): (Mode, Option<Duration>),
475) -> WasmBoxedStream<'static, ()> {
476 let decoding = span.clone();
477 let reading = async_stream::stream! {
478 let reply: &Mutex<Shared<W::Op>> = &shared;
479 let mut last_frame = web_time::Instant::now();
482 let opened = match mode {
484 Mode::Unary => opening.instrument(span.clone()).await,
485 Mode::Streaming => idle_within(idle, last_frame, opening)
486 .await
487 .and_then(|opened| opened),
488 };
489 let Opened {
490 mut frames,
491 request_id,
492 status,
493 headers,
494 route,
495 document,
496 } = match opened {
497 Ok(opened) => opened,
498 Err(error) => {
499 fail(reply, error);
500 return;
501 }
502 };
503 record_request_id(&span, request_id.as_deref());
504 let mut reassembler = document.is_none().then(|| wire.reassembler());
505 {
506 let mut state = lock(reply);
507 state.request_id.clone_from(&request_id);
508 state.document = document;
509 state.route = route.unwrap_or_default();
510 }
511 let enrich = |error: ProviderError| match mode {
512 Mode::Unary => error
514 .with_provider_status(status)
515 .with_provider_request_id(request_id.clone())
516 .with_response_headers(headers.clone()),
517 Mode::Streaming => error,
518 };
519 let mut decoder = wire.decoder();
520 loop {
521 let next = match idle_within(idle, last_frame, frames.next()).await {
522 Ok(next) => {
523 last_frame = web_time::Instant::now();
524 next
525 }
526 Err(stalled) => {
527 record(reply, reassembler.map(|document| document.finish()));
528 fail(reply, stalled);
529 return;
530 }
531 };
532 let flow = match next {
533 Some(Ok(frame)) => step(&mut decoder, reassembler.as_mut(), reply, frame),
534 Some(Err(error)) => {
535 record(reply, reassembler.map(|document| document.finish()));
536 fail(reply, error);
537 return;
538 }
539 None => eof(&mut decoder, reply),
540 };
541 match flow {
542 Ok(Flow::More) => yield (),
543 Ok(Flow::Ended(_)) => break,
544 Err(error) => {
545 record(reply, reassembler.map(|document| document.finish()));
546 fail(reply, enrich(error));
547 return;
548 }
549 }
550 }
551 record(reply, reassembler.map(|document| document.finish()));
552 {
553 let state = lock(reply);
554 if let Some(document) = state.raw.as_ref().or(state.document.as_ref()) {
555 crate::providers::internal::trace_json(
556 crate::providers::internal::LogTarget::Completions,
557 "reply",
558 document,
559 );
560 }
561 }
562 yield ();
563 };
564 let mut reading: WasmBoxedStream<'static, ()> = Box::pin(reading);
565 match mode {
566 Mode::Streaming => Box::pin(futures::stream::poll_fn(move |cx| {
568 let _decoding = decoding.enter();
569 reading.as_mut().poll_next(cx)
570 })),
571 Mode::Unary => reading,
572 }
573}
574
575const LONGEST_TIMER: Duration = Duration::from_millis(2_147_483_647);
578
579pub(crate) async fn idle_within<F: Future>(
584 idle: Option<Duration>,
585 since: web_time::Instant,
586 next: F,
587) -> Result<F::Output, ProviderError> {
588 let Some(idle) = idle.filter(|idle| *idle <= LONGEST_TIMER) else {
589 return Ok(next.await);
590 };
591 crate::wasm_compat::timeout(idle.saturating_sub(since.elapsed()), next)
592 .await
593 .map_err(|_| ProviderError::Stalled(idle))
594}
595
596pub(crate) struct Decoded<Op: Operation> {
599 #[cfg(any(test, feature = "test-utils"))]
601 pub(crate) items: Vec<Result<crate::streaming::Item<Op::Event>, ProviderError>>,
602 pub(crate) outcome: Result<Op::Response, ProviderError>,
603}
604
605pub(crate) fn triage<E>(event: WireEvent<E>) -> Result<Item<E>, ProviderError> {
610 match event {
611 WireEvent::Known(event) => Ok(Item::Event(event)),
612 WireEvent::Unknown { event_type, value } => {
613 warn_unmodeled(&event_type, &value);
614 Ok(Item::Unknown(value))
615 }
616 WireEvent::Corrupt(error) => Err(ProviderError::from(error)),
617 }
618}
619
620pub(crate) fn step<'id, Op, F, D, R>(
623 decoder: &mut D,
624 reassembler: Option<&mut R>,
625 reply: &'id Mutex<Shared<Op>>,
626 frame: F,
627) -> Result<Flow, ProviderError>
628where
629 Op: Operation,
630 D: Decoder<'id, Op, F>,
631 R: Reassemble<D::Event>,
632{
633 match triage(decoder.classify(frame))? {
634 Item::Event(event) => {
635 if let Some(reassembler) = reassembler {
636 reassembler.absorb(&event);
637 }
638 decoder.decode(event, Out::new(reply))
639 }
640 Item::Unknown(value) => {
641 Out::new(reply).unknown(value);
642 Ok(Flow::More)
643 }
644 }
645}
646
647fn eof<'id, Op, F, D>(decoder: &mut D, reply: &'id Mutex<Shared<Op>>) -> Result<Flow, ProviderError>
650where
651 Op: Operation,
652 D: Decoder<'id, Op, F>,
653{
654 match decoder.eof(Out::new(reply)) {
655 Ok(Flow::More) => Err(ProviderError::Truncated),
656 step => step,
657 }
658}
659
660pub(crate) fn feed<'id, Op, F, D, R>(
664 decoder: &mut D,
665 mut reassembler: Option<R>,
666 reply: &'id Mutex<Shared<Op>>,
667 frames: impl IntoIterator<Item = F>,
668) -> Result<(), ProviderError>
669where
670 Op: Operation,
671 D: Decoder<'id, Op, F>,
672 R: Reassemble<D::Event>,
673{
674 let feed_frames = || {
675 for frame in frames {
676 if let Flow::Ended(_) = step(decoder, reassembler.as_mut(), reply, frame)? {
677 return Ok(());
678 }
679 }
680 eof(decoder, reply).map(drop)
681 };
682 let fed = feed_frames();
683 record(reply, reassembler.map(|document| document.finish()));
684 fed
685}
686
687pub(crate) fn record<Op: Operation>(
690 reply: &Mutex<Shared<Op>>,
691 document: Option<serde_json::Value>,
692) {
693 if let Some(document) = document.filter(|document| !document.is_null()) {
694 lock(reply).raw = Some(document);
695 }
696}
697
698pub(crate) fn settle<Op: Operation>(
702 shared: Mutex<Shared<Op>>,
703 fed: Result<(), ProviderError>,
704 reply: crate::wire::Reply,
705) -> Decoded<Op> {
706 let mut shared = shared
707 .into_inner()
708 .unwrap_or_else(std::sync::PoisonError::into_inner);
709 if let Err(error) = fed {
710 shared.items.push_back(Err(error));
711 }
712 shared.document = Some(reply.raw).filter(|raw| !raw.is_null());
713 shared.request_id = reply.provider_request_id;
714 let mut items = Vec::new();
715 while let Some(item) = shared.take() {
716 let failed = item.is_err();
717 items.push(item);
718 if failed {
719 break;
720 }
721 }
722 let outcome = match items.last() {
723 Some(Err(error)) => Err(error.clone()),
724 _ => shared.conclude(&reply.provider),
725 };
726 #[cfg(any(test, feature = "test-utils"))]
727 if let Err(error) = &outcome
728 && !matches!(items.last(), Some(Err(_)))
729 {
730 items.push(Err(error.clone()));
731 }
732 Decoded {
733 #[cfg(any(test, feature = "test-utils"))]
734 items,
735 outcome,
736 }
737}
738
739pub(crate) fn decode_reply<W: Wire>(
743 wire: &W,
744 request: &Request<W>,
745 mode: Mode,
746 frames: impl IntoIterator<Item = W::Frame>,
747 raw: serde_json::Value,
748) -> Result<Response<W>, ProviderError> {
749 let describe = wire.describe();
750 let fold = <W::Op as Operation>::fold(request, &mut Call::new(&describe, mode));
751 let shared = Mutex::new(Shared::new(fold));
752 let fed = feed(
753 &mut wire.decoder(),
754 Some(wire.reassembler()),
755 &shared,
756 frames,
757 );
758 let reply = crate::wire::Reply {
759 provider: describe.name.to_owned(),
760 raw,
761 provider_request_id: None,
762 };
763 settle(shared, fed, reply).outcome
764}
765
766#[cfg(any(test, feature = "test-utils"))]
769pub(crate) fn relay_frames<W>(
770 wire: &W,
771 frames: impl IntoIterator<Item = W::Frame>,
772) -> crate::streaming::StreamEvents
773where
774 W: Wire<Op = crate::operation::Completion>,
775{
776 use crate::error::ErrorReport;
777 use crate::streaming::Relayed;
778
779 let provider = wire.describe().name.to_owned();
780 let shared = Mutex::new(Shared::new(crate::operation::ReplyFold::relayed(
781 provider.clone(),
782 )));
783 let fed = feed(
784 &mut wire.decoder(),
785 Some(wire.reassembler()),
786 &shared,
787 frames,
788 );
789 let decoded = settle(
790 shared,
791 fed,
792 crate::wire::Reply {
793 provider,
794 raw: serde_json::Value::Null,
795 provider_request_id: None,
796 },
797 );
798 let origin = decoded
799 .outcome
800 .as_ref()
801 .map(|response| response.origin.clone())
802 .ok();
803 let relayed: Vec<Result<Relayed, ErrorReport>> = origin
804 .map(|origin| Ok(Relayed::Origin(origin)))
805 .into_iter()
806 .chain(decoded.items.into_iter().map(|item| match item {
807 Ok(item) => Ok(Relayed::Item(item)),
808 Err(error) => Err(ErrorReport::from(&error)),
809 }))
810 .chain(
812 decoded
813 .outcome
814 .ok()
815 .map(|response| Ok(Relayed::Done(Arc::new(response)))),
816 )
817 .collect();
818 Box::pin(futures::stream::iter(relayed))
819}
820
821#[cfg(test)]
822impl Decoded<crate::operation::Completion> {
823 pub(crate) fn events(&self) -> Vec<&crate::streaming::StreamEvent> {
825 self.items
826 .iter()
827 .filter_map(|item| match item {
828 Ok(crate::streaming::Item::Event(event)) => Some(event),
829 _ => None,
830 })
831 .collect()
832 }
833
834 pub(crate) fn ended(&self) -> Vec<crate::message::AssistantContent> {
836 self.events()
837 .into_iter()
838 .filter_map(|event| match event {
839 crate::streaming::StreamEvent::End { content, .. } => Some(content.clone()),
840 _ => None,
841 })
842 .collect()
843 }
844}
845
846#[cfg(test)]
849macro_rules! decode_events {
850 ($decoder:expr, $provider:expr, $events:expr) => {
851 $crate::driver::decode_with(
852 $crate::operation::ReplyFold::relayed($provider),
853 $provider,
854 |reply| {
855 let mut decoder = $decoder;
856 for event in $events {
857 if let $crate::wire::Flow::Ended(_) =
858 $crate::wire::Decoder::decode(&mut decoder, event, reply.out())?
859 {
860 return Ok(());
861 }
862 }
863 match $crate::wire::Decoder::eof(&mut decoder, reply.out())? {
864 $crate::wire::Flow::Ended(_) => Ok(()),
865 $crate::wire::Flow::More => Err($crate::error::ProviderError::Truncated),
866 }
867 },
868 )
869 };
870}
871#[cfg(test)]
872pub(crate) use decode_events;
873
874#[cfg(test)]
879macro_rules! feed_frames {
880 ($decoder:expr, $provider:expr, $frames:expr) => {
881 $crate::driver::decode_with(
882 $crate::operation::ReplyFold::relayed($provider),
883 $provider,
884 |reply| {
885 let mut decoder = $decoder;
886 reply.feed(
887 &mut decoder,
888 None::<$crate::wire::document::Unreassembled>,
889 $frames,
890 )
891 },
892 )
893 };
894 ($decoder:expr, $reassembler:expr, $provider:expr, $frames:expr) => {
895 $crate::driver::decode_with(
896 $crate::operation::ReplyFold::relayed($provider),
897 $provider,
898 |reply| {
899 let mut decoder = $decoder;
900 reply.feed(&mut decoder, Some($reassembler), $frames)
901 },
902 )
903 };
904}
905#[cfg(test)]
906pub(crate) use feed_frames;
907
908#[cfg(test)]
910pub(crate) struct Replying<'id, Op: Operation>(&'id Mutex<Shared<Op>>);
911
912#[cfg(test)]
913impl<'id, Op: Operation> Replying<'id, Op> {
914 pub(crate) fn out(&self) -> Out<'id, Op> {
916 Out::new(self.0)
917 }
918
919 pub(crate) fn feed<F, D: Decoder<'id, Op, F>, R: Reassemble<D::Event>>(
921 &self,
922 decoder: &mut D,
923 reassembler: Option<R>,
924 frames: impl IntoIterator<Item = F>,
925 ) -> Result<(), ProviderError> {
926 feed(decoder, reassembler, self.0, frames)
927 }
928}
929
930#[cfg(test)]
934pub(crate) fn decode_with<Op: Operation>(
935 fold: Op::Fold,
936 provider: &str,
937 run: impl for<'id> FnOnce(Replying<'id, Op>) -> Result<(), ProviderError>,
938) -> Decoded<Op> {
939 let shared = Mutex::new(Shared::new(fold));
940 let fed = run(Replying(&shared));
941 settle(
942 shared,
943 fed,
944 crate::wire::Reply {
945 provider: provider.to_owned(),
946 raw: serde_json::Value::Null,
947 provider_request_id: None,
948 },
949 )
950}
951
952fn fail<Op: Operation>(reply: &Mutex<Shared<Op>>, error: ProviderError) {
954 lock(reply).items.push_back(Err(error));
955}
956
957pub(crate) async fn follow_cursors<P, Fut>(
961 provider: &str,
962 operation: &str,
963 mut page: impl FnMut(Option<String>) -> Fut,
964) -> Result<Vec<P>, ProviderError>
965where
966 Fut: Future<Output = Result<(P, Option<String>), ProviderError>>,
967{
968 let mut pages = Vec::new();
969 let mut cursor = None;
970 loop {
971 let (read, next) = page(cursor.clone()).await?;
972 pages.push(read);
973 let Some(next) = next else { break };
976 if cursor.as_deref() == Some(next.as_str()) {
977 tracing::warn!(
980 provider,
981 operation,
982 pages = pages.len(),
983 "listing repeated its pagination cursor; returning the pages fetched so far"
984 );
985 break;
986 }
987 if pages.len() >= MAX_CONTINUATION_PAGES {
988 tracing::warn!(
989 provider,
990 operation,
991 pages = pages.len(),
992 "listing hit its page ceiling with a cursor still advancing; returning the pages \
993 fetched so far"
994 );
995 break;
996 }
997 cursor = Some(next);
998 }
999 Ok(pages)
1000}
1001
1002pub fn warn_unmodeled(kind: &str, payload: &impl serde::Serialize) {
1005 tracing::warn!(
1006 kind,
1007 payload_bytes = crate::json_utils::json_len(payload),
1008 "skipping unmodeled wire payload"
1009 );
1010}
1011
1012const MAX_CONTINUATION_PAGES: usize = 1000;
1015
1016pub(crate) fn record_request_id(span: &tracing::Span, request_id: Option<&str>) {
1018 if let Some(request_id) = request_id
1019 && !span.is_disabled()
1020 {
1021 span.record(crate::telemetry::PROVIDER_REQUEST_ID_FIELD, request_id);
1022 }
1023}
1024
1025#[cfg(test)]
1026pub(crate) mod tests;