Skip to main content

mutil_ai/adapter/
openai_chat.rs

1use crate::security::{RequestBudget, ResponseLimits};
2use std::collections::BTreeMap;
3
4use async_trait::async_trait;
5use reqwest::header::{AUTHORIZATION, HeaderMap, HeaderValue};
6use serde_json::{Value, json};
7
8use super::{
9    ModelAdapter, ReconnectRequest, ReconnectRequestParts, apply_provider_request_options,
10    apply_request_transform, audit_outcome_for_error, completion_report, effective_retry_policy,
11    finish_sse_stream, json_body_bytes, merge_extra_body, prepare_headers, protocol_name,
12    resolve_api_key, send_json_retry, send_stream_retry, validate_server_tools,
13    validate_tool_choice,
14};
15use crate::error::{Error, Result};
16use crate::headers::{RequestOptions, TransportConfig};
17use crate::normalize::{NormalizedChat, NormalizedMessage, Protocol, normalize};
18use crate::profile::{
19    MaxTokensSemantics, ModelProfile, ProviderProfile, ReasoningAliases, ReasoningReplayPolicy,
20    ThinkingRequestProfile,
21};
22use crate::report::CompletionReport;
23use crate::retry::{RetryPolicy, RetryProvider};
24use crate::sse::SseMessage;
25use crate::stream::{ModelStream, SseMapper, StreamEvent};
26use crate::types::{
27    ChatRequest, ChatResponse, Message, Part, ProviderState, ProviderStateFormat, Reasoning,
28    ReasoningConfig, ReasoningKind, ReasoningMode, ResponseFormat, ResponseMetadata, Role,
29    ToolCall, ToolChoice, Usage,
30};
31
32/// Entry point for OpenAI-compatible adapters.
33///
34/// [`OpenAI`] is a namespace for constructing adapters that speak OpenAI's
35/// wire protocols: use [`OpenAI::chat`] for the Chat Completions API and
36/// [`OpenAI::responses`] for the Responses API. Both adapters default to
37/// `https://api.openai.com/v1` and fall back to the `OPENAI_API_KEY`
38/// environment variable when no API key is set explicitly.
39pub struct OpenAI;
40
41impl OpenAI {
42    /// Use the OpenAI Chat Completions API.
43    pub fn chat(model: impl Into<String>) -> OpenAIChat {
44        OpenAIChat::new(model)
45    }
46
47    /// Use the OpenAI Responses API.
48    pub fn responses(model: impl Into<String>) -> super::OpenAIResponses {
49        super::OpenAIResponses::new(model)
50    }
51}
52
53/// Adapter for `POST /v1/chat/completions`.
54///
55/// [`OpenAIChat`] speaks OpenAI's Chat Completions protocol: neutral
56/// [`ChatRequest`]s are normalized and mapped onto the
57/// `/v1/chat/completions` body, and responses (including reasoning content
58/// and tool calls) are mapped back to a neutral [`ChatResponse`]. Together
59/// with [`OpenAIChat::base_url`], it also serves as the base protocol for
60/// third-party OpenAI-compatible endpoints.
61///
62/// Streaming uses server-sent events and requests usage reporting via
63/// `stream_options.include_usage`. Requests are authorized with
64/// `Authorization: Bearer <key>`, where the key comes from
65/// [`OpenAIChat::api_key`] or the `OPENAI_API_KEY` environment variable.
66pub struct OpenAIChat {
67    model: String,
68    api_key: Option<String>,
69    base_url: String,
70    retry_policy: RetryPolicy,
71    transport: TransportConfig,
72    client: reqwest::Client,
73}
74
75impl OpenAIChat {
76    /// Creates a Chat Completions adapter for `model`, defaulting to
77    /// OpenAI's public endpoint.
78    pub fn new(model: impl Into<String>) -> Self {
79        Self {
80            model: model.into(),
81            api_key: None,
82            base_url: "https://api.openai.com/v1".to_string(),
83            retry_policy: RetryPolicy::default(),
84            transport: TransportConfig::default(),
85            client: super::secure_http_client(),
86        }
87    }
88
89    /// Sets the API key sent as `Authorization: Bearer <key>`.
90    ///
91    /// When unset, the `OPENAI_API_KEY` environment variable is used.
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    /// Overrides the API base URL (default `https://api.openai.com/v1`).
98    ///
99    /// The `/chat/completions` path is appended, so this can point at any
100    /// OpenAI-compatible endpoint.
101    pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
102        self.base_url = base_url.into();
103        self
104    }
105
106    /// Overrides the retry policy applied to transient transport failures.
107    pub fn retry_policy(mut self, retry_policy: RetryPolicy) -> Self {
108        self.retry_policy = retry_policy;
109        self
110    }
111
112    /// Sets the transport configuration used when preparing outgoing requests.
113    pub fn transport(mut self, transport: TransportConfig) -> Self {
114        self.transport = transport;
115        self
116    }
117}
118
119#[async_trait]
120impl ModelAdapter for OpenAIChat {
121    fn provider_name(&self) -> &'static str {
122        "openai-chat"
123    }
124
125    fn model_name(&self) -> &str {
126        &self.model
127    }
128
129    async fn complete_with(
130        &self,
131        request: &ChatRequest,
132        options: &RequestOptions,
133    ) -> Result<ChatResponse> {
134        let budget = RequestBudget::new(options)?;
135        let transformed = apply_request_transform(request, options)?;
136        let transform_applied = matches!(transformed, std::borrow::Cow::Owned(_));
137        let request = transformed.as_ref();
138        let (normalized, report) = normalize(request, Protocol::OpenAiChat)?;
139        let mut body = to_openai_chat_body(&self.model, &normalized, request, None)?;
140        apply_provider_request_options(
141            &mut body,
142            Protocol::OpenAiChat,
143            &options.provider_request,
144            false,
145        )?;
146        let request_body_bytes = json_body_bytes(&body)?;
147        let key = resolve_api_key(
148            self.provider_name(),
149            self.api_key.as_deref(),
150            "OPENAI_API_KEY",
151        )?;
152        options.validate_query(protocol_name(Protocol::OpenAiChat), &[])?;
153        let retry_policy = effective_retry_policy(&self.retry_policy, options);
154        let audit = self.transport.audit_context(
155            self.provider_name(),
156            protocol_name(Protocol::OpenAiChat),
157            &self.model,
158            options,
159            None,
160            request_body_bytes,
161        );
162        if let Some(audit) = &audit {
163            audit.request_started();
164            if transform_applied {
165                audit.transform_applied();
166            }
167            audit.normalization(report.stats());
168        }
169
170        let mut base_headers = HeaderMap::new();
171        base_headers.insert(
172            AUTHORIZATION,
173            HeaderValue::from_str(&format!("Bearer {key}"))?,
174        );
175
176        let result = send_json_retry(
177            self.provider_name(),
178            RetryProvider::OpenAi,
179            &retry_policy,
180            audit.as_ref(),
181            options.cancellation.as_ref(),
182            &budget,
183            || async {
184                let headers = prepare_headers(&self.transport, &base_headers, options).await?;
185                let mut request_builder = self
186                    .client
187                    .post(format!(
188                        "{}/chat/completions",
189                        self.base_url.trim_end_matches('/')
190                    ))
191                    .headers(headers)
192                    .query(&options.extra_query)
193                    .json(&body);
194                if let Some(timeout) = options.timeout {
195                    request_builder = request_builder.timeout(timeout);
196                }
197                Ok(request_builder)
198            },
199        )
200        .await;
201
202        let (value, metadata) = match result {
203            Ok(response) => response,
204            Err(error) => {
205                if let Some(audit) = &audit {
206                    audit.request_finished_with_request_id(
207                        audit_outcome_for_error(&error),
208                        error.status(),
209                        error.request_id().map(str::to_string),
210                        Some(&error),
211                        None,
212                    );
213                }
214                return Err(error);
215            }
216        };
217
218        let mut response = match from_openai_chat_response(value).and_then(|response| {
219            budget.check_deadline()?;
220            Ok(response)
221        }) {
222            Ok(response) => response,
223            Err(error) => {
224                if let Some(audit) = &audit {
225                    audit.request_finished_with_request_id(
226                        crate::audit::AuditOutcome::Failure,
227                        Some(metadata.status),
228                        metadata.request_id.clone(),
229                        Some(&error),
230                        None,
231                    );
232                }
233                return Err(error);
234            }
235        };
236        if !budget.limits.retain_raw {
237            response.raw = serde_json::Value::Null;
238        }
239        response.report = completion_report(
240            Protocol::OpenAiChat,
241            request,
242            report.stats(),
243            transform_applied,
244        );
245        if let Some(audit) = &audit {
246            audit.request_finished_with_request_id(
247                crate::audit::AuditOutcome::Success,
248                Some(metadata.status),
249                metadata.request_id.clone(),
250                None,
251                response.usage.clone(),
252            );
253        }
254        response.metadata = Some(metadata);
255        Ok(response)
256    }
257
258    async fn stream_with(
259        &self,
260        request: &ChatRequest,
261        options: &RequestOptions,
262    ) -> Result<ModelStream> {
263        let budget = RequestBudget::new(options)?;
264        let transformed = apply_request_transform(request, options)?;
265        let transform_applied = matches!(transformed, std::borrow::Cow::Owned(_));
266        let request = transformed.as_ref();
267        let (normalized, report) = normalize(request, Protocol::OpenAiChat)?;
268        let mut body = to_openai_chat_body(&self.model, &normalized, request, None)?;
269        body["stream"] = json!(true);
270        body["stream_options"] = json!({"include_usage": true});
271        apply_provider_request_options(
272            &mut body,
273            Protocol::OpenAiChat,
274            &options.provider_request,
275            true,
276        )?;
277        let request_body_bytes = json_body_bytes(&body)?;
278
279        let key = resolve_api_key(
280            self.provider_name(),
281            self.api_key.as_deref(),
282            "OPENAI_API_KEY",
283        )?;
284        options.validate_query(protocol_name(Protocol::OpenAiChat), &[])?;
285        let retry_policy = effective_retry_policy(&self.retry_policy, options);
286        let audit = self.transport.audit_context(
287            self.provider_name(),
288            protocol_name(Protocol::OpenAiChat),
289            &self.model,
290            options,
291            None,
292            request_body_bytes,
293        );
294        if let Some(audit) = &audit {
295            audit.request_started();
296            if transform_applied {
297                audit.transform_applied();
298            }
299            audit.normalization(report.stats());
300        }
301
302        let mut base_headers = HeaderMap::new();
303        base_headers.insert(
304            AUTHORIZATION,
305            HeaderValue::from_str(&format!("Bearer {key}"))?,
306        );
307        let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
308
309        let response = match send_stream_retry(
310            self.provider_name(),
311            RetryProvider::OpenAi,
312            &retry_policy,
313            audit.as_ref(),
314            options.cancellation.as_ref(),
315            &budget,
316            || async {
317                let headers = prepare_headers(&self.transport, &base_headers, options).await?;
318                let mut request_builder = self
319                    .client
320                    .post(&url)
321                    .headers(headers)
322                    .query(&options.extra_query)
323                    .json(&body);
324                if let Some(timeout) = options.timeout {
325                    request_builder = request_builder.timeout(timeout);
326                }
327                Ok(request_builder)
328            },
329        )
330        .await
331        {
332            Ok(response) => response,
333            Err(error) => {
334                if let Some(audit) = &audit {
335                    audit.request_finished_with_request_id(
336                        audit_outcome_for_error(&error),
337                        error.status(),
338                        error.request_id().map(str::to_string),
339                        Some(&error),
340                        None,
341                    );
342                }
343                return Err(error);
344            }
345        };
346
347        let metadata = ResponseMetadata::from_response(&response);
348        let mapper = OpenAiChatStreamMapper::new(self.model.clone(), metadata).with_report(
349            completion_report(
350                Protocol::OpenAiChat,
351                request,
352                report.stats(),
353                transform_applied,
354            ),
355        );
356        let reconnect = options.stream_reconnect.map(|_| {
357            ReconnectRequest::new(ReconnectRequestParts {
358                budget: budget.clone(),
359                provider: self.provider_name(),
360                client: self.client.clone(),
361                retry_policy: retry_policy.clone(),
362                retry_provider: RetryProvider::OpenAi,
363                transport: self.transport.clone(),
364                options: options.clone(),
365                audit: audit.clone(),
366                url,
367                base_headers,
368                query: options.extra_query.clone(),
369                body,
370            })
371        });
372        Ok(finish_sse_stream(
373            response,
374            mapper,
375            options.stream_reconnect,
376            reconnect,
377            options.cancellation.clone(),
378            options.idle_timeout,
379            audit,
380            budget,
381        ))
382    }
383}
384
385struct OpenAiChatWireProfile {
386    aliases: ReasoningAliases,
387    replay: ReasoningReplayPolicy,
388    thinking: ThinkingRequestProfile,
389    max_tokens_semantics: MaxTokensSemantics,
390}
391
392impl OpenAiChatWireProfile {
393    fn resolve(provider: Option<&ProviderProfile>, model: Option<&ModelProfile>) -> Self {
394        let provider_aliases = provider
395            .map(|profile| profile.reasoning.aliases.clone())
396            .unwrap_or_default();
397        let aliases = model
398            .filter(|profile| !profile.reasoning_aliases.is_empty())
399            .map(|profile| profile.reasoning_aliases.clone())
400            .unwrap_or(provider_aliases);
401        let replay = model
402            .and_then(|profile| profile.replay)
403            .or_else(|| provider.map(|profile| profile.reasoning.replay))
404            .unwrap_or(ReasoningReplayPolicy::SameProvider);
405        let thinking = model
406            .filter(|profile| profile.thinking != ThinkingRequestProfile::None)
407            .map(|profile| profile.thinking.clone())
408            .or_else(|| provider.map(|profile| profile.reasoning.thinking.clone()))
409            .unwrap_or(ThinkingRequestProfile::None);
410        let max_tokens_semantics = model
411            .map(|profile| profile.max_tokens_semantics)
412            .or_else(|| provider.map(|profile| profile.max_tokens_semantics))
413            .unwrap_or(MaxTokensSemantics::MaxCompletionTokens);
414
415        Self {
416            aliases,
417            replay,
418            thinking,
419            max_tokens_semantics,
420        }
421    }
422}
423
424/// Builds the OpenAI Chat Completions request body from a normalized request,
425/// without model-specific overrides.
426///
427/// # Errors
428///
429/// Returns an error if server tools, tool choice, or reasoning controls
430/// cannot be represented in the Chat Completions protocol.
431pub(crate) fn to_openai_chat_body(
432    model: &str,
433    normalized: &NormalizedChat,
434    request: &ChatRequest,
435    profile: Option<&ProviderProfile>,
436) -> Result<Value> {
437    to_openai_chat_body_with_profile(model, normalized, request, profile, None)
438}
439
440/// Like [`to_openai_chat_body`], but also resolves reasoning aliases, replay
441/// policy, thinking controls, and token-limit semantics from the given
442/// provider and model profiles.
443///
444/// # Errors
445///
446/// Returns an error if server tools, tool choice, reasoning controls, or
447/// profile-declared request fields cannot be represented in the Chat
448/// Completions protocol.
449pub(crate) fn to_openai_chat_body_with_profile(
450    model: &str,
451    normalized: &NormalizedChat,
452    request: &ChatRequest,
453    provider: Option<&ProviderProfile>,
454    model_profile: Option<&ModelProfile>,
455) -> Result<Value> {
456    validate_server_tools(Protocol::OpenAiChat, request)?;
457    let wire = OpenAiChatWireProfile::resolve(provider, model_profile);
458    let mut messages = Vec::new();
459
460    if let Some(system) = &normalized.system {
461        messages.push(json!({"role": "system", "content": system}));
462    }
463
464    for message in &normalized.messages {
465        match message.role {
466            crate::normalize::ExternalRole::System => {
467                messages.push(json!({"role": "system", "content": text_content(message)}));
468            }
469            crate::normalize::ExternalRole::Developer => {
470                messages.push(json!({"role": "developer", "content": text_content(message)}));
471            }
472            crate::normalize::ExternalRole::User => {
473                messages.push(json!({
474                    "role": "user",
475                    "content": content_value(&message.parts),
476                }));
477            }
478            crate::normalize::ExternalRole::Assistant => {
479                let text = text_content(message);
480                let tool_calls: Vec<Value> = message
481                    .parts
482                    .iter()
483                    .filter_map(|part| match part {
484                        Part::ToolCall(call) => Some(json!({
485                            "id": call.id.clone().unwrap_or_else(|| call.name.clone()),
486                            "type": "function",
487                            "function": {
488                                "name": call.name,
489                                "arguments": serde_json::to_string(&call.arguments)
490                                    .unwrap_or_else(|_| "{}".to_string()),
491                            }
492                        })),
493                        _ => None,
494                    })
495                    .collect();
496
497                let mut replay_text: BTreeMap<String, Vec<String>> = BTreeMap::new();
498                let mut replay_opaque: BTreeMap<String, Value> = BTreeMap::new();
499                let mut replay_details = Vec::new();
500
501                for part in &message.parts {
502                    let Part::Reasoning(reasoning_part) = part else {
503                        continue;
504                    };
505                    if !should_replay_reasoning(
506                        wire.replay,
507                        reasoning_part,
508                        !tool_calls.is_empty(),
509                        &wire.aliases,
510                    ) {
511                        continue;
512                    }
513
514                    let state = reasoning_part
515                        .state
516                        .as_ref()
517                        .filter(|state| state.format == ProviderStateFormat::OpenAiChat);
518                    let field = state
519                        .and_then(|state| state.data.get("field"))
520                        .and_then(Value::as_str);
521                    let state_value = state.and_then(|state| state.data.get("value"));
522
523                    if field == Some("reasoning_details") {
524                        match state_value {
525                            Some(Value::Array(values)) => replay_details.extend(values.clone()),
526                            Some(value) => replay_details.push(value.clone()),
527                            None => {}
528                        }
529                        continue;
530                    }
531
532                    let field = field.unwrap_or_else(|| {
533                        wire.aliases
534                            .request_replay
535                            .first()
536                            .map(String::as_str)
537                            .unwrap_or("reasoning_content")
538                    });
539                    ensure_safe_reasoning_field(field)?;
540
541                    if let Some(Value::String(value)) = state_value {
542                        replay_text
543                            .entry(field.to_string())
544                            .or_default()
545                            .push(value.clone());
546                    } else if let Some(value) = state_value {
547                        replay_opaque
548                            .entry(field.to_string())
549                            .or_insert(value.clone());
550                    } else if let Some(value) = reasoning_part.display_text() {
551                        replay_text
552                            .entry(field.to_string())
553                            .or_default()
554                            .push(value.to_string());
555                    }
556                }
557
558                let mut value = json!({
559                    "role": "assistant",
560                    "content": if text.is_empty() { Value::Null } else { Value::String(text) },
561                });
562                for (field, values) in replay_text {
563                    ensure_safe_reasoning_field(&field)?;
564                    value[field] = Value::String(values.join("\n"));
565                }
566                for (field, opaque) in replay_opaque {
567                    ensure_safe_reasoning_field(&field)?;
568                    value[field] = opaque;
569                }
570                if !replay_details.is_empty() {
571                    value["reasoning_details"] = Value::Array(replay_details);
572                }
573                if !tool_calls.is_empty() {
574                    value["tool_calls"] = Value::Array(tool_calls);
575                }
576                messages.push(value);
577            }
578            crate::normalize::ExternalRole::Tool => {
579                for result in message.parts.iter().filter_map(|part| match part {
580                    Part::ToolResult(result) => Some(result),
581                    _ => None,
582                }) {
583                    messages.push(json!({
584                        "role": "tool",
585                        "tool_call_id": result.call_id.clone().unwrap_or_else(|| result.name.clone()),
586                        "content": result.content,
587                    }));
588                }
589            }
590        }
591    }
592
593    let mut body = json!({
594        "model": model,
595        "messages": messages,
596    });
597
598    if !normalized.tools.is_empty() {
599        body["tools"] = Value::Array(
600            normalized
601                .tools
602                .iter()
603                .map(|tool| {
604                    json!({
605                        "type": "function",
606                        "function": {
607                            "name": tool.name,
608                            "description": tool.description,
609                            "parameters": tool.parameters,
610                        }
611                    })
612                })
613                .collect(),
614        );
615    }
616    if let Some(temperature) = request.temperature {
617        body["temperature"] = json!(temperature);
618    }
619    if let Some(max_output_tokens) = request.max_output_tokens {
620        let field = match wire.max_tokens_semantics {
621            MaxTokensSemantics::MaxTokens => "max_tokens",
622            MaxTokensSemantics::MaxOutputTokens | MaxTokensSemantics::MaxCompletionTokens => {
623                "max_completion_tokens"
624            }
625        };
626        body[field] = json!(max_output_tokens);
627    }
628    validate_tool_choice(&normalized.tools, request.tool_choice.as_ref())?;
629    if let Some(tool_choice) = &request.tool_choice {
630        body["tool_choice"] = openai_tool_choice(tool_choice);
631    }
632    if let Some(response_format) = &request.response_format {
633        body["response_format"] = openai_response_format(response_format);
634    }
635    if !request.stop.is_empty() {
636        body["stop"] = json!(request.stop);
637    }
638    if let Some(seed) = request.seed {
639        body["seed"] = json!(seed);
640    }
641    apply_openai_chat_thinking(&mut body, request.reasoning.as_ref(), &wire.thinking)?;
642
643    merge_extra_body(&mut body, request, Protocol::OpenAiChat, provider)?;
644    Ok(body)
645}
646
647fn openai_tool_choice(choice: &ToolChoice) -> Value {
648    match choice {
649        ToolChoice::Auto => json!("auto"),
650        ToolChoice::None => json!("none"),
651        ToolChoice::Required => json!("required"),
652        ToolChoice::Tool(name) => json!({
653            "type": "function",
654            "function": {"name": name},
655        }),
656    }
657}
658
659fn openai_response_format(format: &ResponseFormat) -> Value {
660    match format {
661        ResponseFormat::Text => json!({"type": "text"}),
662        ResponseFormat::JsonObject => json!({"type": "json_object"}),
663        ResponseFormat::JsonSchema {
664            name,
665            schema,
666            strict,
667        } => json!({
668            "type": "json_schema",
669            "json_schema": {
670                "name": name,
671                "schema": schema,
672                "strict": strict.unwrap_or(false),
673            }
674        }),
675    }
676}
677
678fn should_replay_reasoning(
679    policy: ReasoningReplayPolicy,
680    reasoning: &Reasoning,
681    has_tool_calls: bool,
682    aliases: &ReasoningAliases,
683) -> bool {
684    match policy {
685        ReasoningReplayPolicy::Never => false,
686        ReasoningReplayPolicy::SameProvider
687        | ReasoningReplayPolicy::PreserveInHistory
688        | ReasoningReplayPolicy::ModelDefined => true,
689        ReasoningReplayPolicy::RequiredForToolCalls => has_tool_calls,
690        ReasoningReplayPolicy::EncryptedOnly => {
691            if reasoning.kind == ReasoningKind::Encrypted {
692                return true;
693            }
694            reasoning
695                .state
696                .as_ref()
697                .filter(|state| state.format == ProviderStateFormat::OpenAiChat)
698                .and_then(|state| state.data.get("field"))
699                .and_then(Value::as_str)
700                .is_some_and(|field| {
701                    field == "reasoning_details"
702                        || aliases.encrypted.iter().any(|alias| alias == field)
703                })
704        }
705    }
706}
707
708fn ensure_safe_reasoning_field(field: &str) -> Result<()> {
709    if matches!(field, "role" | "content" | "tool_calls" | "tool_call_id") {
710        return Err(Error::InvalidProfile(format!(
711            "reasoning alias `{field}` would overwrite an assistant message field"
712        )));
713    }
714    Ok(())
715}
716
717fn apply_openai_chat_thinking(
718    body: &mut Value,
719    config: Option<&ReasoningConfig>,
720    profile: &ThinkingRequestProfile,
721) -> Result<()> {
722    if matches!(profile, ThinkingRequestProfile::None) {
723        if let Some(effort) = openai_chat_reasoning_effort(config) {
724            body["reasoning_effort"] = json!(effort);
725        }
726        return Ok(());
727    }
728
729    apply_thinking_profile(body, config, profile)
730}
731
732fn apply_thinking_profile(
733    body: &mut Value,
734    config: Option<&ReasoningConfig>,
735    profile: &ThinkingRequestProfile,
736) -> Result<()> {
737    match profile {
738        ThinkingRequestProfile::None => {}
739        ThinkingRequestProfile::Field { path, value } => {
740            set_thinking_field(body, path, value.clone())?;
741        }
742        ThinkingRequestProfile::Composite(parts) => {
743            for part in parts {
744                apply_thinking_profile(body, config, part)?;
745            }
746        }
747        ThinkingRequestProfile::EnabledFlag(field) => {
748            let Some(config) = config else {
749                return Ok(());
750            };
751            ensure_safe_thinking_field(field)?;
752            body[field] = json!(config.mode != Some(ReasoningMode::Disabled));
753        }
754        ThinkingRequestProfile::ThinkingObject => {
755            let Some(config) = config else {
756                return Ok(());
757            };
758            ensure_safe_thinking_field("thinking")?;
759            let enabled = config.mode != Some(ReasoningMode::Disabled);
760            let mut thinking = serde_json::Map::new();
761            thinking.insert(
762                "type".to_string(),
763                json!(if enabled { "enabled" } else { "disabled" }),
764            );
765            if let Some(budget) = config.budget_tokens {
766                thinking.insert("budget_tokens".to_string(), json!(budget));
767            }
768            body["thinking"] = Value::Object(thinking);
769        }
770        ThinkingRequestProfile::Effort(field) => {
771            let Some(config) = config else {
772                return Ok(());
773            };
774            ensure_safe_thinking_field(field)?;
775            if let Some(effort) = openai_chat_reasoning_effort(Some(config)) {
776                body[field] = json!(effort);
777            }
778        }
779        ThinkingRequestProfile::MappedEffort { field, mapping } => {
780            let Some(config) = config else {
781                return Ok(());
782            };
783            ensure_safe_thinking_field(field)?;
784            if let Some(effort) = config.effort {
785                if let Some(mapped) = mapping.map(effort) {
786                    body[field] = json!(mapped);
787                }
788            } else if config.mode == Some(ReasoningMode::Disabled)
789                && let Some(mapped) = mapping.map(crate::types::ReasoningEffort::None)
790            {
791                body[field] = json!(mapped);
792            }
793        }
794        ThinkingRequestProfile::BudgetTokens(field) => {
795            let Some(config) = config else {
796                return Ok(());
797            };
798            ensure_safe_thinking_field(field)?;
799            if config.mode != Some(ReasoningMode::Disabled)
800                && let Some(budget) = config.budget_tokens
801            {
802                body[field] = json!(budget);
803            }
804        }
805    }
806
807    Ok(())
808}
809
810fn set_thinking_field(body: &mut Value, path: &str, value: Value) -> Result<()> {
811    let segments: Vec<_> = path
812        .split('.')
813        .filter(|segment| !segment.is_empty())
814        .collect();
815    let Some((last, parents)) = segments.split_last() else {
816        return Err(Error::InvalidProfile(
817            "thinking field path cannot be empty".to_string(),
818        ));
819    };
820    ensure_safe_thinking_field(parents.first().unwrap_or(last))?;
821
822    let mut current = body;
823    for segment in parents {
824        if !current.is_object() {
825            return Err(Error::InvalidProfile(format!(
826                "thinking field path `{path}` crosses a non-object value"
827            )));
828        }
829        current = current
830            .as_object_mut()
831            .expect("checked above")
832            .entry((*segment).to_string())
833            .or_insert_with(|| json!({}));
834    }
835
836    let Some(object) = current.as_object_mut() else {
837        return Err(Error::InvalidProfile(format!(
838            "thinking field path `{path}` does not target an object"
839        )));
840    };
841    object.insert((*last).to_string(), value);
842    Ok(())
843}
844
845fn ensure_safe_thinking_field(field: &str) -> Result<()> {
846    if matches!(
847        field,
848        "model"
849            | "messages"
850            | "stream"
851            | "stream_options"
852            | "tools"
853            | "temperature"
854            | "max_tokens"
855            | "max_completion_tokens"
856    ) {
857        return Err(Error::InvalidProfile(format!(
858            "thinking field `{field}` would overwrite a canonical request field"
859        )));
860    }
861    Ok(())
862}
863
864#[derive(Default)]
865struct OpenAiToolCallAccumulator {
866    id: Option<String>,
867    name: String,
868    arguments: String,
869    last_progress_bytes: Option<usize>,
870}
871
872/// Stateful SSE mapper that turns OpenAI Chat Completions stream chunks into
873/// neutral [`StreamEvent`]s, accumulating text, reasoning, tool calls, and
874/// usage until the `[DONE]` sentinel.
875pub(crate) struct OpenAiChatStreamMapper {
876    model: String,
877    metadata: ResponseMetadata,
878    aliases: ReasoningAliases,
879    started: bool,
880    done: bool,
881    text: String,
882    reasoning_text: BTreeMap<String, String>,
883    reasoning_summary: BTreeMap<String, String>,
884    reasoning_opaque: BTreeMap<String, Value>,
885    reasoning_details: Vec<Value>,
886    tool_calls: BTreeMap<usize, OpenAiToolCallAccumulator>,
887    usage: Option<Usage>,
888    finish_reason: Option<String>,
889    chunks: Vec<Value>,
890    limits: ResponseLimits,
891    report: CompletionReport,
892}
893
894impl OpenAiChatStreamMapper {
895    /// Creates a mapper with default reasoning field aliases.
896    pub(crate) fn new(model: String, metadata: ResponseMetadata) -> Self {
897        Self::with_aliases(model, metadata, ReasoningAliases::default())
898    }
899
900    /// Creates a mapper that reads reasoning content from the
901    /// provider-specific delta fields named in `aliases`.
902    pub(crate) fn with_aliases(
903        model: String,
904        metadata: ResponseMetadata,
905        aliases: ReasoningAliases,
906    ) -> Self {
907        Self {
908            model,
909            metadata,
910            aliases,
911            started: false,
912            done: false,
913            text: String::new(),
914            reasoning_text: BTreeMap::new(),
915            reasoning_summary: BTreeMap::new(),
916            reasoning_opaque: BTreeMap::new(),
917            reasoning_details: Vec::new(),
918            tool_calls: BTreeMap::new(),
919            usage: None,
920            finish_reason: None,
921            chunks: Vec::new(),
922            limits: ResponseLimits::default(),
923            report: CompletionReport::default(),
924        }
925    }
926
927    /// Attaches a [`CompletionReport`] to the response emitted with
928    /// [`StreamEvent::Done`].
929    pub(crate) fn with_report(mut self, report: CompletionReport) -> Self {
930        self.report = report;
931        self
932    }
933
934    fn push_start(&mut self, events: &mut Vec<StreamEvent>) {
935        if self.started {
936            return;
937        }
938        self.started = true;
939        events.push(StreamEvent::Start {
940            provider: "openai-chat",
941            model: self.model.clone(),
942            metadata: self.metadata.clone(),
943        });
944    }
945
946    fn done_events(&mut self) -> Vec<StreamEvent> {
947        if self.done {
948            return Vec::new();
949        }
950        self.done = true;
951
952        let mut events = Vec::new();
953        self.push_start(&mut events);
954        let mut parts = Vec::new();
955
956        for (field, text) in &self.reasoning_text {
957            if !text.is_empty() {
958                parts.push(Part::reasoning(openai_chat_reasoning(
959                    ReasoningKind::Text,
960                    Some(text),
961                    field,
962                    Value::String(text.clone()),
963                )));
964            }
965        }
966        for (field, text) in &self.reasoning_summary {
967            if !text.is_empty() {
968                parts.push(Part::reasoning(openai_chat_reasoning(
969                    ReasoningKind::Summary,
970                    Some(text),
971                    field,
972                    Value::String(text.clone()),
973                )));
974            }
975        }
976        for (field, value) in &self.reasoning_opaque {
977            parts.push(Part::reasoning(openai_chat_reasoning(
978                ReasoningKind::Encrypted,
979                None,
980                field,
981                value.clone(),
982            )));
983        }
984        for detail in &self.reasoning_details {
985            parts.push(Part::reasoning(openai_chat_reasoning_from_detail(detail)));
986        }
987        if !self.text.is_empty() {
988            parts.push(Part::text(&self.text));
989        }
990        for (index, call) in &self.tool_calls {
991            if call.last_progress_bytes != Some(call.arguments.len()) {
992                events.push(StreamEvent::ToolCallProgress {
993                    index: *index,
994                    id: call.id.clone(),
995                    name: Some(call.name.clone()),
996                    arguments_so_far: call.arguments.clone(),
997                });
998            }
999            let arguments = if call.arguments.trim().is_empty() {
1000                json!({})
1001            } else {
1002                parse_json_or_string(&call.arguments)
1003            };
1004            parts.push(Part::ToolCall(ToolCall {
1005                // Missing native IDs are assigned collision-free by normalization.
1006                id: call.id.clone(),
1007                name: call.name.clone(),
1008                arguments,
1009                provider_state: None,
1010            }));
1011        }
1012
1013        let response = ChatResponse {
1014            message: Message::new(Role::Assistant, parts),
1015            usage: self.usage.clone(),
1016            raw: if self.limits.retain_raw {
1017                Value::Array(std::mem::take(&mut self.chunks))
1018            } else {
1019                Value::Null
1020            },
1021            metadata: Some(self.metadata.clone()),
1022            report: self.report.clone(),
1023        };
1024        events.push(StreamEvent::Done {
1025            response: Box::new(response),
1026            finish_reason: self.finish_reason.clone(),
1027        });
1028        events
1029    }
1030}
1031
1032impl SseMapper for OpenAiChatStreamMapper {
1033    fn configure_limits(&mut self, limits: ResponseLimits) {
1034        self.limits = limits;
1035    }
1036
1037    fn sse_parser(&self) -> crate::sse::SseParser {
1038        // Lenient gateways routinely cut the connection right after the
1039        // final tool-call argument delta, without the blank-line SSE
1040        // terminator. The discard default loses that frame; Flush recovers
1041        // it, and a genuinely truncated payload surfaces as a parse error
1042        // instead of silent loss.
1043        crate::sse::SseParser::new().with_tail_policy(crate::sse::TailPolicy::Flush)
1044    }
1045
1046    fn map(&mut self, message: SseMessage) -> Result<Vec<StreamEvent>> {
1047        if message.data.trim() == "[DONE]" {
1048            return Ok(self.done_events());
1049        }
1050
1051        let chunk: Value = serde_json::from_str(&message.data)?;
1052        if let Some(error) = chunk.get("error") {
1053            return Err(Error::ProviderStream(error.to_string()));
1054        }
1055        if self.limits.retain_raw {
1056            self.chunks.push(chunk.clone());
1057        }
1058
1059        let mut events = Vec::new();
1060        self.push_start(&mut events);
1061
1062        if let Some(usage) = chunk.get("usage").and_then(openai_chat_usage) {
1063            self.usage = Some(usage.clone());
1064            events.push(StreamEvent::Usage { usage });
1065        }
1066
1067        let Some(choice) = chunk.pointer("/choices/0") else {
1068            return Ok(events);
1069        };
1070
1071        if let Some(finish_reason) = choice.get("finish_reason").and_then(Value::as_str) {
1072            self.finish_reason = Some(finish_reason.to_string());
1073        }
1074
1075        let Some(delta) = choice.get("delta") else {
1076            return Ok(events);
1077        };
1078
1079        for field in &self.aliases.response_text {
1080            if field == "reasoning_details" {
1081                continue;
1082            }
1083            if let Some(text) = delta.get(field).and_then(Value::as_str) {
1084                self.reasoning_text
1085                    .entry(field.clone())
1086                    .or_default()
1087                    .push_str(text);
1088                events.push(StreamEvent::ReasoningDelta {
1089                    kind: ReasoningKind::Text,
1090                    text: text.to_string(),
1091                });
1092            }
1093        }
1094        for field in &self.aliases.response_summary {
1095            if field == "reasoning_details" {
1096                continue;
1097            }
1098            if let Some(text) = delta.get(field).and_then(Value::as_str) {
1099                self.reasoning_summary
1100                    .entry(field.clone())
1101                    .or_default()
1102                    .push_str(text);
1103                events.push(StreamEvent::ReasoningDelta {
1104                    kind: ReasoningKind::Summary,
1105                    text: text.to_string(),
1106                });
1107            }
1108        }
1109        for field in self
1110            .aliases
1111            .encrypted
1112            .iter()
1113            .chain(self.aliases.signature.iter())
1114        {
1115            if field == "reasoning_details" {
1116                continue;
1117            }
1118            if let Some(value) = delta.get(field) {
1119                if let Some(text) = value.as_str() {
1120                    let existing = self
1121                        .reasoning_opaque
1122                        .entry(field.clone())
1123                        .or_insert_with(|| Value::String(String::new()));
1124                    if let Value::String(existing) = existing {
1125                        existing.push_str(text);
1126                    } else {
1127                        *existing = Value::String(text.to_string());
1128                    }
1129                } else if !value.is_null() {
1130                    self.reasoning_opaque.insert(field.clone(), value.clone());
1131                }
1132            }
1133        }
1134        if let Some(details) = delta.get("reasoning_details").and_then(Value::as_array) {
1135            for detail in details {
1136                self.reasoning_details.push(detail.clone());
1137                if let Some(text) = detail
1138                    .get("text")
1139                    .and_then(Value::as_str)
1140                    .or_else(|| detail.get("summary").and_then(Value::as_str))
1141                    && !text.is_empty()
1142                {
1143                    events.push(StreamEvent::ReasoningDelta {
1144                        kind: openai_chat_reasoning_kind(detail),
1145                        text: text.to_string(),
1146                    });
1147                }
1148            }
1149        }
1150        if let Some(text) = delta.get("content").and_then(Value::as_str) {
1151            self.text.push_str(text);
1152            events.push(StreamEvent::TextDelta {
1153                text: text.to_string(),
1154            });
1155        }
1156
1157        if let Some(tool_calls) = delta.get("tool_calls").and_then(Value::as_array) {
1158            for call in tool_calls {
1159                let index = call.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
1160                let accumulator = self.tool_calls.entry(index).or_default();
1161                let id = call.get("id").and_then(Value::as_str).map(str::to_string);
1162                let name = call
1163                    .pointer("/function/name")
1164                    .and_then(Value::as_str)
1165                    .map(str::to_string);
1166                let arguments_delta = call
1167                    .pointer("/function/arguments")
1168                    .and_then(Value::as_str)
1169                    .unwrap_or_default()
1170                    .to_string();
1171
1172                if id.is_some() {
1173                    accumulator.id = id.clone();
1174                }
1175                if let Some(name) = &name
1176                    && accumulator.name.is_empty()
1177                {
1178                    accumulator.name.clone_from(name);
1179                }
1180                if accumulator
1181                    .arguments
1182                    .len()
1183                    .saturating_add(arguments_delta.len())
1184                    > self.limits.max_tool_argument_bytes
1185                {
1186                    return Err(Error::ResponseLimit {
1187                        resource: "tool argument bytes",
1188                        limit: self.limits.max_tool_argument_bytes,
1189                    });
1190                }
1191                accumulator.arguments.push_str(&arguments_delta);
1192
1193                let progress_id = accumulator.id.clone().or_else(|| id.clone());
1194                let progress_name = (!accumulator.name.is_empty())
1195                    .then(|| accumulator.name.clone())
1196                    .or_else(|| name.clone());
1197                let emit_progress = accumulator.last_progress_bytes.is_none_or(|last| {
1198                    accumulator.arguments.len().saturating_sub(last)
1199                        >= self.limits.tool_progress_interval_bytes
1200                });
1201                events.push(StreamEvent::ToolCallDelta {
1202                    index,
1203                    id,
1204                    name,
1205                    arguments_delta,
1206                });
1207                if emit_progress {
1208                    accumulator.last_progress_bytes = Some(accumulator.arguments.len());
1209                    events.push(StreamEvent::ToolCallProgress {
1210                        index,
1211                        id: progress_id,
1212                        name: progress_name,
1213                        arguments_so_far: accumulator.arguments.clone(),
1214                    });
1215                }
1216            }
1217        }
1218
1219        Ok(events)
1220    }
1221
1222    fn finish(&mut self) -> Result<Vec<StreamEvent>> {
1223        Ok(self.done_events())
1224    }
1225}
1226
1227/// Converts an OpenAI Chat Completions JSON response into a neutral
1228/// [`ChatResponse`].
1229///
1230/// # Errors
1231///
1232/// Returns an error if the payload cannot be parsed into the neutral
1233/// representation.
1234pub(crate) fn from_openai_chat_response(value: Value) -> Result<ChatResponse> {
1235    from_openai_chat_response_with_aliases(value, &ReasoningAliases::default())
1236}
1237
1238/// Like [`from_openai_chat_response`], but also extracts reasoning content
1239/// from the provider-specific message fields named in `aliases`.
1240///
1241/// # Errors
1242///
1243/// Returns an error if the payload cannot be parsed into the neutral
1244/// representation.
1245pub(crate) fn from_openai_chat_response_with_aliases(
1246    value: Value,
1247    aliases: &ReasoningAliases,
1248) -> Result<ChatResponse> {
1249    let message = value
1250        .pointer("/choices/0/message")
1251        .cloned()
1252        .unwrap_or(Value::Null);
1253
1254    let mut parts = Vec::new();
1255    let mut handled = Vec::new();
1256
1257    for field in &aliases.response_text {
1258        if handled.iter().any(|seen| seen == field) {
1259            continue;
1260        }
1261        handled.push(field.clone());
1262        if field == "reasoning_details" {
1263            push_reasoning_details(&mut parts, message.get(field));
1264        } else if let Some(text) = message.get(field).and_then(Value::as_str)
1265            && !text.is_empty()
1266        {
1267            parts.push(Part::reasoning(openai_chat_reasoning(
1268                ReasoningKind::Text,
1269                Some(text),
1270                field,
1271                Value::String(text.to_string()),
1272            )));
1273        }
1274    }
1275
1276    for field in &aliases.response_summary {
1277        if handled.iter().any(|seen| seen == field) {
1278            continue;
1279        }
1280        handled.push(field.clone());
1281        if field == "reasoning_details" {
1282            push_reasoning_details(&mut parts, message.get(field));
1283        } else if let Some(text) = message.get(field).and_then(Value::as_str)
1284            && !text.is_empty()
1285        {
1286            parts.push(Part::reasoning(openai_chat_reasoning(
1287                ReasoningKind::Summary,
1288                Some(text),
1289                field,
1290                Value::String(text.to_string()),
1291            )));
1292        }
1293    }
1294
1295    for field in aliases.encrypted.iter().chain(aliases.signature.iter()) {
1296        if handled.iter().any(|seen| seen == field) {
1297            continue;
1298        }
1299        handled.push(field.clone());
1300        let Some(value) = message.get(field) else {
1301            continue;
1302        };
1303        if field == "reasoning_details" {
1304            push_reasoning_details(&mut parts, Some(value));
1305        } else if let Some(text) = value.as_str() {
1306            if !text.is_empty() {
1307                parts.push(Part::reasoning(openai_chat_reasoning(
1308                    ReasoningKind::Encrypted,
1309                    None,
1310                    field,
1311                    Value::String(text.to_string()),
1312                )));
1313            }
1314        } else if !value.is_null() {
1315            parts.push(Part::reasoning(openai_chat_reasoning(
1316                ReasoningKind::Encrypted,
1317                None,
1318                field,
1319                value.clone(),
1320            )));
1321        }
1322    }
1323
1324    if !handled.iter().any(|field| field == "reasoning_details")
1325        && let Some(details) = message.get("reasoning_details")
1326    {
1327        push_reasoning_details(&mut parts, Some(details));
1328    }
1329
1330    if let Some(text) = message.get("content").and_then(Value::as_str)
1331        && !text.is_empty()
1332    {
1333        parts.push(Part::text(text));
1334    }
1335
1336    if let Some(tool_calls) = message.get("tool_calls").and_then(Value::as_array) {
1337        for call in tool_calls {
1338            let id = call.get("id").and_then(Value::as_str).map(str::to_string);
1339            let name = call
1340                .pointer("/function/name")
1341                .and_then(Value::as_str)
1342                .unwrap_or_default()
1343                .to_string();
1344            let arguments = call
1345                .pointer("/function/arguments")
1346                .and_then(Value::as_str)
1347                .map(parse_json_or_string)
1348                .unwrap_or(Value::Null);
1349            parts.push(Part::ToolCall(ToolCall {
1350                id,
1351                name,
1352                arguments,
1353                provider_state: None,
1354            }));
1355        }
1356    }
1357
1358    let usage = value.get("usage").map(openai_chat_usage_value);
1359
1360    Ok(ChatResponse {
1361        message: Message::new(Role::Assistant, parts),
1362        usage,
1363        raw: value,
1364        metadata: None,
1365        report: CompletionReport::default(),
1366    })
1367}
1368
1369fn push_reasoning_details(parts: &mut Vec<Part>, value: Option<&Value>) {
1370    let Some(Value::Array(details)) = value else {
1371        return;
1372    };
1373    for detail in details {
1374        parts.push(Part::reasoning(openai_chat_reasoning_from_detail(detail)));
1375    }
1376}
1377
1378fn openai_chat_reasoning(
1379    kind: ReasoningKind,
1380    text: Option<&str>,
1381    field: &str,
1382    value: Value,
1383) -> Reasoning {
1384    let (summary, text) = match kind {
1385        ReasoningKind::Summary => (text.map(str::to_string), None),
1386        _ => (None, text.map(str::to_string)),
1387    };
1388    Reasoning {
1389        kind,
1390        summary,
1391        text,
1392        state: Some(ProviderState::new(
1393            ProviderStateFormat::OpenAiChat,
1394            json!({"field": field, "value": value}),
1395        )),
1396    }
1397}
1398
1399fn openai_chat_reasoning_kind(detail: &Value) -> ReasoningKind {
1400    match detail.get("type").and_then(Value::as_str) {
1401        Some(kind) if kind.contains("summary") => ReasoningKind::Summary,
1402        Some(kind) if kind.contains("encrypted") => ReasoningKind::Encrypted,
1403        Some(kind) if kind.contains("redacted") => ReasoningKind::Redacted,
1404        _ => ReasoningKind::Text,
1405    }
1406}
1407
1408fn openai_chat_reasoning_from_detail(detail: &Value) -> Reasoning {
1409    let kind = openai_chat_reasoning_kind(detail);
1410    let text = detail
1411        .get("text")
1412        .and_then(Value::as_str)
1413        .or_else(|| detail.get("summary").and_then(Value::as_str));
1414    openai_chat_reasoning(kind, text, "reasoning_details", detail.clone())
1415}
1416
1417fn openai_chat_usage(usage: &Value) -> Option<Usage> {
1418    Some(openai_chat_usage_value(usage))
1419}
1420
1421fn openai_chat_usage_value(usage: &Value) -> Usage {
1422    Usage {
1423        input_tokens: usage.get("prompt_tokens").and_then(Value::as_u64),
1424        output_tokens: usage.get("completion_tokens").and_then(Value::as_u64),
1425        total_tokens: usage.get("total_tokens").and_then(Value::as_u64),
1426        cache_read_tokens: usage
1427            .pointer("/prompt_tokens_details/cached_tokens")
1428            .and_then(Value::as_u64)
1429            .or_else(|| usage.get("cache_read_input_tokens").and_then(Value::as_u64)),
1430        cache_write_tokens: usage
1431            .get("cache_creation_input_tokens")
1432            .and_then(Value::as_u64),
1433        reasoning_tokens: usage
1434            .pointer("/completion_tokens_details/reasoning_tokens")
1435            .and_then(Value::as_u64),
1436        raw: Some(usage.clone()),
1437    }
1438}
1439
1440fn parse_json_or_string(value: &str) -> Value {
1441    serde_json::from_str(value).unwrap_or_else(|_| Value::String(value.to_string()))
1442}
1443
1444fn openai_chat_reasoning_effort(config: Option<&ReasoningConfig>) -> Option<&'static str> {
1445    let config = config?;
1446    if let Some(effort) = config.effort {
1447        return Some(match effort {
1448            crate::types::ReasoningEffort::None => "none",
1449            crate::types::ReasoningEffort::Minimal => "minimal",
1450            crate::types::ReasoningEffort::Low => "low",
1451            crate::types::ReasoningEffort::Medium => "medium",
1452            crate::types::ReasoningEffort::High => "high",
1453            crate::types::ReasoningEffort::XHigh => "xhigh",
1454            crate::types::ReasoningEffort::Max => "max",
1455            crate::types::ReasoningEffort::Ultra => "ultra",
1456        });
1457    }
1458
1459    match config.mode {
1460        Some(ReasoningMode::Disabled) => Some("none"),
1461        _ => None,
1462    }
1463}
1464
1465fn text_content(message: &NormalizedMessage) -> String {
1466    message
1467        .parts
1468        .iter()
1469        .filter_map(|part| match part {
1470            Part::Text { text, .. } => Some(text.as_str()),
1471            _ => None,
1472        })
1473        .collect::<Vec<_>>()
1474        .join("\n")
1475}
1476
1477fn image_source_url(source: &crate::types::ImageSource) -> String {
1478    match source {
1479        crate::types::ImageSource::Url { url } => url.clone(),
1480        crate::types::ImageSource::Base64 { media_type, data } => {
1481            format!("data:{media_type};base64,{data}")
1482        }
1483        crate::types::ImageSource::FileRef { uri, .. } => uri.clone(),
1484    }
1485}
1486
1487fn content_value(parts: &[Part]) -> Value {
1488    let has_image = parts
1489        .iter()
1490        .any(|part| matches!(part, Part::ImageUrl { .. } | Part::Image { .. }));
1491    if !has_image {
1492        return Value::String(
1493            parts
1494                .iter()
1495                .filter_map(|part| match part {
1496                    Part::Text { text, .. } => Some(text.as_str()),
1497                    _ => None,
1498                })
1499                .collect::<Vec<_>>()
1500                .join("\n"),
1501        );
1502    }
1503
1504    Value::Array(
1505        parts
1506            .iter()
1507            .filter_map(|part| match part {
1508                Part::Text { text, .. } => Some(json!({"type": "text", "text": text})),
1509                Part::ImageUrl { image_url } => Some(json!({
1510                    "type": "image_url",
1511                    "image_url": {
1512                        "url": image_url.url,
1513                        "detail": image_url.detail,
1514                    }
1515                })),
1516                Part::Image { image } => Some(json!({
1517                    "type": "image_url",
1518                    "image_url": {
1519                        "url": image_source_url(&image.source),
1520                        "detail": image.detail,
1521                    }
1522                })),
1523                _ => None,
1524            })
1525            .collect(),
1526    )
1527}
1528
1529#[cfg(test)]
1530mod tests {
1531    #[test]
1532    fn in_place_system_and_developer_keep_history_positions() {
1533        use crate::normalize::{Protocol, SystemPlacement};
1534        let mut profile = crate::profile::ProviderProfile::new("test-chat");
1535        profile.normalize.system_placement = SystemPlacement::FirstToTopRestInPlace;
1536        let request = crate::types::ChatRequest::new(vec![
1537            crate::types::Message::system("base"),
1538            crate::types::Message::user("hi"),
1539            crate::types::Message::new(
1540                crate::types::Role::Developer,
1541                vec![crate::types::Part::text("skill body")],
1542            ),
1543        ]);
1544        let (normalized, _report) =
1545            super::super::normalize_for_protocol(&request, Protocol::OpenAiChat, Some(&profile))
1546                .expect("normalize");
1547        let body =
1548            to_openai_chat_body_with_profile("m", &normalized, &request, Some(&profile), None)
1549                .expect("body");
1550        let msgs = body["messages"].as_array().expect("messages");
1551        assert_eq!(msgs[0]["role"], "system");
1552        assert_eq!(msgs[0]["content"], "base");
1553        assert_eq!(msgs[1]["role"], "user");
1554        assert_eq!(msgs[2]["role"], "developer");
1555        assert_eq!(msgs[2]["content"], "skill body");
1556    }
1557
1558    use super::*;
1559    use crate::normalize::{Protocol, normalize};
1560
1561    #[test]
1562    fn reasoning_content_round_trips_cjk() {
1563        let response = from_openai_chat_response(json!({
1564            "choices": [{
1565                "message": {
1566                    "role": "assistant",
1567                    "reasoning_content": "我先检查边界,再回答:你好,世界。",
1568                    "content": "最终答案"
1569                }
1570            }]
1571        }))
1572        .unwrap();
1573
1574        let reasoning = response.reasoning().next().unwrap();
1575        assert_eq!(reasoning.kind, ReasoningKind::Text);
1576        assert_eq!(
1577            reasoning.text.as_deref(),
1578            Some("我先检查边界,再回答:你好,世界。")
1579        );
1580        assert_eq!(response.text(), "最终答案");
1581
1582        let request = ChatRequest::new([response.message]);
1583        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1584        let body = to_openai_chat_body("deepseek-reasoner", &normalized, &request, None).unwrap();
1585        assert_eq!(
1586            body.pointer("/messages/0/reasoning_content")
1587                .and_then(Value::as_str),
1588            Some("我先检查边界,再回答:你好,世界。")
1589        );
1590    }
1591
1592    #[test]
1593    fn reasoning_details_round_trip_in_order() {
1594        let response = from_openai_chat_response(json!({
1595            "choices": [{
1596                "message": {
1597                    "role": "assistant",
1598                    "reasoning_details": [
1599                        {"type": "reasoning.summary", "text": "摘要"},
1600                        {"type": "reasoning.encrypted", "data": "opaque"}
1601                    ],
1602                    "content": "answer"
1603                }
1604            }]
1605        }))
1606        .unwrap();
1607
1608        let reasoning: Vec<_> = response.reasoning().collect();
1609        assert_eq!(reasoning[0].kind, ReasoningKind::Summary);
1610        assert_eq!(reasoning[0].summary.as_deref(), Some("摘要"));
1611        assert_eq!(reasoning[1].kind, ReasoningKind::Encrypted);
1612
1613        let request = ChatRequest::new([response.message]);
1614        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1615        let body = to_openai_chat_body("compatible", &normalized, &request, None).unwrap();
1616        assert_eq!(
1617            body.pointer("/messages/0/reasoning_details"),
1618            Some(&json!([
1619                {"type": "reasoning.summary", "text": "摘要"},
1620                {"type": "reasoning.encrypted", "data": "opaque"}
1621            ]))
1622        );
1623    }
1624
1625    #[test]
1626    fn neutral_request_controls_map_to_openai_chat() {
1627        let request = ChatRequest::user("hi")
1628            .tools([crate::types::ToolSpec::new(
1629                "lookup",
1630                "lookup",
1631                json!({"type": "object"}),
1632            )])
1633            .tool_choice(ToolChoice::Required)
1634            .response_format(ResponseFormat::JsonSchema {
1635                name: "answer".to_string(),
1636                schema: json!({"type": "object"}),
1637                strict: Some(true),
1638            })
1639            .stop(["END"])
1640            .seed(42);
1641        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1642        let body = to_openai_chat_body("gpt-5", &normalized, &request, None).unwrap();
1643
1644        assert_eq!(body["tool_choice"], "required");
1645        assert_eq!(body["response_format"]["type"], "json_schema");
1646        assert_eq!(body["response_format"]["json_schema"]["strict"], true);
1647        assert_eq!(body["stop"], json!(["END"]));
1648        assert_eq!(body["seed"], 42);
1649    }
1650
1651    #[test]
1652    fn unknown_tool_choice_is_rejected() {
1653        let request = ChatRequest::user("hi")
1654            .tools([crate::types::ToolSpec::new(
1655                "lookup",
1656                "lookup",
1657                json!({"type": "object"}),
1658            )])
1659            .tool_choice(ToolChoice::Tool("missing".to_string()));
1660        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1661        let error = to_openai_chat_body("gpt-5", &normalized, &request, None).unwrap_err();
1662
1663        assert!(matches!(error, Error::InvalidRequest(_)));
1664    }
1665
1666    #[test]
1667    fn reasoning_effort_is_sent() {
1668        let request = ChatRequest::user("hi")
1669            .reasoning(ReasoningConfig::new().effort(crate::types::ReasoningEffort::XHigh));
1670        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1671        let body = to_openai_chat_body("gpt-5", &normalized, &request, None).unwrap();
1672        assert_eq!(body["reasoning_effort"], "xhigh");
1673    }
1674
1675    /// 0.6.0:`ultra` 是 `ReasoningEffort` 的最高档(Codex 桌面端的档位表里
1676    /// `xhigh` 之上那一档)。序列化值与线上值都必须是 `"ultra"`。
1677    #[test]
1678    fn ultra_reasoning_effort_is_sent() {
1679        assert_eq!(
1680            serde_json::to_value(crate::types::ReasoningEffort::Ultra).unwrap(),
1681            json!("ultra")
1682        );
1683        let request = ChatRequest::user("hi")
1684            .reasoning(ReasoningConfig::new().effort(crate::types::ReasoningEffort::Ultra));
1685        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1686        let body = to_openai_chat_body("gpt-5", &normalized, &request, None).unwrap();
1687        assert_eq!(body["reasoning_effort"], "ultra");
1688    }
1689
1690    #[test]
1691    fn extra_body_is_merged_but_cannot_override_canonical_fields() {
1692        let request = ChatRequest::user("hi")
1693            .extra_body("enable_thinking", true)
1694            .extra_body("reasoning_format", "parsed");
1695        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1696        let body = to_openai_chat_body("qwen3", &normalized, &request, None).unwrap();
1697
1698        assert_eq!(body["enable_thinking"], true);
1699        assert_eq!(body["reasoning_format"], "parsed");
1700
1701        let request = ChatRequest::user("hi").extra_body("model", "attacker-model");
1702        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1703        let error = to_openai_chat_body("qwen3", &normalized, &request, None).unwrap_err();
1704        assert!(matches!(
1705            error,
1706            Error::ReservedExtraBodyField { field, .. } if field == "model"
1707        ));
1708    }
1709
1710    #[test]
1711    fn profile_extra_body_is_a_default_and_request_extra_wins() {
1712        let mut profile = ProviderProfile::new("qwen");
1713        profile
1714            .request
1715            .extra_body
1716            .insert("enable_thinking".to_string(), json!(false));
1717        profile
1718            .request
1719            .extra_body
1720            .insert("reasoning_format".to_string(), json!("hidden"));
1721
1722        let request = ChatRequest::user("hi").extra_body("enable_thinking", true);
1723        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1724        let body = to_openai_chat_body("qwen3", &normalized, &request, Some(&profile)).unwrap();
1725
1726        assert_eq!(body["enable_thinking"], true);
1727        assert_eq!(body["reasoning_format"], "hidden");
1728    }
1729
1730    #[test]
1731    fn profile_aliases_control_response_parsing_and_history_replay() {
1732        let aliases = ReasoningAliases::empty()
1733            .text("thinking_text")
1734            .replay("thinking_text")
1735            .encrypted("encrypted_thinking");
1736        let response = from_openai_chat_response_with_aliases(
1737            json!({
1738                "choices": [{
1739                    "message": {
1740                        "role": "assistant",
1741                        "thinking_text": "先检查输入。",
1742                        "encrypted_thinking": "opaque-state",
1743                        "content": "答案"
1744                    }
1745                }]
1746            }),
1747            &aliases,
1748        )
1749        .unwrap();
1750
1751        assert_eq!(response.reasoning_text(), "先检查输入。");
1752        assert_eq!(response.text(), "答案");
1753        assert_eq!(response.reasoning().count(), 2);
1754
1755        let mut profile = ProviderProfile::new("custom-compatible");
1756        profile.reasoning.aliases = aliases;
1757        let request = ChatRequest::new([response.message]);
1758        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1759        let body =
1760            to_openai_chat_body("custom-model", &normalized, &request, Some(&profile)).unwrap();
1761
1762        assert_eq!(body["messages"][0]["thinking_text"], "先检查输入。");
1763        assert_eq!(body["messages"][0]["encrypted_thinking"], "opaque-state");
1764    }
1765
1766    #[test]
1767    fn profile_thinking_request_maps_neutral_config() {
1768        let mut profile = ProviderProfile::new("qwen");
1769        profile.reasoning.thinking = ThinkingRequestProfile::Composite(vec![
1770            ThinkingRequestProfile::EnabledFlag("enable_thinking".to_string()),
1771            ThinkingRequestProfile::BudgetTokens("thinking_budget".to_string()),
1772        ]);
1773
1774        let request = ChatRequest::user("hi").reasoning(
1775            ReasoningConfig::new()
1776                .mode(ReasoningMode::Enabled)
1777                .budget_tokens(2048),
1778        );
1779        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1780        let body = to_openai_chat_body("qwen3", &normalized, &request, Some(&profile)).unwrap();
1781
1782        assert_eq!(body["enable_thinking"], true);
1783        assert_eq!(body["thinking_budget"], 2048);
1784
1785        let request =
1786            ChatRequest::user("hi").reasoning(ReasoningConfig::new().mode(ReasoningMode::Disabled));
1787        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1788        let body = to_openai_chat_body("qwen3", &normalized, &request, Some(&profile)).unwrap();
1789
1790        assert_eq!(body["enable_thinking"], false);
1791        assert!(body.get("thinking_budget").is_none());
1792    }
1793
1794    #[test]
1795    fn replay_policy_never_drops_reasoning_history() {
1796        let response = from_openai_chat_response(json!({
1797            "choices": [{
1798                "message": {
1799                    "role": "assistant",
1800                    "reasoning_content": "private",
1801                    "content": "answer"
1802                }
1803            }]
1804        }))
1805        .unwrap();
1806
1807        let mut profile = ProviderProfile::new("private-history");
1808        profile.reasoning.replay = ReasoningReplayPolicy::Never;
1809        let request = ChatRequest::new([response.message]);
1810        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1811        let body =
1812            to_openai_chat_body("private-model", &normalized, &request, Some(&profile)).unwrap();
1813
1814        assert!(body["messages"][0].get("reasoning_content").is_none());
1815    }
1816
1817    #[test]
1818    fn model_profile_overrides_provider_thinking_and_aliases() {
1819        let mut provider = ProviderProfile::new("moonshot");
1820        provider.reasoning.thinking =
1821            ThinkingRequestProfile::EnabledFlag("enable_thinking".to_string());
1822        provider.reasoning.aliases = ReasoningAliases::default();
1823
1824        let model_profile = ModelProfile {
1825            matcher: crate::profile::ModelMatcher::Prefix("kimi-k3".to_string()),
1826            thinking: ThinkingRequestProfile::Effort("reasoning_effort".to_string()),
1827            reasoning_aliases: ReasoningAliases::empty()
1828                .text("reasoning_content")
1829                .replay("reasoning_content"),
1830            replay: Some(ReasoningReplayPolicy::SameProvider),
1831            ..ModelProfile::default()
1832        };
1833
1834        let request = ChatRequest::user("hi")
1835            .reasoning(ReasoningConfig::new().effort(crate::types::ReasoningEffort::High));
1836        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1837        let body = to_openai_chat_body_with_profile(
1838            "kimi-k3",
1839            &normalized,
1840            &request,
1841            Some(&provider),
1842            Some(&model_profile),
1843        )
1844        .unwrap();
1845
1846        assert_eq!(body["reasoning_effort"], "high");
1847        assert!(body.get("enable_thinking").is_none());
1848    }
1849
1850    #[test]
1851    fn domestic_profile_presets_emit_documented_request_fields() {
1852        let deepseek = ChatRequest::user("hi").reasoning(
1853            ReasoningConfig::new()
1854                .effort(crate::types::ReasoningEffort::Minimal)
1855                .budget_tokens(1024),
1856        );
1857        let (normalized, _) = normalize(&deepseek, Protocol::OpenAiChat).unwrap();
1858        let body = to_openai_chat_body(
1859            "deepseek-reasoner",
1860            &normalized,
1861            &deepseek,
1862            Some(&ProviderProfile::deepseek_compatible()),
1863        )
1864        .unwrap();
1865        assert_eq!(body["thinking"]["type"], "enabled");
1866        assert_eq!(body["thinking"]["budget_tokens"], 1024);
1867        assert_eq!(body["reasoning_effort"], "low");
1868
1869        let qwen = ChatRequest::user("hi").reasoning(
1870            ReasoningConfig::new()
1871                .mode(ReasoningMode::Enabled)
1872                .budget_tokens(2048),
1873        );
1874        let (normalized, _) = normalize(&qwen, Protocol::OpenAiChat).unwrap();
1875        let body = to_openai_chat_body(
1876            "qwen3",
1877            &normalized,
1878            &qwen,
1879            Some(&ProviderProfile::qwen_compatible()),
1880        )
1881        .unwrap();
1882        assert_eq!(body["enable_thinking"], true);
1883        assert_eq!(body["thinking_budget"], 2048);
1884
1885        let glm =
1886            ChatRequest::user("hi").reasoning(ReasoningConfig::new().mode(ReasoningMode::Disabled));
1887        let (normalized, _) = normalize(&glm, Protocol::OpenAiChat).unwrap();
1888        let body = to_openai_chat_body(
1889            "glm-4.7",
1890            &normalized,
1891            &glm,
1892            Some(&ProviderProfile::glm_compatible()),
1893        )
1894        .unwrap();
1895        assert_eq!(body["thinking"]["type"], "disabled");
1896
1897        let kimi = ChatRequest::user("hi")
1898            .reasoning(ReasoningConfig::new().effort(crate::types::ReasoningEffort::High));
1899        let (normalized, _) = normalize(&kimi, Protocol::OpenAiChat).unwrap();
1900        let body = to_openai_chat_body(
1901            "kimi-k3",
1902            &normalized,
1903            &kimi,
1904            Some(&ProviderProfile::kimi_compatible()),
1905        )
1906        .unwrap();
1907        assert_eq!(body["reasoning_effort"], "high");
1908    }
1909
1910    #[test]
1911    fn doubao_preset_replays_encrypted_content_for_tool_turns() {
1912        let aliases = ReasoningAliases::empty()
1913            .text("reasoning_content")
1914            .replay("reasoning_content")
1915            .encrypted("encrypted_content");
1916        let response = from_openai_chat_response_with_aliases(
1917            json!({
1918                "choices": [{
1919                    "message": {
1920                        "role": "assistant",
1921                        "reasoning_content": "tool reasoning",
1922                        "encrypted_content": "opaque",
1923                        "tool_calls": [{
1924                            "id": "call_1",
1925                            "type": "function",
1926                            "function": {"name": "lookup", "arguments": "{}"}
1927                        }]
1928                    }
1929                }]
1930            }),
1931            &aliases,
1932        )
1933        .unwrap();
1934
1935        let request = ChatRequest::new([response.message]);
1936        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1937        let body = to_openai_chat_body(
1938            "doubao-seed",
1939            &normalized,
1940            &request,
1941            Some(&ProviderProfile::doubao_compatible()),
1942        )
1943        .unwrap();
1944
1945        assert_eq!(body["messages"][0]["reasoning_content"], "tool reasoning");
1946        assert_eq!(body["messages"][0]["encrypted_content"], "opaque");
1947    }
1948
1949    #[test]
1950    fn kimi_model_presets_map_k3_and_k2_6_controls() {
1951        let k3 = ChatRequest::user("hi")
1952            .reasoning(ReasoningConfig::new().effort(crate::types::ReasoningEffort::High));
1953        let (normalized, _) = normalize(&k3, Protocol::OpenAiChat).unwrap();
1954        let body = to_openai_chat_body_with_profile(
1955            "kimi-k3",
1956            &normalized,
1957            &k3,
1958            Some(&ProviderProfile::kimi_compatible()),
1959            Some(&ModelProfile::kimi_k3()),
1960        )
1961        .unwrap();
1962        assert_eq!(body["reasoning_effort"], "high");
1963
1964        let k2_6 =
1965            ChatRequest::user("hi").reasoning(ReasoningConfig::new().mode(ReasoningMode::Enabled));
1966        let (normalized, _) = normalize(&k2_6, Protocol::OpenAiChat).unwrap();
1967        let body = to_openai_chat_body_with_profile(
1968            "kimi-k2.6",
1969            &normalized,
1970            &k2_6,
1971            Some(&ProviderProfile::kimi_compatible()),
1972            Some(&ModelProfile::kimi_k2_6()),
1973        )
1974        .unwrap();
1975        assert_eq!(body["thinking"]["type"], "enabled");
1976        assert_eq!(body["thinking"]["keep"], "all");
1977    }
1978
1979    #[test]
1980    fn static_thinking_fields_apply_without_reasoning_config() {
1981        let mut profile = ProviderProfile::new("custom");
1982        profile.reasoning.thinking = ThinkingRequestProfile::Field {
1983            path: "clear_thinking".to_string(),
1984            value: Value::Bool(false),
1985        };
1986        let request = ChatRequest::user("hi");
1987        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
1988        let body =
1989            to_openai_chat_body("custom-model", &normalized, &request, Some(&profile)).unwrap();
1990
1991        assert_eq!(body["clear_thinking"], false);
1992    }
1993
1994    #[test]
1995    fn model_profile_can_replace_budget_with_effort_controls() {
1996        let model_profile = ModelProfile {
1997            matcher: crate::profile::ModelMatcher::Prefix("qwen-effort".to_string()),
1998            thinking: ThinkingRequestProfile::MappedEffort {
1999                field: "reasoning_effort".to_string(),
2000                mapping: crate::profile::EffortMapping::identity(),
2001            },
2002            reasoning_aliases: ReasoningAliases::empty()
2003                .text("reasoning_content")
2004                .replay("reasoning_content"),
2005            replay: Some(ReasoningReplayPolicy::SameProvider),
2006            ..ModelProfile::default()
2007        };
2008        let request = ChatRequest::user("hi").reasoning(
2009            ReasoningConfig::new()
2010                .effort(crate::types::ReasoningEffort::High)
2011                .budget_tokens(2048),
2012        );
2013        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
2014        let body = to_openai_chat_body_with_profile(
2015            "qwen-effort-235b",
2016            &normalized,
2017            &request,
2018            Some(&ProviderProfile::qwen_compatible()),
2019            Some(&model_profile),
2020        )
2021        .unwrap();
2022
2023        assert_eq!(body["reasoning_effort"], "high");
2024        assert!(body.get("enable_thinking").is_none());
2025        assert!(body.get("thinking_budget").is_none());
2026    }
2027
2028    #[test]
2029    fn doubao_preset_drops_reasoning_when_turn_has_no_tool_calls() {
2030        let response = from_openai_chat_response_with_aliases(
2031            json!({
2032                "choices": [{
2033                    "message": {
2034                        "role": "assistant",
2035                        "reasoning_content": "private",
2036                        "encrypted_content": "opaque",
2037                        "content": "answer"
2038                    }
2039                }]
2040            }),
2041            &ReasoningAliases::empty()
2042                .text("reasoning_content")
2043                .replay("reasoning_content")
2044                .encrypted("encrypted_content"),
2045        )
2046        .unwrap();
2047
2048        let request = ChatRequest::new([response.message]);
2049        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
2050        let body = to_openai_chat_body(
2051            "doubao-seed",
2052            &normalized,
2053            &request,
2054            Some(&ProviderProfile::doubao_compatible()),
2055        )
2056        .unwrap();
2057
2058        assert!(body["messages"][0].get("reasoning_content").is_none());
2059        assert!(body["messages"][0].get("encrypted_content").is_none());
2060    }
2061
2062    #[test]
2063    fn model_profile_without_replay_inherits_provider_policy() {
2064        let aliases = ReasoningAliases::empty()
2065            .text("reasoning_content")
2066            .replay("reasoning_content")
2067            .encrypted("encrypted_content");
2068        let response = from_openai_chat_response_with_aliases(
2069            json!({
2070                "choices": [{
2071                    "message": {
2072                        "role": "assistant",
2073                        "encrypted_content": "opaque",
2074                        "tool_calls": [{
2075                            "id": "call_1",
2076                            "type": "function",
2077                            "function": {"name": "lookup", "arguments": "{}"}
2078                        }]
2079                    }
2080                }]
2081            }),
2082            &aliases,
2083        )
2084        .unwrap();
2085
2086        let request = ChatRequest::new([response.message]);
2087        let (normalized, _) = normalize(&request, Protocol::OpenAiChat).unwrap();
2088        let body = to_openai_chat_body_with_profile(
2089            "doubao-seed",
2090            &normalized,
2091            &request,
2092            Some(&ProviderProfile::doubao_compatible()),
2093            Some(&ModelProfile::default()),
2094        )
2095        .unwrap();
2096
2097        assert_eq!(body["messages"][0]["encrypted_content"], "opaque");
2098    }
2099
2100    #[test]
2101    fn stream_mapper_uses_profile_aliases() {
2102        let aliases = ReasoningAliases::empty()
2103            .text("thinking_text")
2104            .replay("thinking_text");
2105        let metadata = ResponseMetadata {
2106            status: 200,
2107            request_id: None,
2108            headers: HeaderMap::new(),
2109        };
2110        let mut mapper =
2111            OpenAiChatStreamMapper::with_aliases("custom-model".to_string(), metadata, aliases);
2112
2113        let events = mapper
2114            .map(SseMessage {
2115                event: None,
2116                data: json!({
2117                    "choices": [{
2118                        "delta": {"thinking_text": "先分析", "content": "答案"},
2119                        "finish_reason": null
2120                    }]
2121                })
2122                .to_string(),
2123                id: None,
2124            })
2125            .unwrap();
2126        assert!(events.iter().any(|event| matches!(
2127            event,
2128            StreamEvent::ReasoningDelta { text, .. } if text == "先分析"
2129        )));
2130
2131        let events = mapper
2132            .map(SseMessage {
2133                event: None,
2134                data: "[DONE]".to_string(),
2135                id: None,
2136            })
2137            .unwrap();
2138        let response = events
2139            .into_iter()
2140            .find_map(|event| match event {
2141                StreamEvent::Done { response, .. } => Some(response),
2142                _ => None,
2143            })
2144            .unwrap();
2145        assert_eq!(response.reasoning_text(), "先分析");
2146        assert_eq!(response.text(), "答案");
2147    }
2148
2149    #[test]
2150    fn stream_assembles_reasoning_text_and_tool_arguments() {
2151        let metadata = ResponseMetadata {
2152            status: 200,
2153            request_id: Some("req-stream".to_string()),
2154            headers: HeaderMap::new(),
2155        };
2156        let mut mapper = OpenAiChatStreamMapper::new("deepseek-reasoner".to_string(), metadata);
2157        let chunks = [
2158            json!({
2159                "choices": [{
2160                    "delta": {
2161                        "role": "assistant",
2162                        "reasoning_content": "先检查边界,",
2163                        "tool_calls": [{
2164                            "index": 0,
2165                            "id": "call_1",
2166                            "function": {"name": "lookup", "arguments": "{\"q\":"}
2167                        }]
2168                    },
2169                    "finish_reason": null
2170                }]
2171            }),
2172            json!({
2173                "choices": [{
2174                    "delta": {
2175                        "reasoning_content": "再调用工具。",
2176                        "content": "结果如下",
2177                        "tool_calls": [{
2178                            "index": 0,
2179                            "function": {"arguments": "\"Rust\"}"}
2180                        }]
2181                    },
2182                    "finish_reason": "tool_calls"
2183                }]
2184            }),
2185            json!({
2186                "choices": [],
2187                "usage": {"prompt_tokens": 10, "completion_tokens": 5}
2188            }),
2189        ];
2190
2191        let mut events = Vec::new();
2192        for chunk in chunks {
2193            events.extend(
2194                mapper
2195                    .map(SseMessage {
2196                        event: None,
2197                        data: chunk.to_string(),
2198                        id: None,
2199                    })
2200                    .unwrap(),
2201            );
2202        }
2203        events.extend(
2204            mapper
2205                .map(SseMessage {
2206                    event: None,
2207                    data: "[DONE]".to_string(),
2208                    id: None,
2209                })
2210                .unwrap(),
2211        );
2212
2213        assert!(events.iter().any(|event| matches!(
2214            event,
2215            StreamEvent::ReasoningDelta { text, .. } if text == "先检查边界,"
2216        )));
2217        assert!(events.iter().any(|event| matches!(
2218            event,
2219            StreamEvent::TextDelta { text } if text == "结果如下"
2220        )));
2221        assert!(events.iter().any(|event| matches!(
2222            event,
2223            StreamEvent::ToolCallDelta {
2224                index: 0,
2225                arguments_delta,
2226                ..
2227            } if arguments_delta == "\"Rust\"}"
2228        )));
2229
2230        let StreamEvent::Done {
2231            response,
2232            finish_reason,
2233        } = events.last().unwrap()
2234        else {
2235            panic!("expected done event");
2236        };
2237        assert_eq!(finish_reason.as_deref(), Some("tool_calls"));
2238        assert_eq!(response.text(), "结果如下");
2239        assert_eq!(response.reasoning_text(), "先检查边界,再调用工具。");
2240        let call = response.tool_calls().next().unwrap();
2241        assert_eq!(call.name, "lookup");
2242        assert_eq!(call.arguments, json!({"q": "Rust"}));
2243        assert_eq!(response.usage.as_ref().unwrap().input_tokens, Some(10));
2244    }
2245}