openai_protocol/
chat.rs

1use std::collections::HashMap;
2
3use serde::{Deserialize, Serialize};
4use serde_json::Value;
5use validator::Validate;
6
7use super::{
8    common::{
9        default_model, default_true, validate_stop, ChatLogProbs, ContentPart, Function,
10        FunctionCall, FunctionChoice, GenerationRequest, ResponseFormat, StreamOptions,
11        StringOrArray, Tool, ToolCall, ToolCallDelta, ToolChoice, ToolChoiceValue, ToolReference,
12        Usage,
13    },
14    sampling_params::{validate_top_k_value, validate_top_p_value},
15};
16use crate::{
17    builders::{ChatCompletionResponseBuilder, ChatCompletionStreamResponseBuilder},
18    validated::Normalizable,
19};
20
21// ============================================================================
22// Chat Messages
23// ============================================================================
24
25#[serde_with::skip_serializing_none]
26#[derive(Debug, Clone, Deserialize, Serialize)]
27#[serde(tag = "role")]
28pub enum ChatMessage {
29    #[serde(rename = "system")]
30    System {
31        content: MessageContent,
32        name: Option<String>,
33    },
34    #[serde(rename = "user")]
35    User {
36        content: MessageContent,
37        name: Option<String>,
38    },
39    #[serde(rename = "assistant")]
40    Assistant {
41        content: Option<MessageContent>,
42        name: Option<String>,
43        tool_calls: Option<Vec<ToolCall>>,
44        /// Reasoning content for O1-style models (SGLang extension)
45        reasoning_content: Option<String>,
46    },
47    #[serde(rename = "tool")]
48    Tool {
49        content: MessageContent,
50        tool_call_id: String,
51    },
52    #[serde(rename = "function")]
53    Function { content: String, name: String },
54    #[serde(rename = "developer")]
55    Developer {
56        content: MessageContent,
57        tools: Option<Vec<Tool>>,
58        name: Option<String>,
59    },
60}
61
62#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
63#[serde(untagged)]
64pub enum MessageContent {
65    Text(String),
66    Parts(Vec<ContentPart>),
67}
68
69impl MessageContent {
70    /// Returns the text content, cloning only when necessary.
71    /// For simple text, returns a clone of the string.
72    /// For parts, concatenates text parts with spaces.
73    /// Optimized to avoid intermediate Vec allocation.
74    pub fn to_simple_string(&self) -> String {
75        match self {
76            MessageContent::Text(text) => text.clone(),
77            MessageContent::Parts(parts) => {
78                // Use fold to build string directly without intermediate Vec allocation
79                let mut result = String::new();
80                let mut first = true;
81                for part in parts {
82                    if let ContentPart::Text { text } = part {
83                        if !first {
84                            result.push(' ');
85                        }
86                        result.push_str(text);
87                        first = false;
88                    }
89                }
90                result
91            }
92        }
93    }
94
95    /// Appends text content directly to a buffer, avoiding intermediate allocations.
96    /// Returns true if any content was appended.
97    #[inline]
98    pub fn append_text_to(&self, buffer: &mut String) -> bool {
99        match self {
100            MessageContent::Text(text) => {
101                if !text.is_empty() {
102                    buffer.push_str(text);
103                    true
104                } else {
105                    false
106                }
107            }
108            MessageContent::Parts(parts) => {
109                let mut appended = false;
110                for part in parts {
111                    if let ContentPart::Text { text } = part {
112                        if !text.is_empty() {
113                            if appended {
114                                buffer.push(' ');
115                            }
116                            buffer.push_str(text);
117                            appended = true;
118                        }
119                    }
120                }
121                appended
122            }
123        }
124    }
125
126    /// Returns true if this content contains any non-empty text.
127    #[inline]
128    pub fn has_text(&self) -> bool {
129        match self {
130            MessageContent::Text(text) => !text.is_empty(),
131            MessageContent::Parts(parts) => parts
132                .iter()
133                .any(|part| matches!(part, ContentPart::Text { text } if !text.is_empty())),
134        }
135    }
136}
137
138// ============================================================================
139// Chat Completion Request
140// ============================================================================
141
142#[serde_with::skip_serializing_none]
143#[derive(Debug, Clone, Deserialize, Serialize, Default, Validate)]
144#[validate(schema(function = "validate_chat_cross_parameters"))]
145pub struct ChatCompletionRequest {
146    /// A list of messages comprising the conversation so far
147    #[validate(custom(function = "validate_messages"))]
148    pub messages: Vec<ChatMessage>,
149
150    /// ID of the model to use
151    #[serde(default = "default_model")]
152    pub model: String,
153
154    /// Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far
155    #[validate(range(min = -2.0, max = 2.0))]
156    pub frequency_penalty: Option<f32>,
157
158    /// Deprecated: Replaced by tool_choice
159    #[deprecated(note = "Use tool_choice instead")]
160    pub function_call: Option<FunctionCall>,
161
162    /// Deprecated: Replaced by tools
163    #[deprecated(note = "Use tools instead")]
164    pub functions: Option<Vec<Function>>,
165
166    /// Modify the likelihood of specified tokens appearing in the completion
167    pub logit_bias: Option<HashMap<String, f32>>,
168
169    /// Whether to return log probabilities of the output tokens
170    #[serde(default)]
171    pub logprobs: bool,
172
173    /// Deprecated: Replaced by max_completion_tokens
174    #[deprecated(note = "Use max_completion_tokens instead")]
175    #[validate(range(min = 1))]
176    pub max_tokens: Option<u32>,
177
178    /// An upper bound for the number of tokens that can be generated for a completion
179    #[validate(range(min = 1))]
180    pub max_completion_tokens: Option<u32>,
181
182    /// Developer-defined tags and values used for filtering completions in the dashboard
183    pub metadata: Option<HashMap<String, String>>,
184
185    /// Output types that you would like the model to generate for this request
186    pub modalities: Option<Vec<String>>,
187
188    /// How many chat completion choices to generate for each input message
189    #[validate(range(min = 1, max = 10))]
190    pub n: Option<u32>,
191
192    /// Whether to enable parallel function calling during tool use
193    pub parallel_tool_calls: Option<bool>,
194
195    /// Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far
196    #[validate(range(min = -2.0, max = 2.0))]
197    pub presence_penalty: Option<f32>,
198
199    /// Cache key for prompts (beta feature)
200    pub prompt_cache_key: Option<String>,
201
202    /// Effort level for reasoning models (low, medium, high)
203    pub reasoning_effort: Option<String>,
204
205    /// An object specifying the format that the model must output
206    pub response_format: Option<ResponseFormat>,
207
208    /// Safety identifier for content moderation
209    pub safety_identifier: Option<String>,
210
211    /// Deprecated: This feature is in Legacy mode
212    #[deprecated(note = "This feature is in Legacy mode")]
213    pub seed: Option<i64>,
214
215    /// The service tier to use for this request
216    pub service_tier: Option<String>,
217
218    /// Up to 4 sequences where the API will stop generating further tokens
219    #[validate(custom(function = "validate_stop"))]
220    pub stop: Option<StringOrArray>,
221
222    /// If set, partial message deltas will be sent
223    #[serde(default)]
224    pub stream: bool,
225
226    /// Options for streaming response
227    pub stream_options: Option<StreamOptions>,
228
229    /// What sampling temperature to use, between 0 and 2
230    #[validate(range(min = 0.0, max = 2.0))]
231    pub temperature: Option<f32>,
232
233    /// Controls which (if any) tool is called by the model
234    pub tool_choice: Option<ToolChoice>,
235
236    /// A list of tools the model may call
237    pub tools: Option<Vec<Tool>>,
238
239    /// An integer between 0 and 20 specifying the number of most likely tokens to return
240    #[validate(range(min = 0, max = 20))]
241    pub top_logprobs: Option<u32>,
242
243    /// An alternative to sampling with temperature
244    #[validate(custom(function = "validate_top_p_value"))]
245    pub top_p: Option<f32>,
246
247    /// Verbosity level for debugging
248    pub verbosity: Option<i32>,
249
250    // =============================================================================
251    // Engine-Specific Sampling Parameters
252    // =============================================================================
253    // These parameters are extensions beyond the OpenAI API specification and
254    // control model generation behavior in engine-specific ways.
255    // =============================================================================
256    /// Top-k sampling parameter (-1 to disable)
257    #[validate(custom(function = "validate_top_k_value"))]
258    pub top_k: Option<i32>,
259
260    /// Min-p nucleus sampling parameter
261    #[validate(range(min = 0.0, max = 1.0))]
262    pub min_p: Option<f32>,
263
264    /// Minimum number of tokens to generate
265    #[validate(range(min = 1))]
266    pub min_tokens: Option<u32>,
267
268    /// Repetition penalty for reducing repetitive text
269    #[validate(range(min = 0.0, max = 2.0))]
270    pub repetition_penalty: Option<f32>,
271
272    /// Regex constraint for output generation
273    pub regex: Option<String>,
274
275    /// EBNF grammar constraint for structured output
276    pub ebnf: Option<String>,
277
278    /// Specific token IDs to use as stop conditions
279    pub stop_token_ids: Option<Vec<u32>>,
280
281    /// Skip trimming stop tokens from output
282    #[serde(default)]
283    pub no_stop_trim: bool,
284
285    /// Ignore end-of-sequence tokens during generation
286    #[serde(default)]
287    pub ignore_eos: bool,
288
289    /// Continue generating from final assistant message
290    #[serde(default)]
291    pub continue_final_message: bool,
292
293    /// Skip special tokens during detokenization
294    #[serde(default = "default_true")]
295    pub skip_special_tokens: bool,
296
297    /// Path to LoRA adapter(s) for model customization
298    pub lora_path: Option<String>,
299
300    /// Session parameters for continual prompting
301    pub session_params: Option<HashMap<String, Value>>,
302
303    /// Separate reasoning content from final answer (O1-style models)
304    #[serde(default = "default_true")]
305    pub separate_reasoning: bool,
306
307    /// Stream reasoning tokens during generation
308    #[serde(default = "default_true")]
309    pub stream_reasoning: bool,
310
311    /// Chat template kwargs
312    pub chat_template_kwargs: Option<HashMap<String, Value>>,
313
314    /// Return model hidden states
315    #[serde(default)]
316    pub return_hidden_states: bool,
317
318    /// Random seed for sampling for deterministic outputs
319    pub sampling_seed: Option<u64>,
320}
321
322// ============================================================================
323// Validation Functions
324// ============================================================================
325
326/// Validates messages array is not empty and has valid content
327fn validate_messages(messages: &[ChatMessage]) -> Result<(), validator::ValidationError> {
328    if messages.is_empty() {
329        return Err(validator::ValidationError::new("messages cannot be empty"));
330    }
331
332    for msg in messages.iter() {
333        if let ChatMessage::User { content, .. } = msg {
334            match content {
335                MessageContent::Text(text) if text.is_empty() => {
336                    return Err(validator::ValidationError::new(
337                        "message content cannot be empty",
338                    ));
339                }
340                MessageContent::Parts(parts) if parts.is_empty() => {
341                    return Err(validator::ValidationError::new(
342                        "message content parts cannot be empty",
343                    ));
344                }
345                _ => {}
346            }
347        }
348    }
349    Ok(())
350}
351
352/// Schema-level validation for cross-field dependencies
353fn validate_chat_cross_parameters(
354    req: &ChatCompletionRequest,
355) -> Result<(), validator::ValidationError> {
356    // 1. Validate logprobs dependency
357    if req.top_logprobs.is_some() && !req.logprobs {
358        let mut e = validator::ValidationError::new("top_logprobs_requires_logprobs");
359        e.message = Some("top_logprobs is only allowed when logprobs is enabled".into());
360        return Err(e);
361    }
362
363    // 2. Validate stream_options dependency
364    if req.stream_options.is_some() && !req.stream {
365        let mut e = validator::ValidationError::new("stream_options_requires_stream");
366        e.message =
367            Some("The 'stream_options' parameter is only allowed when 'stream' is enabled".into());
368        return Err(e);
369    }
370
371    // 3. Validate token limits - min <= max
372    if let (Some(min), Some(max)) = (req.min_tokens, req.max_completion_tokens) {
373        if min > max {
374            let mut e = validator::ValidationError::new("min_tokens_exceeds_max");
375            e.message = Some("min_tokens cannot exceed max_tokens/max_completion_tokens".into());
376            return Err(e);
377        }
378    }
379
380    // 4. Validate structured output conflicts
381    let has_json_format = matches!(
382        req.response_format,
383        Some(ResponseFormat::JsonObject | ResponseFormat::JsonSchema { .. })
384    );
385
386    if has_json_format && req.regex.is_some() {
387        let mut e = validator::ValidationError::new("regex_conflicts_with_json");
388        e.message = Some("cannot use regex constraint with JSON response format".into());
389        return Err(e);
390    }
391
392    if has_json_format && req.ebnf.is_some() {
393        let mut e = validator::ValidationError::new("ebnf_conflicts_with_json");
394        e.message = Some("cannot use EBNF constraint with JSON response format".into());
395        return Err(e);
396    }
397
398    // 5. Validate mutually exclusive structured output constraints
399    let constraint_count = [
400        req.regex.is_some(),
401        req.ebnf.is_some(),
402        matches!(req.response_format, Some(ResponseFormat::JsonSchema { .. })),
403    ]
404    .iter()
405    .filter(|&&x| x)
406    .count();
407
408    if constraint_count > 1 {
409        let mut e = validator::ValidationError::new("multiple_constraints");
410        e.message = Some("only one structured output constraint (regex, ebnf, or json_schema) can be active at a time".into());
411        return Err(e);
412    }
413
414    // 6. Validate response format JSON schema name
415    if let Some(ResponseFormat::JsonSchema { json_schema }) = &req.response_format {
416        if json_schema.name.is_empty() {
417            let mut e = validator::ValidationError::new("json_schema_name_empty");
418            e.message = Some("JSON schema name cannot be empty".into());
419            return Err(e);
420        }
421    }
422
423    // 7. Validate tool_choice requires tools (except for "none")
424    if let Some(ref tool_choice) = req.tool_choice {
425        let has_tools = req.tools.as_ref().is_some_and(|t| !t.is_empty());
426
427        // Check if tool_choice is anything other than "none"
428        let is_some_choice = !matches!(tool_choice, ToolChoice::Value(ToolChoiceValue::None));
429
430        if is_some_choice && !has_tools {
431            let mut e = validator::ValidationError::new("tool_choice_requires_tools");
432            e.message = Some("Invalid value for 'tool_choice': 'tool_choice' is only allowed when 'tools' are specified.".into());
433            return Err(e);
434        }
435
436        // Additional validation when tools are present
437        if has_tools {
438            let tools = req.tools.as_ref().unwrap();
439
440            match tool_choice {
441                ToolChoice::Function { function, .. } => {
442                    // Validate that the specified function name exists in tools
443                    let function_exists = tools.iter().any(|tool| {
444                        tool.tool_type == "function" && tool.function.name == function.name
445                    });
446
447                    if !function_exists {
448                        let mut e =
449                            validator::ValidationError::new("tool_choice_function_not_found");
450                        e.message = Some(
451                            format!(
452                            "Invalid value for 'tool_choice': function '{}' not found in 'tools'.",
453                            function.name
454                        )
455                            .into(),
456                        );
457                        return Err(e);
458                    }
459                }
460                ToolChoice::AllowedTools {
461                    mode,
462                    tools: allowed_tools,
463                    ..
464                } => {
465                    // Validate mode is "auto" or "required"
466                    if mode != "auto" && mode != "required" {
467                        let mut e = validator::ValidationError::new("tool_choice_invalid_mode");
468                        e.message = Some(format!(
469                            "Invalid value for 'tool_choice.mode': must be 'auto' or 'required', got '{}'.",
470                            mode
471                        ).into());
472                        return Err(e);
473                    }
474
475                    // Validate that all ToolReferences are Function type (Chat API only supports function tools)
476                    for tool_ref in allowed_tools {
477                        match tool_ref {
478                            ToolReference::Function { name } => {
479                                // Validate that the function exists in tools array
480                                let tool_exists = tools.iter().any(|tool| {
481                                    tool.tool_type == "function" && tool.function.name == *name
482                                });
483
484                                if !tool_exists {
485                                    let mut e = validator::ValidationError::new(
486                                        "tool_choice_tool_not_found",
487                                    );
488                                    e.message = Some(
489                                        format!(
490                                            "Invalid value for 'tool_choice.tools': tool '{}' not found in 'tools'.",
491                                            name
492                                        )
493                                        .into(),
494                                    );
495                                    return Err(e);
496                                }
497                            }
498                            _ => {
499                                // Chat Completion API only supports function tools in tool_choice
500                                let mut e = validator::ValidationError::new(
501                                    "tool_choice_invalid_tool_type",
502                                );
503                                e.message = Some(
504                                    format!(
505                                        "Invalid value for 'tool_choice.tools': Chat Completion API only supports function tools, got '{}'.",
506                                        tool_ref.identifier()
507                                    )
508                                    .into(),
509                                );
510                                return Err(e);
511                            }
512                        }
513                    }
514                }
515                _ => {}
516            }
517        }
518    }
519
520    Ok(())
521}
522
523// ============================================================================
524// Normalizable Implementation
525// ============================================================================
526
527impl Normalizable for ChatCompletionRequest {
528    /// Normalize the request by applying migrations and defaults:
529    /// 1. Migrate deprecated fields to their replacements
530    /// 2. Clear deprecated fields and log warnings
531    /// 3. Apply OpenAI defaults for tool_choice
532    fn normalize(&mut self) {
533        // Migrate deprecated max_tokens → max_completion_tokens
534        #[allow(deprecated)]
535        if self.max_completion_tokens.is_none() && self.max_tokens.is_some() {
536            self.max_completion_tokens = self.max_tokens;
537            self.max_tokens = None; // Clear deprecated field
538        }
539
540        // Migrate deprecated functions → tools
541        #[allow(deprecated)]
542        if self.tools.is_none() && self.functions.is_some() {
543            tracing::warn!("functions is deprecated, use tools instead");
544            self.tools = self.functions.as_ref().map(|functions| {
545                functions
546                    .iter()
547                    .map(|func| Tool {
548                        tool_type: "function".to_string(),
549                        function: func.clone(),
550                    })
551                    .collect()
552            });
553            self.functions = None; // Clear deprecated field
554        }
555
556        // Migrate deprecated function_call → tool_choice
557        #[allow(deprecated)]
558        if self.tool_choice.is_none() && self.function_call.is_some() {
559            tracing::warn!("function_call is deprecated, use tool_choice instead");
560            self.tool_choice = self.function_call.as_ref().map(|fc| match fc {
561                FunctionCall::None => ToolChoice::Value(ToolChoiceValue::None),
562                FunctionCall::Auto => ToolChoice::Value(ToolChoiceValue::Auto),
563                FunctionCall::Function { name } => ToolChoice::Function {
564                    tool_type: "function".to_string(),
565                    function: FunctionChoice { name: name.clone() },
566                },
567            });
568            self.function_call = None; // Clear deprecated field
569        }
570
571        // Apply tool_choice defaults
572        if self.tool_choice.is_none() {
573            if let Some(tools) = &self.tools {
574                let choice_value = if !tools.is_empty() {
575                    ToolChoiceValue::Auto
576                } else {
577                    ToolChoiceValue::None
578                };
579                self.tool_choice = Some(ToolChoice::Value(choice_value));
580            }
581            // If tools is None, leave tool_choice as None (don't set it)
582        }
583    }
584}
585
586// ============================================================================
587// GenerationRequest Trait Implementation
588// ============================================================================
589
590impl GenerationRequest for ChatCompletionRequest {
591    fn is_stream(&self) -> bool {
592        self.stream
593    }
594
595    fn get_model(&self) -> Option<&str> {
596        Some(&self.model)
597    }
598
599    fn extract_text_for_routing(&self) -> String {
600        // Extract text from messages for routing decisions
601        // Use a single buffer to avoid intermediate Vec<String> allocations
602        let mut buffer = String::new();
603        let mut has_content = false;
604
605        for msg in &self.messages {
606            match msg {
607                ChatMessage::System { content, .. }
608                | ChatMessage::User { content, .. }
609                | ChatMessage::Tool { content, .. }
610                | ChatMessage::Developer { content, .. } => {
611                    if has_content && content.has_text() {
612                        buffer.push(' ');
613                    }
614                    if content.append_text_to(&mut buffer) {
615                        has_content = true;
616                    }
617                }
618                ChatMessage::Assistant {
619                    content,
620                    reasoning_content,
621                    ..
622                } => {
623                    // Append main content
624                    if let Some(c) = content {
625                        if has_content && c.has_text() {
626                            buffer.push(' ');
627                        }
628                        if c.append_text_to(&mut buffer) {
629                            has_content = true;
630                        }
631                    }
632                    // Append reasoning content
633                    if let Some(reasoning) = reasoning_content {
634                        if !reasoning.is_empty() {
635                            if has_content {
636                                buffer.push(' ');
637                            }
638                            buffer.push_str(reasoning);
639                            has_content = true;
640                        }
641                    }
642                }
643                ChatMessage::Function { content, .. } => {
644                    if !content.is_empty() {
645                        if has_content {
646                            buffer.push(' ');
647                        }
648                        buffer.push_str(content);
649                        has_content = true;
650                    }
651                }
652            }
653        }
654
655        buffer
656    }
657}
658
659// ============================================================================
660// Response Types
661// ============================================================================
662
663#[serde_with::skip_serializing_none]
664#[derive(Debug, Clone, Deserialize, Serialize)]
665pub struct ChatCompletionResponse {
666    pub id: String,
667    pub object: String, // "chat.completion"
668    pub created: u64,
669    pub model: String,
670    pub choices: Vec<ChatChoice>,
671    pub usage: Option<Usage>,
672    pub system_fingerprint: Option<String>,
673}
674
675impl ChatCompletionResponse {
676    /// Create a new builder for ChatCompletionResponse
677    pub fn builder(
678        id: impl Into<String>,
679        model: impl Into<String>,
680    ) -> ChatCompletionResponseBuilder {
681        ChatCompletionResponseBuilder::new(id, model)
682    }
683}
684
685/// Response message structure for ChatCompletionResponse (different from request ChatMessage)
686#[derive(Debug, Clone, Deserialize, Serialize)]
687pub struct ChatCompletionMessage {
688    pub role: String, // Always "assistant" for responses
689    #[serde(skip_serializing_if = "Option::is_none")]
690    pub content: Option<String>,
691    #[serde(skip_serializing_if = "Option::is_none")]
692    pub tool_calls: Option<Vec<ToolCall>>,
693    pub reasoning_content: Option<String>,
694    // Note: function_call is deprecated and not included
695    // Note: refusal, annotations, audio are not added yet
696}
697
698#[derive(Debug, Clone, Deserialize, Serialize)]
699pub struct ChatChoice {
700    pub index: u32,
701    pub message: ChatCompletionMessage,
702    #[serde(skip_serializing_if = "Option::is_none")]
703    pub logprobs: Option<ChatLogProbs>,
704    pub finish_reason: Option<String>, // "stop", "length", "tool_calls", "content_filter", "function_call"
705    /// Information about which stop condition was matched
706    #[serde(skip_serializing_if = "Option::is_none")]
707    pub matched_stop: Option<Value>, // Can be string or integer
708    /// Hidden states from the model (SGLang extension)
709    #[serde(skip_serializing_if = "Option::is_none")]
710    pub hidden_states: Option<Vec<f32>>,
711}
712
713#[serde_with::skip_serializing_none]
714#[derive(Debug, Clone, Deserialize, Serialize)]
715pub struct ChatCompletionStreamResponse {
716    pub id: String,
717    pub object: String, // "chat.completion.chunk"
718    pub created: u64,
719    pub model: String,
720    pub system_fingerprint: Option<String>,
721    pub choices: Vec<ChatStreamChoice>,
722    pub usage: Option<Usage>,
723}
724
725impl ChatCompletionStreamResponse {
726    /// Create a new builder for ChatCompletionStreamResponse
727    pub fn builder(
728        id: impl Into<String>,
729        model: impl Into<String>,
730    ) -> ChatCompletionStreamResponseBuilder {
731        ChatCompletionStreamResponseBuilder::new(id, model)
732    }
733}
734
735/// Delta structure for streaming chat completion responses
736#[derive(Debug, Clone, Deserialize, Serialize)]
737pub struct ChatMessageDelta {
738    #[serde(skip_serializing_if = "Option::is_none")]
739    pub role: Option<String>,
740    #[serde(skip_serializing_if = "Option::is_none")]
741    pub content: Option<String>,
742    #[serde(skip_serializing_if = "Option::is_none")]
743    pub tool_calls: Option<Vec<ToolCallDelta>>,
744    pub reasoning_content: Option<String>,
745}
746
747#[derive(Debug, Clone, Deserialize, Serialize)]
748pub struct ChatStreamChoice {
749    pub index: u32,
750    pub delta: ChatMessageDelta,
751    pub logprobs: Option<ChatLogProbs>,
752    pub finish_reason: Option<String>,
753    #[serde(skip_serializing_if = "Option::is_none")]
754    pub matched_stop: Option<Value>,
755}
openai_protocol/chat.rs

openai_protocol/
chat.rs
