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
32pub struct OpenAI;
40
41impl OpenAI {
42 pub fn chat(model: impl Into<String>) -> OpenAIChat {
44 OpenAIChat::new(model)
45 }
46
47 pub fn responses(model: impl Into<String>) -> super::OpenAIResponses {
49 super::OpenAIResponses::new(model)
50 }
51}
52
53pub 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 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 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 base_url(mut self, base_url: impl Into<String>) -> Self {
102 self.base_url = base_url.into();
103 self
104 }
105
106 pub fn retry_policy(mut self, retry_policy: RetryPolicy) -> Self {
108 self.retry_policy = retry_policy;
109 self
110 }
111
112 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
424pub(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
440pub(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
872pub(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 pub(crate) fn new(model: String, metadata: ResponseMetadata) -> Self {
897 Self::with_aliases(model, metadata, ReasoningAliases::default())
898 }
899
900 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 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 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 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
1227pub(crate) fn from_openai_chat_response(value: Value) -> Result<ChatResponse> {
1235 from_openai_chat_response_with_aliases(value, &ReasoningAliases::default())
1236}
1237
1238pub(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 #[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}