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
47pub 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
63pub type OpenAICompatible = EndpointAdapter;
68
69impl EndpointAdapter {
70 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 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 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 pub fn retry_policy(mut self, retry_policy: RetryPolicy) -> Self {
105 self.retry_policy = retry_policy;
106 self
107 }
108
109 pub fn transport(mut self, transport: TransportConfig) -> Self {
111 self.transport = auth_transport(transport, &self.endpoint.auth);
112 self
113 }
114
115 pub fn model_profile(mut self, profile: ModelProfile) -> Self {
117 self.model_profiles.push(profile);
118 self
119 }
120
121 pub fn model_profiles(mut self, profiles: impl IntoIterator<Item = ModelProfile>) -> Self {
123 self.model_profiles.extend(profiles);
124 self
125 }
126
127 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}