Skip to main content

mutil_ai/adapter/
endpoint.rs

1use crate::security::RequestBudget;
2use async_trait::async_trait;
3use reqwest::header::{AUTHORIZATION, HeaderMap, HeaderName, HeaderValue};
4use serde_json::json;
5
6use super::anthropic::{
7    AnthropicStreamMapper, from_anthropic_response, to_anthropic_body, validate_anthropic_request,
8};
9use super::gemini::{
10    GeminiStreamMapper, from_gemini_response, to_gemini_body, validate_gemini_request,
11};
12use super::openai_chat::{
13    OpenAiChatStreamMapper, from_openai_chat_response_with_aliases,
14    to_openai_chat_body_with_profile,
15};
16use super::openai_responses::{
17    ResponsesStreamMapper, from_responses_response, to_responses_body, validate_responses_request,
18};
19use super::{
20    ModelAdapter, ReconnectRequest, ReconnectRequestParts, apply_provider_request_options,
21    apply_request_transform, audit_outcome_for_error, completion_report,
22    effective_provider_request_options, effective_retry_policy, finish_sse_stream, json_body_bytes,
23    merge_extra_body, prepare_headers, protocol_name, send_json_retry, send_stream_retry,
24    validate_profile_selector,
25};
26use crate::audit::{AuditContext, ProfileAuditSnapshot};
27use crate::error::{Error, Result};
28use crate::headers::{RequestOptions, TransportConfig};
29use crate::normalize::{NormalizeReport, Protocol};
30use crate::profile::{
31    AuthStyle, Capabilities, EndpointSpec, ModelProfile, ReasoningAliases, ReasoningReplayPolicy,
32};
33use crate::report::CompletionReport;
34use crate::retry::{RetryPolicy, RetryProvider};
35use crate::stream::ModelStream;
36use crate::types::{ChatRequest, ChatResponse, Part, ResponseMetadata};
37
38const ANTHROPIC_VERSION: &str = "2023-06-01";
39
40fn auth_transport(mut transport: TransportConfig, auth: &AuthStyle) -> TransportConfig {
41    if let AuthStyle::XApiKey { header } | AuthStyle::Custom { header, .. } = auth {
42        transport.header_policy = transport.header_policy.protect(header.clone());
43    }
44    transport
45}
46
47/// A protocol-dispatching adapter for explicitly configured endpoints.
48///
49/// The caller selects the protocol, path, and auth through [`EndpointSpec`].
50/// The adapter never infers them from a base URL.
51pub struct EndpointAdapter {
52    model: String,
53    endpoint: EndpointSpec,
54    provider_profile: Option<crate::profile::ProviderProfile>,
55    api_key: Option<String>,
56    api_key_env: Option<String>,
57    model_profiles: Vec<ModelProfile>,
58    retry_policy: RetryPolicy,
59    transport: TransportConfig,
60    client: reqwest::Client,
61}
62
63/// Backwards-compatible name for the OpenAI Chat-focused first iteration.
64///
65/// New code should prefer [`EndpointAdapter`] because it also dispatches
66/// Responses, Anthropic Messages, and Gemini generateContent.
67pub type OpenAICompatible = EndpointAdapter;
68
69impl EndpointAdapter {
70    /// Create an adapter for the given model and endpoint specification.
71    ///
72    /// The [`EndpointSpec`] selects the wire protocol (OpenAI Chat,
73    /// OpenAI Responses, Anthropic Messages, or Gemini generateContent),
74    /// the request path, and the auth style.
75    pub fn new(model: impl Into<String>, endpoint: EndpointSpec) -> Self {
76        let provider_profile = endpoint.resolved_profile();
77        let transport = auth_transport(TransportConfig::default(), &endpoint.auth);
78        Self {
79            model: model.into(),
80            endpoint,
81            provider_profile,
82            api_key: None,
83            api_key_env: None,
84            model_profiles: Vec::new(),
85            retry_policy: RetryPolicy::default(),
86            transport,
87            client: super::secure_http_client(),
88        }
89    }
90
91    /// Set an explicit API key, taking precedence over the environment.
92    pub fn api_key(mut self, api_key: impl Into<String>) -> Self {
93        self.api_key = Some(api_key.into());
94        self
95    }
96
97    /// Read the API key from the given environment variable at request time.
98    pub fn api_key_from_env(mut self, env_name: impl Into<String>) -> Self {
99        self.api_key_env = Some(env_name.into());
100        self
101    }
102
103    /// Override the retry policy used for failed requests.
104    pub fn retry_policy(mut self, retry_policy: RetryPolicy) -> Self {
105        self.retry_policy = retry_policy;
106        self
107    }
108
109    /// Configure transport-level settings (timeouts, proxies, audit hooks).
110    pub fn transport(mut self, transport: TransportConfig) -> Self {
111        self.transport = auth_transport(transport, &self.endpoint.auth);
112        self
113    }
114
115    /// Add a model-level profile. The first matching profile wins.
116    pub fn model_profile(mut self, profile: ModelProfile) -> Self {
117        self.model_profiles.push(profile);
118        self
119    }
120
121    /// Add multiple model-level profiles. The first matching profile wins.
122    pub fn model_profiles(mut self, profiles: impl IntoIterator<Item = ModelProfile>) -> Self {
123        self.model_profiles.extend(profiles);
124        self
125    }
126
127    /// The endpoint specification this adapter dispatches to.
128    pub fn endpoint(&self) -> &EndpointSpec {
129        &self.endpoint
130    }
131
132    fn ensure_supported(&self) -> Result<()> {
133        validate_profile_selector(&self.endpoint.profile)
134    }
135
136    fn selected_model_profile(&self) -> Option<&ModelProfile> {
137        self.model_profiles
138            .iter()
139            .find(|profile| profile.matches(&self.model))
140    }
141
142    fn capabilities(&self) -> Capabilities {
143        self.selected_model_profile()
144            .and_then(|profile| profile.capabilities.clone())
145            .or_else(|| {
146                self.provider_profile
147                    .as_ref()
148                    .map(|profile| profile.capabilities.clone())
149            })
150            .unwrap_or_default()
151    }
152
153    fn audit_profile_snapshot(&self) -> ProfileAuditSnapshot {
154        ProfileAuditSnapshot {
155            provider_profile_id: self
156                .provider_profile
157                .as_ref()
158                .map(|profile| profile.id.to_string()),
159            model_profile_selected: self.selected_model_profile().is_some(),
160            capabilities: Some(self.capabilities()),
161        }
162    }
163
164    fn reasoning_aliases(&self) -> ReasoningAliases {
165        self.selected_model_profile()
166            .filter(|profile| !profile.reasoning_aliases.is_empty())
167            .map(|profile| profile.reasoning_aliases.clone())
168            .or_else(|| {
169                self.provider_profile
170                    .as_ref()
171                    .map(|profile| profile.reasoning.aliases.clone())
172            })
173            .unwrap_or_default()
174    }
175
176    fn reasoning_replay_policy(&self) -> ReasoningReplayPolicy {
177        self.selected_model_profile()
178            .and_then(|profile| profile.replay)
179            .or_else(|| {
180                self.provider_profile
181                    .as_ref()
182                    .map(|profile| profile.reasoning.replay)
183            })
184            .unwrap_or(ReasoningReplayPolicy::SameProvider)
185    }
186
187    fn ensure_request_supported(&self, request: &ChatRequest, streaming: bool) -> Result<()> {
188        let capabilities = self.capabilities();
189
190        if request.reasoning.is_some() && !capabilities.reasoning.supported {
191            return Err(Error::Unsupported(
192                "reasoning is disabled by the selected profile".to_string(),
193            ));
194        }
195        if let Some(reasoning) = &request.reasoning {
196            if reasoning.summary.is_some() && !capabilities.reasoning.summary {
197                return Err(Error::Unsupported(
198                    "reasoning summaries are disabled by the selected profile".to_string(),
199                ));
200            }
201            if reasoning.include_text == Some(true) && !capabilities.reasoning.text {
202                return Err(Error::Unsupported(
203                    "readable reasoning text is disabled by the selected profile".to_string(),
204                ));
205            }
206            if reasoning.include_encrypted == Some(true) && !capabilities.reasoning.encrypted {
207                return Err(Error::Unsupported(
208                    "encrypted reasoning is disabled by the selected profile".to_string(),
209                ));
210            }
211        }
212
213        let expected_state = self.endpoint.protocol.provider_state_format();
214        let has_replay_state = request.messages.iter().any(|message| {
215            message.parts.iter().any(|part| match part {
216                Part::Reasoning(reasoning) => reasoning
217                    .state
218                    .as_ref()
219                    .is_some_and(|state| state.format == expected_state),
220                Part::Text { provider_state, .. } => provider_state
221                    .as_ref()
222                    .is_some_and(|state| state.format == expected_state),
223                Part::ToolCall(call) => call
224                    .provider_state
225                    .as_ref()
226                    .is_some_and(|state| state.format == expected_state),
227                _ => false,
228            })
229        });
230        if has_replay_state {
231            let policy = self.reasoning_replay_policy();
232            if self.endpoint.protocol != Protocol::OpenAiChat
233                && !matches!(
234                    policy,
235                    ReasoningReplayPolicy::SameProvider
236                        | ReasoningReplayPolicy::PreserveInHistory
237                        | ReasoningReplayPolicy::ModelDefined
238                )
239            {
240                return Err(Error::Unsupported(format!(
241                    "replay policy {policy:?} is not implemented for {:?}",
242                    self.endpoint.protocol
243                )));
244            }
245            if !capabilities.reasoning.replay
246                && !(self.endpoint.protocol == Protocol::OpenAiChat
247                    && policy == ReasoningReplayPolicy::Never)
248            {
249                return Err(Error::Unsupported(
250                    "reasoning replay is disabled by the selected profile".to_string(),
251                ));
252            }
253        }
254
255        if !request.tools.is_empty() && !capabilities.tools.supported {
256            return Err(Error::Unsupported(
257                "tool calling is disabled by the selected profile".to_string(),
258            ));
259        }
260        if !request.server_tools.is_empty() {
261            if !capabilities.server_side_state {
262                return Err(Error::Unsupported(
263                    "server-side tools are disabled by the selected profile".to_string(),
264                ));
265            }
266            if self.endpoint.protocol != Protocol::OpenAiResponses {
267                return Err(Error::Unsupported(
268                    "the selected protocol does not implement generic server-side tools"
269                        .to_string(),
270                ));
271            }
272        }
273        if request.tool_choice.is_some() && !capabilities.tool_choice {
274            return Err(Error::Unsupported(
275                "tool choice is disabled by the selected profile".to_string(),
276            ));
277        }
278        if request.response_format.is_some() && !capabilities.structured_output {
279            return Err(Error::Unsupported(
280                "structured output is disabled by the selected profile".to_string(),
281            ));
282        }
283        if request.seed.is_some() && !capabilities.seed {
284            return Err(Error::Unsupported(
285                "seed is disabled by the selected profile".to_string(),
286            ));
287        }
288        if !request.stop.is_empty() && !capabilities.stop {
289            return Err(Error::Unsupported(
290                "stop sequences are disabled by the selected profile".to_string(),
291            ));
292        }
293        if streaming && !request.tools.is_empty() && !capabilities.tools.streaming {
294            return Err(Error::Unsupported(
295                "streaming tool calls are disabled by the selected profile".to_string(),
296            ));
297        }
298        if streaming && !capabilities.streaming.supported {
299            return Err(Error::Unsupported(
300                "streaming is disabled by the selected profile".to_string(),
301            ));
302        }
303        if !capabilities.multimodal
304            && request.messages.iter().any(|message| {
305                message
306                    .parts
307                    .iter()
308                    .any(|part| matches!(part, Part::ImageUrl { .. }))
309            })
310        {
311            return Err(Error::Unsupported(
312                "multimodal input is disabled by the selected profile".to_string(),
313            ));
314        }
315
316        Ok(())
317    }
318
319    fn resolve_api_key(&self) -> Result<Option<String>> {
320        if self.endpoint.auth == AuthStyle::None {
321            return Ok(None);
322        }
323
324        if let Some(key) = &self.api_key
325            && !key.trim().is_empty()
326        {
327            return Ok(Some(key.clone()));
328        }
329
330        if let Some(env_name) = &self.api_key_env
331            && let Ok(key) = std::env::var(env_name)
332            && !key.trim().is_empty()
333        {
334            return Ok(Some(key));
335        }
336
337        Err(Error::MissingApiKey(
338            self.api_key_env
339                .clone()
340                .unwrap_or_else(|| "generic endpoint API key".to_string()),
341        ))
342    }
343
344    async fn request_parts(
345        &self,
346        options: &RequestOptions,
347        streaming: bool,
348    ) -> Result<(HeaderMap, Vec<(String, String)>)> {
349        self.ensure_supported()?;
350        let profile = self.provider_profile.as_ref();
351        let key = self.resolve_api_key()?;
352
353        let mut headers = profile
354            .map(|profile| profile.request.extra_headers.clone())
355            .unwrap_or_default();
356        let mut query = profile
357            .map(|profile| profile.request.extra_query.clone())
358            .unwrap_or_default();
359        query.extend(options.extra_query.iter().cloned());
360
361        let reserved_query: &[&str] = match self.endpoint.protocol {
362            Protocol::GeminiGenerateContent => &["key", "alt"],
363            _ => &[],
364        };
365        for (name, _) in &query {
366            if reserved_query.contains(&name.as_str())
367                || matches!(&self.endpoint.auth, AuthStyle::QueryKey { parameter } if name == parameter)
368            {
369                return Err(Error::ReservedExtraQuery {
370                    protocol: protocol_name(self.endpoint.protocol),
371                    parameter: name.clone(),
372                });
373            }
374        }
375
376        if let Some(key) = key {
377            match &self.endpoint.auth {
378                AuthStyle::Bearer => {
379                    headers.insert(
380                        AUTHORIZATION,
381                        HeaderValue::from_str(&format!("Bearer {key}"))?,
382                    );
383                }
384                AuthStyle::XApiKey { header } => {
385                    headers.insert(header.clone(), HeaderValue::from_str(&key)?);
386                }
387                AuthStyle::QueryKey { parameter } => {
388                    query.push((parameter.clone(), key));
389                }
390                AuthStyle::Custom {
391                    header,
392                    value_prefix,
393                } => {
394                    let value = format!("{}{key}", value_prefix.as_deref().unwrap_or_default());
395                    headers.insert(header.clone(), HeaderValue::from_str(&value)?);
396                }
397                AuthStyle::None => {}
398            }
399        }
400
401        if self.endpoint.protocol == Protocol::AnthropicMessages {
402            headers
403                .entry(HeaderName::from_static("anthropic-version"))
404                .or_insert_with(|| HeaderValue::from_static(ANTHROPIC_VERSION));
405        }
406
407        if streaming && self.endpoint.protocol == Protocol::GeminiGenerateContent {
408            query.push(("alt".to_string(), "sse".to_string()));
409        }
410
411        Ok((headers, query))
412    }
413
414    #[cfg(test)]
415    fn build_body(
416        &self,
417        request: &ChatRequest,
418        streaming: bool,
419    ) -> Result<(serde_json::Value, NormalizeReport)> {
420        self.build_body_with_options(request, streaming, &RequestOptions::default())
421    }
422
423    fn build_body_with_options(
424        &self,
425        request: &ChatRequest,
426        streaming: bool,
427        options: &RequestOptions,
428    ) -> Result<(serde_json::Value, NormalizeReport)> {
429        let profile = self.provider_profile.as_ref();
430        let model_profile = self.selected_model_profile();
431        let (normalized, report) =
432            super::normalize_for_protocol(request, self.endpoint.protocol, profile)?;
433
434        let (mut body, report) = match self.endpoint.protocol {
435            Protocol::OpenAiChat => {
436                let mut body = to_openai_chat_body_with_profile(
437                    &self.model,
438                    &normalized,
439                    request,
440                    profile,
441                    model_profile,
442                )?;
443                if streaming {
444                    body["stream"] = json!(true);
445                    body["stream_options"] = json!({"include_usage": true});
446                }
447                (body, report)
448            }
449            Protocol::OpenAiResponses => {
450                validate_responses_request(request)?;
451                let mut body = to_responses_body(&self.model, &normalized, request);
452                merge_extra_body(&mut body, request, Protocol::OpenAiResponses, profile)?;
453                if streaming {
454                    body["stream"] = json!(true);
455                }
456                (body, report)
457            }
458            Protocol::AnthropicMessages => {
459                validate_anthropic_request(request)?;
460                let mut body = to_anthropic_body(&self.model, &normalized, request);
461                merge_extra_body(&mut body, request, Protocol::AnthropicMessages, profile)?;
462                if streaming {
463                    body["stream"] = json!(true);
464                }
465                (body, report)
466            }
467            Protocol::GeminiGenerateContent => {
468                validate_gemini_request(request)?;
469                let mut body = to_gemini_body(&normalized, request);
470                merge_extra_body(&mut body, request, Protocol::GeminiGenerateContent, profile)?;
471                (body, report)
472            }
473        };
474        let provider_request =
475            effective_provider_request_options(profile, &options.provider_request);
476        apply_provider_request_options(
477            &mut body,
478            self.endpoint.protocol,
479            &provider_request,
480            streaming,
481        )?;
482        Ok((body, report))
483    }
484
485    fn retry_provider(&self) -> RetryProvider {
486        match self.endpoint.protocol {
487            Protocol::OpenAiChat | Protocol::OpenAiResponses => RetryProvider::OpenAi,
488            Protocol::AnthropicMessages => RetryProvider::Anthropic,
489            Protocol::GeminiGenerateContent => RetryProvider::Google,
490        }
491    }
492
493    fn parse_response(&self, value: serde_json::Value) -> Result<ChatResponse> {
494        match self.endpoint.protocol {
495            Protocol::OpenAiChat => {
496                from_openai_chat_response_with_aliases(value, &self.reasoning_aliases())
497            }
498            Protocol::OpenAiResponses => from_responses_response(value),
499            Protocol::AnthropicMessages => from_anthropic_response(value),
500            Protocol::GeminiGenerateContent => from_gemini_response(value),
501        }
502    }
503
504    #[allow(clippy::too_many_arguments)]
505    fn stream_mapper(
506        &self,
507        response: reqwest::Response,
508        policy: Option<crate::stream::StreamReconnectPolicy>,
509        reconnect: Option<ReconnectRequest>,
510        cancellation: Option<crate::CancellationToken>,
511        idle_timeout: Option<std::time::Duration>,
512        report: CompletionReport,
513        audit: Option<AuditContext>,
514        budget: RequestBudget,
515    ) -> ModelStream {
516        let metadata = ResponseMetadata::from_response(&response);
517        match self.endpoint.protocol {
518            Protocol::OpenAiChat => finish_sse_stream(
519                response,
520                OpenAiChatStreamMapper::with_aliases(
521                    self.model.clone(),
522                    metadata,
523                    self.reasoning_aliases(),
524                )
525                .with_report(report),
526                policy,
527                reconnect,
528                cancellation,
529                idle_timeout,
530                audit,
531                budget,
532            ),
533            Protocol::OpenAiResponses => finish_sse_stream(
534                response,
535                ResponsesStreamMapper::new(self.model.clone(), metadata).with_report(report),
536                policy,
537                reconnect,
538                cancellation,
539                idle_timeout,
540                audit,
541                budget,
542            ),
543            Protocol::AnthropicMessages => finish_sse_stream(
544                response,
545                AnthropicStreamMapper::new(self.model.clone(), metadata).with_report(report),
546                policy,
547                reconnect,
548                cancellation,
549                idle_timeout,
550                audit,
551                budget,
552            ),
553            Protocol::GeminiGenerateContent => finish_sse_stream(
554                response,
555                GeminiStreamMapper::new(self.model.clone(), metadata).with_report(report),
556                policy,
557                reconnect,
558                cancellation,
559                idle_timeout,
560                audit,
561                budget,
562            ),
563        }
564    }
565}
566
567#[async_trait]
568impl ModelAdapter for EndpointAdapter {
569    fn provider_name(&self) -> &'static str {
570        "endpoint-adapter"
571    }
572
573    fn model_name(&self) -> &str {
574        &self.model
575    }
576
577    async fn complete_with(
578        &self,
579        request: &ChatRequest,
580        options: &RequestOptions,
581    ) -> Result<ChatResponse> {
582        let budget = RequestBudget::new(options)?;
583        self.ensure_supported()?;
584        let transformed = apply_request_transform(request, options)?;
585        let transform_applied = matches!(transformed, std::borrow::Cow::Owned(_));
586        let request = transformed.as_ref();
587        self.ensure_request_supported(request, false)?;
588        let (body, report) = self.build_body_with_options(request, false, options)?;
589        let request_body_bytes = json_body_bytes(&body)?;
590        let (base_headers, query) = self.request_parts(options, false).await?;
591        let url = self.endpoint.url_for(&self.model, false)?;
592        let provider = protocol_name(self.endpoint.protocol);
593        let retry_policy = effective_retry_policy(&self.retry_policy, options);
594        let audit = self.transport.audit_context(
595            self.provider_name(),
596            provider,
597            &self.model,
598            options,
599            Some(self.audit_profile_snapshot()),
600            request_body_bytes,
601        );
602        if let Some(audit) = &audit {
603            audit.request_started();
604            if transform_applied {
605                audit.transform_applied();
606            }
607            audit.normalization(report.stats());
608        }
609
610        let result = send_json_retry(
611            provider,
612            self.retry_provider(),
613            &retry_policy,
614            audit.as_ref(),
615            options.cancellation.as_ref(),
616            &budget,
617            || async {
618                let headers = prepare_headers(&self.transport, &base_headers, options).await?;
619                let mut request_builder = self
620                    .client
621                    .post(&url)
622                    .headers(headers)
623                    .query(&query)
624                    .json(&body);
625                if let Some(timeout) = options.timeout {
626                    request_builder = request_builder.timeout(timeout);
627                }
628                Ok(request_builder)
629            },
630        )
631        .await;
632
633        let (value, metadata) = match result {
634            Ok(response) => response,
635            Err(error) => {
636                if let Some(audit) = &audit {
637                    audit.request_finished_with_request_id(
638                        audit_outcome_for_error(&error),
639                        error.status(),
640                        error.request_id().map(str::to_string),
641                        Some(&error),
642                        None,
643                    );
644                }
645                return Err(error);
646            }
647        };
648
649        let mut response = match self.parse_response(value).and_then(|response| {
650            budget.check_deadline()?;
651            Ok(response)
652        }) {
653            Ok(response) => response,
654            Err(error) => {
655                if let Some(audit) = &audit {
656                    audit.request_finished_with_request_id(
657                        crate::audit::AuditOutcome::Failure,
658                        Some(metadata.status),
659                        metadata.request_id.clone(),
660                        Some(&error),
661                        None,
662                    );
663                }
664                return Err(error);
665            }
666        };
667        if !budget.limits.retain_raw {
668            response.raw = serde_json::Value::Null;
669        }
670        response.report = completion_report(
671            self.endpoint.protocol,
672            request,
673            report.stats(),
674            transform_applied,
675        );
676        if let Some(audit) = &audit {
677            audit.request_finished_with_request_id(
678                crate::audit::AuditOutcome::Success,
679                Some(metadata.status),
680                metadata.request_id.clone(),
681                None,
682                response.usage.clone(),
683            );
684        }
685        response.metadata = Some(metadata);
686        Ok(response)
687    }
688
689    async fn stream_with(
690        &self,
691        request: &ChatRequest,
692        options: &RequestOptions,
693    ) -> Result<ModelStream> {
694        let budget = RequestBudget::new(options)?;
695        self.ensure_supported()?;
696        let transformed = apply_request_transform(request, options)?;
697        let transform_applied = matches!(transformed, std::borrow::Cow::Owned(_));
698        let request = transformed.as_ref();
699        self.ensure_request_supported(request, true)?;
700        let (body, report) = self.build_body_with_options(request, true, options)?;
701        let request_body_bytes = json_body_bytes(&body)?;
702        let (base_headers, query) = self.request_parts(options, true).await?;
703        let url = self.endpoint.url_for(&self.model, true)?;
704        let provider = protocol_name(self.endpoint.protocol);
705        let retry_policy = effective_retry_policy(&self.retry_policy, options);
706        let audit = self.transport.audit_context(
707            self.provider_name(),
708            provider,
709            &self.model,
710            options,
711            Some(self.audit_profile_snapshot()),
712            request_body_bytes,
713        );
714        if let Some(audit) = &audit {
715            audit.request_started();
716            if transform_applied {
717                audit.transform_applied();
718            }
719            audit.normalization(report.stats());
720        }
721
722        let response = match send_stream_retry(
723            provider,
724            self.retry_provider(),
725            &retry_policy,
726            audit.as_ref(),
727            options.cancellation.as_ref(),
728            &budget,
729            || async {
730                let headers = prepare_headers(&self.transport, &base_headers, options).await?;
731                let mut request_builder = self
732                    .client
733                    .post(&url)
734                    .headers(headers)
735                    .query(&query)
736                    .json(&body);
737                if let Some(timeout) = options.timeout {
738                    request_builder = request_builder.timeout(timeout);
739                }
740                Ok(request_builder)
741            },
742        )
743        .await
744        {
745            Ok(response) => response,
746            Err(error) => {
747                if let Some(audit) = &audit {
748                    audit.request_finished_with_request_id(
749                        audit_outcome_for_error(&error),
750                        error.status(),
751                        error.request_id().map(str::to_string),
752                        Some(&error),
753                        None,
754                    );
755                }
756                return Err(error);
757            }
758        };
759
760        let reconnect = options.stream_reconnect.map(|_| {
761            ReconnectRequest::new(ReconnectRequestParts {
762                budget: budget.clone(),
763                provider,
764                client: self.client.clone(),
765                retry_policy: retry_policy.clone(),
766                retry_provider: self.retry_provider(),
767                transport: self.transport.clone(),
768                options: options.clone(),
769                audit: audit.clone(),
770                url,
771                base_headers,
772                query,
773                body,
774            })
775        });
776        Ok(self.stream_mapper(
777            response,
778            options.stream_reconnect,
779            reconnect,
780            options.cancellation.clone(),
781            options.idle_timeout,
782            completion_report(
783                self.endpoint.protocol,
784                request,
785                report.stats(),
786                transform_applied,
787            ),
788            audit,
789            budget,
790        ))
791    }
792}
793
794#[cfg(test)]
795mod tests {
796    #[test]
797    fn system_placement_policy_is_ignored_outside_openai_protocols() {
798        use crate::normalize::{ExternalRole, Protocol, SystemPlacement};
799        use crate::types::{ChatRequest, Message, Part, Role};
800        let mut profile = ProviderProfile::new("gating");
801        profile.normalize.system_placement = SystemPlacement::FirstToTopRestInPlace;
802        let request = ChatRequest::new(vec![
803            Message::system("base"),
804            Message::user("hi"),
805            Message::system("late catalog"),
806            Message::new(Role::Developer, vec![Part::text("skill body")]),
807        ]);
808        for protocol in [Protocol::AnthropicMessages, Protocol::GeminiGenerateContent] {
809            let (normalized, _report) =
810                super::super::normalize_for_protocol(&request, protocol, Some(&profile))
811                    .expect("normalize");
812            let system = normalized.system.expect("merged system text");
813            assert!(
814                system.contains("base")
815                    && system.contains("late catalog")
816                    && system.contains("skill body"),
817                "{protocol:?} must merge everything to top"
818            );
819            assert!(
820                !normalized
821                    .messages
822                    .iter()
823                    .any(|m| matches!(m.role, ExternalRole::System | ExternalRole::Developer)),
824                "{protocol:?} must not receive in-place instruction messages"
825            );
826        }
827    }
828
829    use super::*;
830    use crate::profile::{Capabilities, ModelMatcher, ProfileSelector, ProviderProfile};
831    use crate::types::{Message, Role, ToolSpec};
832
833    fn endpoint(profile: ProviderProfile) -> EndpointSpec {
834        EndpointSpec::new(
835            Protocol::OpenAiChat,
836            "http://127.0.0.1:9/v1",
837            "/chat/completions",
838            AuthStyle::None,
839        )
840        .profile(profile)
841    }
842
843    #[test]
844    fn provider_capabilities_gate_tools_reasoning_and_multimodal_input() {
845        let mut profile = ProviderProfile::new("restricted");
846        profile.capabilities.tools.supported = false;
847        profile.capabilities.reasoning.supported = false;
848        profile.capabilities.multimodal = false;
849        let model = EndpointAdapter::new("model-a", endpoint(profile));
850
851        let tools = ChatRequest::user("hi").tools([ToolSpec::new(
852            "lookup",
853            "lookup",
854            json!({"type": "object"}),
855        )]);
856        assert!(matches!(
857            model.ensure_request_supported(&tools, false),
858            Err(Error::Unsupported(message)) if message.contains("tool calling")
859        ));
860
861        let reasoning = ChatRequest::user("hi").reasoning(crate::types::ReasoningConfig::new());
862        assert!(matches!(
863            model.ensure_request_supported(&reasoning, false),
864            Err(Error::Unsupported(message)) if message.contains("reasoning")
865        ));
866
867        let multimodal = ChatRequest::new([Message::new(
868            Role::User,
869            vec![
870                Part::text("describe"),
871                Part::image_url("https://example.test/image.png"),
872            ],
873        )]);
874        assert!(matches!(
875            model.ensure_request_supported(&multimodal, false),
876            Err(Error::Unsupported(message)) if message.contains("multimodal")
877        ));
878    }
879
880    #[test]
881    fn model_profile_capabilities_override_provider_capabilities() {
882        let mut provider = ProviderProfile::new("restricted");
883        provider.capabilities.tools.supported = false;
884
885        let model_profile = ModelProfile {
886            matcher: ModelMatcher::Prefix("qwen3".to_string()),
887            capabilities: Some(Capabilities::default()),
888            ..ModelProfile::default()
889        };
890        let model =
891            EndpointAdapter::new("qwen3-235b", endpoint(provider)).model_profile(model_profile);
892
893        let request = ChatRequest::user("hi").tools([ToolSpec::new(
894            "lookup",
895            "lookup",
896            json!({"type": "object"}),
897        )]);
898        assert!(model.ensure_request_supported(&request, false).is_ok());
899    }
900
901    #[test]
902    fn streaming_capability_is_checked_before_sending() {
903        let mut profile = ProviderProfile::new("non-streaming");
904        profile.capabilities.streaming.supported = false;
905        let model = EndpointAdapter::new("model-a", endpoint(profile));
906
907        assert!(matches!(
908            model.ensure_request_supported(&ChatRequest::user("hi"), true),
909            Err(Error::Unsupported(message)) if message.contains("streaming")
910        ));
911    }
912
913    #[test]
914    fn builtin_profile_is_used_by_endpoint_adapter() {
915        let endpoint = EndpointSpec::openai_chat("https://example.test/v1").profile_selector(
916            ProfileSelector::Builtin(crate::profile::ProfileId::from("qwen")),
917        );
918        let model = EndpointAdapter::new("qwen3", endpoint);
919        let request = ChatRequest::user("hi")
920            .reasoning(crate::types::ReasoningConfig::new().budget_tokens(1024));
921
922        let (body, _) = model.build_body(&request, false).unwrap();
923        assert_eq!(body["enable_thinking"], true);
924        assert_eq!(body["thinking_budget"], 1024);
925    }
926
927    #[test]
928    fn unknown_builtin_profile_is_rejected() {
929        let endpoint = EndpointSpec::openai_chat("https://example.test/v1").profile_selector(
930            ProfileSelector::Builtin(crate::profile::ProfileId::from("unknown")),
931        );
932        let model = EndpointAdapter::new("model-a", endpoint);
933
934        assert!(matches!(
935            model.ensure_supported(),
936            Err(Error::Unsupported(_))
937        ));
938    }
939
940    #[test]
941    fn unsupported_non_chat_replay_policies_are_rejected() {
942        let mut profile = ProviderProfile::new("anthropic-gateway");
943        profile.reasoning.replay = ReasoningReplayPolicy::Never;
944        let endpoint = EndpointSpec::anthropic_messages("https://example.test/v1").profile(profile);
945        let model = EndpointAdapter::new("claude", endpoint);
946        let request = ChatRequest::new([Message::new(
947            Role::Assistant,
948            vec![Part::reasoning(
949                crate::types::Reasoning::text("private").with_state(
950                    crate::types::ProviderStateFormat::AnthropicMessages,
951                    json!({"type": "thinking"}),
952                ),
953            )],
954        )]);
955
956        assert!(matches!(
957            model.ensure_request_supported(&request, false),
958            Err(Error::Unsupported(message)) if message.contains("replay policy")
959        ));
960    }
961
962    #[test]
963    fn endpoint_adapter_builds_all_protocol_bodies() {
964        let request = ChatRequest::user("hi");
965
966        let (responses, _) = EndpointAdapter::new(
967            "gpt-5",
968            EndpointSpec::openai_responses("https://example.test/v1"),
969        )
970        .build_body(&request, false)
971        .unwrap();
972        assert_eq!(responses["model"], "gpt-5");
973        assert!(responses.get("input").is_some());
974
975        let (anthropic, _) = EndpointAdapter::new(
976            "claude",
977            EndpointSpec::anthropic_messages("https://example.test/v1"),
978        )
979        .build_body(&request, false)
980        .unwrap();
981        assert_eq!(anthropic["model"], "claude");
982        assert!(anthropic.get("messages").is_some());
983
984        let (gemini, _) = EndpointAdapter::new(
985            "gemini-3",
986            EndpointSpec::gemini_generate_content("https://example.test/v1beta"),
987        )
988        .build_body(&request, false)
989        .unwrap();
990        assert!(gemini.get("contents").is_some());
991    }
992
993    #[test]
994    fn gemini_streaming_uses_stream_path_and_alt_query() {
995        let endpoint = EndpointSpec::gemini_generate_content("https://example.test/v1beta");
996        assert_eq!(
997            endpoint.url_for("gemini-3", true).unwrap(),
998            "https://example.test/v1beta/models/gemini-3:streamGenerateContent"
999        );
1000    }
1001}