session_core/
request_keys.rs1use agent::StreamFn;
13use ai::http::BoxFuture;
14use ai::retry::RetryPolicy;
15use ai::{AssistantMessage, EventSink, Model, SimpleStreamOptions, TranscriptContext};
16use std::pin::pin;
17use std::sync::Arc;
18use std::task::Poll;
19
20pub type ProviderCredentials = Arc<dyn Fn(&str) -> Option<String> + Send + Sync>;
22
23#[derive(Clone)]
24pub struct Keys {
25 runtime: Option<(String, String)>,
27 resolve: ProviderCredentials,
28}
29
30impl Keys {
31 pub fn new(runtime: Option<(String, String)>, resolve: ProviderCredentials) -> Keys {
33 Keys { runtime, resolve }
34 }
35
36 pub fn session(api_key: Option<String>, provider: &str, env: &crate::RunEnv) -> Keys {
39 let env = env.clone();
40 Keys::new(
41 api_key.map(|key| (provider.to_string(), key)),
42 Arc::new(move |provider: &str| crate::lane::api_key(&crate::ModelFlags::default(), &env, provider)),
43 )
44 }
45
46 pub fn key(&self, provider: &str) -> Option<String> {
48 match &self.runtime {
49 Some((runtime, key)) if runtime == provider => Some(key.clone()),
50 _ => (self.resolve)(provider),
51 }
52 }
53
54 pub fn request_key(&self, provider: &str) -> Option<String> {
56 self.key(provider).filter(|key| key != ai::env::AMBIENT_CREDENTIALS)
57 }
58
59 pub fn request_keys(&self) -> ProviderCredentials {
61 let keys = self.clone();
62 Arc::new(move |provider: &str| keys.request_key(provider))
63 }
64}
65
66pub struct Keyed<S> {
68 pub inner: S,
69 pub keys: Keys,
70}
71
72impl<S: StreamFn> StreamFn for Keyed<S> {
73 fn stream<'a>(
74 &'a self,
75 model: &'a Model,
76 context: &'a TranscriptContext,
77 options: &'a SimpleStreamOptions,
78 sink: &'a mut EventSink<'_>,
79 ) -> BoxFuture<'a, AssistantMessage> {
80 Box::pin(async move {
81 if options.base.api_key.is_some() {
82 return self.inner.stream(model, context, options, sink).await;
83 }
84 let mut keyed = options.clone();
85 keyed.base.api_key = self.keys.request_key(&model.provider);
86 self.inner.stream(model, context, &keyed, sink).await
87 })
88 }
89}
90
91pub type RetrySource = Arc<dyn Fn() -> RetryPolicy + Send + Sync>;
93
94pub fn retry_policy(settings: &config::settings::SettingsManager) -> RetryPolicy {
97 let retry = settings
98 .settings()
99 .get("retry")
100 .cloned()
101 .unwrap_or(serde_json::Value::Null);
102 RetryPolicy::from_settings(&retry, true)
103}
104
105pub struct Retrying<S> {
108 pub inner: S,
109 pub policy: RetrySource,
110}
111
112impl<S: StreamFn> StreamFn for Retrying<S> {
113 fn stream<'a>(
114 &'a self,
115 model: &'a Model,
116 context: &'a TranscriptContext,
117 options: &'a SimpleStreamOptions,
118 sink: &'a mut EventSink<'_>,
119 ) -> BoxFuture<'a, AssistantMessage> {
120 Box::pin(async move {
121 let policy = (self.policy)();
122 let mut attempt = 0;
123 loop {
124 let message = self.inner.stream(model, context, options, sink).await;
125 let aborted = options.base.signal.as_ref().is_some_and(ai::AbortSignal::aborted);
126 if aborted || !policy.enabled || attempt >= policy.max_retries || !ai::retry::is_retryable(&message) {
127 return message;
128 }
129 attempt += 1;
130 let delay = std::time::Duration::from_millis(policy.delay_ms(attempt));
131 if !wait(delay, options.base.signal.as_ref()).await {
132 return message;
133 }
134 }
135 })
136 }
137}
138
139async fn wait(delay: std::time::Duration, signal: Option<&ai::AbortSignal>) -> bool {
141 let Some(signal) = signal else {
142 tokio::time::sleep(delay).await;
143 return true;
144 };
145 let mut sleep = pin!(tokio::time::sleep(delay));
146 let mut cancelled = pin!(signal.cancelled());
147 std::future::poll_fn(|cx| {
148 if cancelled.as_mut().poll(cx).is_ready() {
149 return Poll::Ready(false);
150 }
151 match sleep.as_mut().poll(cx) {
152 Poll::Ready(()) => Poll::Ready(true),
153 Poll::Pending => Poll::Pending,
154 }
155 })
156 .await
157}
158
159pub fn lane_stream(settings: crate::lane::SettingsReader, keys: Keys) -> Arc<dyn StreamFn> {
163 let reader = settings.clone();
164 Arc::new(Retrying {
165 inner: Keyed {
166 inner: crate::lane::Provider::new().with_live_settings(settings),
167 keys,
168 },
169 policy: Arc::new(move || retry_policy(&reader())),
170 })
171}