omniference 0.1.8

//! Official OpenAI API request and response types
//!
//! This module contains all data structures for interacting with the official OpenAI API,
//! including Chat Completions API, Responses API, and all modern OpenAI features like
//! audio, vision, reasoning, and advanced parameters.

use super::openai_compatible::{CompletionTokensDetails, PromptTokensDetails};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// -------------------------
// Chat Completions API Types
// -------------------------

/// OpenAI Chat Completions request structure
///
/// This structure mirrors the official OpenAI Chat Completions API specification
/// and supports all current and legacy parameters for maximum compatibility.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIChatRequest {
	pub model: String,
	pub messages: Vec<OpenAIMessage>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub temperature: Option<f32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub top_p: Option<f32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub max_tokens: Option<u32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub max_completion_tokens: Option<u32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub stream: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub stop: Option<OpenAIStop>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub presence_penalty: Option<f32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub frequency_penalty: Option<f32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub tools: Option<Vec<OpenAIToolSpec>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub tool_choice: Option<OpenAIToolChoice>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub functions: Option<Vec<OpenAIFunctionDef>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub function_call: Option<serde_json::Value>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub response_format: Option<OpenAIResponseFormat>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub logit_bias: Option<std::collections::HashMap<String, f32>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub logprobs: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub top_logprobs: Option<u32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub n: Option<u32>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub seed: Option<u64>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub user: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub stream_options: Option<OpenAIStreamOptions>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub modalities: Option<Vec<String>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub audio: Option<OpenAIAudioParams>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub parallel_tool_calls: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub store: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub prediction: Option<OpenAIPredictionConfig>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub service_tier: Option<OpenAIServiceTier>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub reasoning_effort: Option<OpenAIReasoningEffort>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub verbosity: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub web_search_options: Option<OpenAIWebSearchOptions>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub prompt_cache_key: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub safety_identifier: Option<String>,
}

/// Options for streaming responses
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIStreamOptions {
	pub include_usage: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "lowercase")]
pub enum OpenAIReasoningEffort {
	Minimal,
	Low,
	Medium,
	High,
}

/// Stop sequences - can be a single string or array of strings
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum OpenAIStop {
	Single(String),
	Many(Vec<String>),
}

/// A single message in the conversation
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIMessage {
	pub role: String,
	#[serde(default)]
	pub content: OpenAIMessageContent,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub name: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub tool_calls: Option<Vec<OpenAIToolCall>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub tool_call_id: Option<String>,
}

/// Message content can be simple text or array of content parts
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum OpenAIMessageContent {
	Text(String),
	Parts(Vec<OpenAIContentPart>),
}

impl Default for OpenAIMessageContent {
	fn default() -> Self {
		OpenAIMessageContent::Text(String::new())
	}
}

/// A single content part within a message (text, image, audio, etc.)
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIContentPart {
	#[serde(rename = "type")]
	pub kind: String,
	#[serde(default)]
	pub text: Option<String>,
	#[serde(default)]
	pub image_url: Option<OpenAIImageUrl>,
	#[serde(default)]
	pub audio: Option<OpenAIAudioContent>,
	#[serde(default)]
	pub file: Option<OpenAIFileContent>,
}

/// Image URL specification - can be simple URL or object with detail level
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum OpenAIImageUrl {
	Url(String),
	Obj { url: String, detail: Option<String> },
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIFileContent {
	pub filename: Option<String>,
	pub file_data: Option<String>,
	pub file_id: Option<String>,
}

/// Tool specification (currently only functions are supported)
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIToolSpec {
	pub r#type: String,
	pub function: OpenAIFunctionDef,
}

/// Function definition for tools
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIFunctionDef {
	pub name: String,
	pub description: Option<String>,
	pub parameters: serde_json::Value,
}

/// A tool call made by the assistant
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct OpenAIToolCall {
	pub id: String,
	pub r#type: String,
	pub function: OpenAIFunctionCall,
}

/// Function call details within a tool call
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct OpenAIFunctionCall {
	pub name: String,
	pub arguments: String,
}

/// Tool call delta for streaming
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct OpenAIToolCallDelta {
	pub index: u32,
	pub id: Option<String>,
	pub r#type: Option<String>,
	pub function: Option<OpenAIFunctionCallDelta>,
}

/// Function call delta for streaming
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct OpenAIFunctionCallDelta {
	pub name: Option<String>,
	pub arguments: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIAudioParams {
	pub voice: Option<OpenAIVoice>,
	pub format: Option<OpenAIAudioFormat>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "lowercase")]
pub enum OpenAIVoice {
	Alloy,
	Ash,
	Ballad,
	Coral,
	Echo,
	Fable,
	Nova,
	Onyx,
	Sage,
	Shimmer,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "lowercase")]
pub enum OpenAIAudioFormat {
	Wav,
	Mp3,
	Flac,
	Opus,
	Pcm16,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIAudioContent {
	pub data: String,
	pub format: OpenAIAudioFormat,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIPredictionConfig {
	pub r#type: Option<String>,
	pub content: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "lowercase")]
pub enum OpenAIServiceTier {
	Auto,
	Default,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIWebSearchOptions {
	pub user_location: Option<OpenAIUserLocation>,
	pub search_context_size: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIUserLocation {
	pub r#type: String,
	pub approximate: Option<OpenAIApproximateLocation>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIApproximateLocation {
	pub country: Option<String>,
	pub region: Option<String>,
	pub city: Option<String>,
	pub timezone: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum OpenAIToolChoice {
	String(String),
	Named {
		r#type: String, // "function"
		function: OpenAINamedFunction,
	},
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAINamedFunction {
	pub name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum OpenAIResponseFormat {
	Simple {
		r#type: String, // "text" or "json_object"
	},
	JsonSchema {
		r#type: String, // "json_schema"
		json_schema: OpenAIJsonSchema,
	},
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OpenAIJsonSchema {
	pub description: Option<String>,
	pub name: String,
	pub schema: serde_json::Value,
	pub strict: Option<bool>,
}

#[derive(Deserialize)]
pub struct OpenAIInputMessageItem {
	pub role: Option<String>,
	pub content: Option<Vec<OpenAIInputContentPart>>, // for messages-style input
}

#[derive(Deserialize)]
pub struct OpenAIInputContentPart {
	#[serde(rename = "type")]
	pub kind: String,
	pub text: Option<String>,
	pub image_url: Option<String>,
}

// ---------------------
// Response Types
// ---------------------
#[derive(Serialize, Deserialize)]
pub struct OpenAIChatResponse {
	pub id: String,
	pub object: String,
	pub created: u64,
	pub model: String,
	pub choices: Vec<OpenAIChoice>,
	pub usage: Option<OpenAIUsage>,
	pub service_tier: Option<String>,
	pub system_fingerprint: Option<String>,
}

#[derive(Serialize, Deserialize)]
pub struct OpenAIChoice {
	pub index: u32,
	pub message: Option<OpenAIResponseMessage>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub delta: Option<OpenAIDelta>,
	pub finish_reason: Option<String>,
	pub logprobs: Option<serde_json::Value>,
}

#[derive(Serialize, Deserialize, PartialEq)]
pub struct OpenAIResponseMessage {
	pub role: String,
	pub content: Option<String>,
	pub tool_calls: Option<Vec<OpenAIToolCall>>,
	pub refusal: Option<String>,
	#[serde(default)]
	pub annotations: Vec<serde_json::Value>,
}

#[derive(Serialize, Deserialize, PartialEq)]
pub struct OpenAIDelta {
	pub role: Option<String>,
	pub content: Option<String>,
	pub reasoning_content: Option<String>,
	pub tool_calls: Option<Vec<OpenAIToolCallDelta>>,
}

#[derive(Serialize, Deserialize, PartialEq)]
pub struct OpenAIUsage {
	pub prompt_tokens: u32,
	pub completion_tokens: u32,
	pub total_tokens: u32,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub prompt_tokens_details: Option<PromptTokensDetails>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub completion_tokens_details: Option<CompletionTokensDetails>,
}

#[derive(Serialize, Deserialize)]
pub struct OpenAIStreamChunk {
	pub id: String,
	pub object: String,
	pub created: u64,
	pub model: String,
	pub choices: Vec<OpenAIStreamChoice>,
}

#[derive(Serialize, Deserialize)]
pub struct OpenAIStreamChoice {
	pub index: u32,
	pub delta: OpenAIDelta,
	pub finish_reason: Option<String>,
}

// ---------------------
// OpenAI Responses API Specific Types
// ---------------------

/// Represents a model response.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAIResponsesResponse {
	/// Unique identifier for this Response.
	pub id: String,
	/// The object type, always "response".
	pub object: String,
	/// Unix timestamp (in seconds) of when this Response was created.
	pub created_at: i64,
	/// The status of the response generation.
	pub status: ResponseStatus,
	/// Whether this response was generated in the background.
	pub background: bool,
	/// Billing information for the response.
	pub billing: ResponseBilling,
	/// An array of content items generated by the model.
	pub output: Vec<ResponseOutputItem>,
	/// An error object returned when the model fails to generate a Response.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub error: Option<ResponseError>,
	/// Details about why the response is incomplete.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub incomplete_details: Option<response::IncompleteDetails>,
	/// A system (or developer) message inserted into the model's context.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub instructions: Option<Instructions>,
	/// Set of 16 key-value pairs that can be attached to an object.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub metadata: Option<HashMap<String, String>>,
	/// Model ID used to generate the response.
	pub model: String,
	/// Whether to allow the model to run tool calls in parallel.
	pub parallel_tool_calls: bool,
	/// What sampling temperature to use, between 0 and 2.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub temperature: Option<f64>,
	/// How the model should select which tool (or tools) to use.
	pub tool_choice: ToolChoice,
	/// An array of tools the model may call while generating a response.
	pub tools: Vec<Tool>,
	/// An alternative to sampling with temperature, called nucleus sampling.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub top_p: Option<f64>,
	/// The conversation that this response belongs to.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub conversation: Option<response::Conversation>,
	/// An upper bound for the number of tokens that can be generated for a response.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub max_output_tokens: Option<i64>,
	/// The unique ID of the previous response to the model.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub previous_response_id: Option<String>,
	/// Reference to a prompt template and its variables.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub prompt: Option<ResponsePrompt>,
	/// Used by OpenAI to cache responses for similar requests.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub prompt_cache_key: Option<String>,
	/// Configuration options for reasoning models.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub reasoning: Option<Reasoning>,
	/// A stable identifier for safety policy enforcement.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub safety_identifier: Option<String>,
	/// Specifies the latency tier to use for processing the request.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub service_tier: Option<ServiceTier>,
	/// Whether to store this response.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub store: Option<bool>,
	/// Configuration options for a text response from the model.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub text: Option<ResponseTextConfig>,
	/// The number of most likely tokens to return at each token position.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub top_logprobs: Option<i32>,
	/// The truncation strategy to use for the model response.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub truncation: Option<TruncationStrategy>,
	/// Represents token usage details.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub usage: Option<ResponseUsage>,
	/// Deprecated: A stable identifier for your end-users.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub user: Option<String>,
}

pub mod response {
	use super::*;

	/// Details about why the response is incomplete.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct IncompleteDetails {
		/// The reason why the response is incomplete.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub reason: Option<IncompleteReason>,
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(rename_all = "snake_case")]
	pub enum IncompleteReason {
		MaxOutputTokens,
		ContentFilter,
	}

	/// The conversation that this response belongs to.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct Conversation {
		/// The unique ID of the conversation.
		pub id: String,
	}
}

/// Represents either a string of instructions or a list of input items.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum Instructions {
	Text(String),
	Items(Vec<ResponseInputItem>),
}

/// The latency tier for request processing.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ServiceTier {
	Auto,
	Default,
	Flex,
	Scale,
	Priority,
}

/// The status of a response generation.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ResponseStatus {
	Completed,
	Failed,
	InProgress,
	Cancelled,
	Queued,
	Incomplete,
}

/// The truncation strategy for model responses.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TruncationStrategy {
	Auto,
	Disabled,
}

// Tool related structs

/// An array of tools the model may call while generating a response.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Tool {
	Function(FunctionTool),
	FileSearch(FileSearchTool),
	ComputerUsePreview(ComputerTool),
	WebSearch(WebSearchTool),
	Mcp(tool::Mcp),
	CodeInterpreter(tool::CodeInterpreter),
	ImageGeneration(tool::ImageGeneration),
	LocalShell(tool::LocalShell),
	Custom(CustomTool),
	WebSearchPreview(WebSearchPreviewTool),
}

pub mod tool {
	use super::*;

	/// Give the model access to additional tools via remote Model Context Protocol (MCP) servers.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct Mcp {
		/// A label for this MCP server, used to identify it in tool calls.
		pub server_label: String,
		/// List of allowed tool names or a filter object.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub allowed_tools: Option<AllowedTools>,
		/// An OAuth access token that can be used with a remote MCP server.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub authorization: Option<String>,
		/// Identifier for service connectors, like those available in ChatGPT.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub connector_id: Option<ConnectorId>,
		/// Optional HTTP headers to send to the MCP server.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub headers: Option<HashMap<String, String>>,
		/// Specify which of the MCP server's tools require approval.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub require_approval: Option<RequireApproval>,
		/// Optional description of the MCP server, used to provide more context.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub server_description: Option<String>,
		/// The URL for the MCP server.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub server_url: Option<String>,
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(untagged)]
	pub enum AllowedTools {
		Names(Vec<String>),
		Filter(McpToolFilter),
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct McpToolFilter {
		/// Indicates whether or not a tool modifies data or is read-only.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub read_only: Option<bool>,
		/// List of allowed tool names.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub tool_names: Option<Vec<String>>,
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(rename_all = "snake_case")]
	pub enum ConnectorId {
		ConnectorDropbox,
		ConnectorGmail,
		ConnectorGooglecalendar,
		ConnectorGoogledrive,
		ConnectorMicrosoftteams,
		ConnectorOutlookcalendar,
		ConnectorOutlookemail,
		ConnectorSharepoint,
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(untagged)]
	pub enum RequireApproval {
		String(String), // "always" or "never"
		Filter(McpToolApprovalFilter),
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct McpToolApprovalFilter {
		#[serde(skip_serializing_if = "Option::is_none")]
		pub always: Option<McpToolFilter>,
		#[serde(skip_serializing_if = "Option::is_none")]
		pub never: Option<McpToolFilter>,
	}

	/// A tool that runs Python code to help generate a response to a prompt.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct CodeInterpreter {
		/// The code interpreter container.
		pub container: CodeInterpreterContainer,
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(untagged)]
	pub enum CodeInterpreterContainer {
		Id(String),
		Auto(CodeInterpreterToolAuto),
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(tag = "type")]
	pub enum CodeInterpreterToolAuto {
		#[serde(rename = "auto")]
		Auto {
			/// An optional list of uploaded files to make available to your code.
			#[serde(skip_serializing_if = "Option::is_none")]
			file_ids: Option<Vec<String>>,
		},
	}

	/// A tool that generates images using a model like `gpt-image-1`.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct ImageGeneration {
		/// Background type for the generated image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub background: Option<String>,
		/// Control how much effort the model will exert to match the style and features.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub input_fidelity: Option<String>,
		/// Optional mask for inpainting.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub input_image_mask: Option<InputImageMask>,
		/// The image generation model to use.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub model: Option<String>,
		/// Moderation level for the generated image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub moderation: Option<String>,
		/// Compression level for the output image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub output_compression: Option<i32>,
		/// The output format of the generated image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub output_format: Option<String>,
		/// Number of partial images to generate in streaming mode.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub partial_images: Option<i32>,
		/// The quality of the generated image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub quality: Option<String>,
		/// The size of the generated image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub size: Option<String>,
	}

	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct InputImageMask {
		/// File ID for the mask image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub file_id: Option<String>,
		/// Base64-encoded mask image.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub image_url: Option<String>,
	}

	/// A tool that allows the model to execute shell commands in a local environment.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct LocalShell {}
}

/// Defines a function in your own code the model can choose to call.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FunctionTool {
	/// The name of the function to call.
	pub name: String,
	/// A JSON schema object describing the parameters of the function.
	pub parameters: serde_json::Value,
	/// Whether to enforce strict parameter validation.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub strict: Option<bool>,
	/// A description of the function.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub description: Option<String>,
}

/// A tool that searches for relevant content from uploaded files.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FileSearchTool {
	/// The IDs of the vector stores to search.
	pub vector_store_ids: Vec<String>,
	/// A filter to apply.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub filters: Option<serde_json::Value>, // Using Value for simplicity
	/// The maximum number of results to return.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub max_num_results: Option<i32>,
	/// Ranking options for search.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub ranking_options: Option<file_search_tool::RankingOptions>,
}

pub mod file_search_tool {
	use super::*;

	/// Ranking options for search.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct RankingOptions {
		/// The ranker to use for the file search.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub ranker: Option<String>,
		/// The score threshold for the file search.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub score_threshold: Option<f64>,
	}
}

/// A tool that controls a virtual computer.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ComputerTool {
	/// The height of the computer display.
	pub display_height: f64,
	/// The width of the computer display.
	pub display_width: f64,
	/// The type of computer environment to control.
	pub environment: String,
}

/// A custom tool that processes input using a specified format.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CustomTool {
	/// The name of the custom tool.
	pub name: String,
	/// Optional description of the custom tool.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub description: Option<String>,
	/// The input format for the custom tool.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub format: Option<serde_json::Value>,
}

/// This tool searches the web for relevant results to use in a response.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WebSearchPreviewTool {
	/// High level guidance for the amount of context window space to use for the search.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub search_context_size: Option<String>,
	/// The user's location.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub user_location: Option<web_search_tool::UserLocation>,
}

/// Search the Internet for sources related to the prompt.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WebSearchTool {
	/// Filters for the search.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub filters: Option<web_search_tool::Filters>,
	/// High level guidance for the amount of context window space to use for the search.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub search_context_size: Option<String>,
	/// The approximate location of the user.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub user_location: Option<web_search_tool::UserLocation>,
}

pub mod web_search_tool {
	use super::*;

	/// Filters for the search.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct Filters {
		/// Allowed domains for the search.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub allowed_domains: Option<Vec<String>>,
	}

	/// The approximate location of the user.
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct UserLocation {
		/// The type of location approximation.
		#[serde(rename = "type")]
		pub type_field: String, // "approximate"
		/// Free text input for the city of the user.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub city: Option<String>,
		/// The two-letter ISO country code of the user.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub country: Option<String>,
		/// Free text input for the region of the user.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub region: Option<String>,
		/// The IANA timezone of the user.
		#[serde(skip_serializing_if = "Option::is_none")]
		pub timezone: Option<String>,
	}
}

// ToolChoice related structs

/// Controls which (if any) tool is called by the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum ToolChoice {
	String(String), // "none", "auto", "required"
	Object(ToolChoiceObject),
}

/// An object specifying a tool choice configuration.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ToolChoiceObject {
	AllowedTools(ToolChoiceAllowed),
	FileSearch,
	WebSearchPreview,
	ComputerUsePreview,
	#[serde(rename = "web_search_preview_2025_03_11")]
	WebSearchPreview20250311,
	ImageGeneration,
	CodeInterpreter,
	Function(ToolChoiceFunction),
	Mcp(ToolChoiceMcp),
	Custom(ToolChoiceCustom),
}

/// Constrains the tools available to the model to a pre-defined set.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ToolChoiceAllowed {
	/// `auto` or `required`.
	pub mode: String,
	/// A list of tool definitions that the model should be allowed to call.
	pub tools: Vec<serde_json::Value>,
}

/// Forces the model to call a specific function.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ToolChoiceFunction {
	/// The name of the function to call.
	pub name: String,
}

/// Forces the model to call a specific tool on a remote MCP server.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ToolChoiceMcp {
	/// The label of the MCP server to use.
	pub server_label: String,
	/// The name of the tool to call on the server.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub name: Option<String>,
}

/// Forces the model to call a specific custom tool.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ToolChoiceCustom {
	/// The name of the custom tool to call.
	pub name: String,
}

// Input and Output Item related structs

/// An output item generated by the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ResponseOutputItem {
	Message(ResponseOutputMessage),
	FileSearchCall(ResponseFileSearchToolCall),
	FunctionCall(ResponseFunctionToolCall),
	WebSearchCall(ResponseFunctionWebSearch),
	ComputerCall(ResponseComputerToolCall),
	Reasoning(ResponseReasoningItem),
	ImageGenerationCall(ImageGenerationCall),
	CodeInterpreterCall(ResponseCodeInterpreterToolCall),
	LocalShellCall(LocalShellCall),
	McpCall(McpCall),
	McpListTools(McpListTools),
	McpApprovalRequest(McpApprovalRequest),
	CustomToolCall(ResponseCustomToolCall),
}

/// An input item provided to the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ResponseInputItem {
	Message(InputMessage),
	FileSearchCall(ResponseFileSearchToolCall),
	ComputerCall(ResponseComputerToolCall),
	ComputerCallOutput(ResponseComputerToolCallOutputItem),
	WebSearchCall(ResponseFunctionWebSearch),
	FunctionCall(ResponseFunctionToolCall),
	FunctionCallOutput(FunctionCallOutput),
	Reasoning(ResponseReasoningItem),
	ImageGenerationCall(ImageGenerationCall),
	CodeInterpreterCall(ResponseCodeInterpreterToolCall),
	LocalShellCall(LocalShellCall),
	LocalShellCallOutput(LocalShellCallOutput),
	McpListTools(McpListTools),
	McpApprovalRequest(McpApprovalRequest),
	McpApprovalResponse(McpApprovalResponse),
	McpCall(McpCall),
	CustomToolCallOutput(ResponseCustomToolCallOutput),
	CustomToolCall(ResponseCustomToolCall),
	ItemReference(ItemReference),
}

/// An output message from the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseOutputMessage {
	pub id: String,
	pub content: Vec<ResponseOutputContent>,
	pub role: String,   // "assistant"
	pub status: String, // "in_progress" | "completed" | "incomplete"
}

/// A message input to the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct InputMessage {
	pub content: InputMessageContent,
	pub role: InputMessageRole,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub status: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum InputMessageContent {
	Text(String),
	Parts(Vec<ResponseInputContentPart>),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InputMessageRole {
	User,
	Assistant,
	System,
	Developer,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ResponseInputContentPart {
	InputText(ResponseInputText),
	InputImage(ResponseInputImage),
	InputFile(ResponseInputFile),
	InputAudio(ResponseInputAudio),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ResponseOutputContent {
	OutputText(ResponseOutputText),
	Refusal(ResponseOutputRefusal),
}

// ... more structs for each item type ...
// Due to the large number of types, this is a representative subset.
// The full implementation would require defining structs for every variant
// of ResponseOutputItem, ResponseInputItem, ResponseStreamEvent, etc.
// Here are a few key examples:

/// A text output from the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseOutputText {
	pub text: String,
	pub annotations: Vec<Annotation>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub logprobs: Option<Vec<Logprob>>,
}

/// A refusal from the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseOutputRefusal {
	pub refusal: String,
}

/// A tool call to run a function.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseFunctionToolCall {
	#[serde(skip_serializing_if = "Option::is_none")]
	pub id: Option<String>,
	pub call_id: String,
	pub name: String,
	pub arguments: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub status: Option<String>,
}

/// An error object returned when the model fails to generate a Response.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseError {
	pub code: String,
	pub message: String,
}

/// Billing information for a response.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseBilling {
	/// The payer for this response.
	pub payer: String,
}

/// Represents token usage details.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseUsage {
	pub input_tokens: u32,
	pub input_tokens_details: response_usage::InputTokensDetails,
	pub output_tokens: u32,
	pub output_tokens_details: response_usage::OutputTokensDetails,
	pub total_tokens: i64,
}

pub mod response_usage {
	use super::*;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct InputTokensDetails {
		pub cached_tokens: i64,
	}
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct OutputTokensDetails {
		pub reasoning_tokens: i64,
	}
}

/// A reference to a prompt template and its variables.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponsePrompt {
	pub id: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub variables: Option<HashMap<String, PromptVariable>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub version: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum PromptVariable {
	String(String),
	InputText(ResponseInputText),
	InputImage(ResponseInputImage),
	InputFile(ResponseInputFile),
}

/// Configuration options for a text response from the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseTextConfig {
	#[serde(skip_serializing_if = "Option::is_none")]
	pub format: Option<ResponseFormatTextConfig>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub verbosity: Option<String>, // "low" | "medium" | "high"
}

/// Response format configuration for text responses.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type")]
pub enum ResponseFormatTextConfig {
	#[serde(rename = "text")]
	Text,
	#[serde(rename = "json_schema")]
	JsonSchema {
		name: String,
		schema: serde_json::Value,
		#[serde(skip_serializing_if = "Option::is_none")]
		description: Option<String>,
		#[serde(skip_serializing_if = "Option::is_none")]
		strict: Option<bool>,
	},
}

// ---------------------
// OpenAI Responses API Payload Types
// ---------------------

/// Content part payload for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum OpenAIContentPartPayload {
	InputText { text: String },
	InputImage { image_url: String, detail: String },
	OutputText { text: String },
}

/// Tool payload for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAIToolPayload {
	#[serde(rename = "type")]
	pub tool_type: String,
	pub function: OpenAIFunctionPayload,
}

/// Function payload for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAIFunctionPayload {
	pub name: String,
	pub description: Option<String>,
	pub parameters: serde_json::Value,
}

/// Reasoning configuration payload for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAIReasoningConfigPayload {
	pub effort: Option<String>,
	pub summary: Option<String>,
}

/// Text configuration payload for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAITextConfigPayload {
	pub verbosity: Option<String>,
}

/// Tool call payload for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAIToolCallPayload {
	pub id: String,
	pub name: String,
	pub arguments: String,
	pub function: OpenAIFunctionCallPayload,
}

/// Function call payload for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAIFunctionCallPayload {
	pub name: String,
	pub arguments: String,
}

/// Parameters for creating a model response.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct OpenAIResponsesRequestPayload {
	#[serde(skip_serializing_if = "Option::is_none")]
	pub background: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub conversation: Option<ConversationParam>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub include: Option<Vec<ResponseIncludable>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub input: Option<OpenAIInputMessage>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub instructions: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub max_output_tokens: Option<i64>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub metadata: Option<HashMap<String, String>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub model: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub parallel_tool_calls: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub previous_response_id: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub prompt: Option<ResponsePrompt>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub prompt_cache_key: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub reasoning: Option<Reasoning>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub safety_identifier: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub service_tier: Option<ServiceTier>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub store: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub stream: Option<bool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub stream_options: Option<StreamOptions>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub temperature: Option<f64>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub text: Option<ResponseTextConfig>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub tool_choice: Option<ToolChoice>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub tools: Option<Vec<Tool>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub top_p: Option<f64>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub truncation: Option<TruncationStrategy>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub user: Option<String>,
}

/// Streaming output item for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpenAIStreamingOutputItem {
	pub id: String,
	pub content: Vec<OpenAIStreamingContent>,
}

/// Streaming content for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum OpenAIStreamingContent {
	OutputText { text: String },
}

/// Output item for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum OpenAIOutputItem {
	Message {
		role: String,
		content: Vec<OpenAIOutputContent>,
	},
	Reasoning {
		reasoning: String,
		summary: String,
	},
	ToolCall {
		id: String,
		tool_type: String,
		function: OpenAIFunctionCallPayload,
	},
	Preamble {
		content: Vec<OpenAIOutputContent>,
	},
}

/// Output content for OpenAI Responses API
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum OpenAIOutputContent {
	OutputText { text: String },
	OutputReasoning { reasoning: String, summary: String },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum ConversationParam {
	Id(String),
	Object(ResponseConversationParam),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseConversationParam {
	pub id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "kebab-case")]
pub enum ResponseIncludable {
	FileSearchCallResults,
	MessageInputImageImageUrl,
	ComputerCallOutputOutputImageUrl,
	ReasoningEncryptedContent,
	CodeInterpreterCallOutputs,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum OpenAIInputMessage {
	String(String),
	Items(Vec<ResponseInputItem>),
	Message { role: String, content: Vec<OpenAIContentPartPayload> },
	UserMessage { content: Vec<OpenAIContentPartPayload> },
	AssistantMessage { content: Vec<OpenAIContentPartPayload> },
	SystemMessage { content: Vec<OpenAIContentPartPayload> },
	DeveloperMessage { content: Vec<OpenAIContentPartPayload> },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct StreamOptions {
	#[serde(skip_serializing_if = "Option::is_none")]
	pub include_obfuscation: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct Reasoning {
	/// The effort level for reasoning. Supported values: "none", "minimal", "low", "medium", "high", "xhigh".
	#[serde(skip_serializing_if = "Option::is_none")]
	pub effort: Option<String>,
	/// Whether to generate a summary of the reasoning. Supported values: "auto", "concise", "detailed".
	#[serde(skip_serializing_if = "Option::is_none")]
	pub summary: Option<String>,
}

/// A text input to the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseInputText {
	pub text: String,
}

/// An image input to the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseInputImage {
	pub detail: ImageDetailLevel,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub file_id: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub image_url: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ImageDetailLevel {
	Low,
	High,
	Auto,
}

/// A file input to the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseInputFile {
	#[serde(skip_serializing_if = "Option::is_none")]
	pub file_data: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub file_id: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub file_url: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub filename: Option<String>,
}

/// An audio input to the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseInputAudio {
	pub input_audio: response_input_audio::InputAudio,
}
pub mod response_input_audio {
	use super::*;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct InputAudio {
		pub data: String, // Base64 encoded
		pub format: AudioFormat,
	}
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(rename_all = "snake_case")]
	pub enum AudioFormat {
		Mp3,
		Wav,
	}
}

/// An annotation on a text output.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Annotation {
	FileCitation(FileCitation),
	UrlCitation(UrlCitation),
	ContainerFileCitation(ContainerFileCitation),
	FilePath(FilePath),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FileCitation {
	pub file_id: String,
	pub filename: String,
	pub index: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct UrlCitation {
	pub end_index: i32,
	pub start_index: i32,
	pub title: String,
	pub url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ContainerFileCitation {
	pub container_id: String,
	pub end_index: i32,
	pub file_id: String,
	pub filename: String,
	pub start_index: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FilePath {
	pub file_id: String,
	pub index: i32,
}

/// The log probability of a token.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Logprob {
	pub token: String,
	pub bytes: Vec<u8>,
	pub logprob: f64,
	pub top_logprobs: Vec<logprob::TopLogprob>,
}
pub mod logprob {
	use super::*;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct TopLogprob {
		pub token: String,
		pub bytes: Vec<u8>,
		pub logprob: f64,
	}
}

/// The results of a file search tool call.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseFileSearchToolCall {
	pub id: String,
	pub queries: Vec<String>,
	pub status: FileSearchStatus,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub results: Option<Vec<response_file_search_tool_call::Result>>,
}
pub mod response_file_search_tool_call {
	use super::*;
	use serde_json::Value;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct Result {
		#[serde(skip_serializing_if = "Option::is_none")]
		pub attributes: Option<HashMap<String, Value>>,
		#[serde(skip_serializing_if = "Option::is_none")]
		pub file_id: Option<String>,
		#[serde(skip_serializing_if = "Option::is_none")]
		pub filename: Option<String>,
		#[serde(skip_serializing_if = "Option::is_none")]
		pub score: Option<f64>,
		#[serde(skip_serializing_if = "Option::is_none")]
		pub text: Option<String>,
	}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum FileSearchStatus {
	InProgress,
	Searching,
	Completed,
	Incomplete,
	Failed,
}

/// The results of a web search tool call.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseFunctionWebSearch {
	pub id: String,
	pub status: WebSearchStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum WebSearchStatus {
	InProgress,
	Searching,
	Completed,
	Failed,
}

/// A tool call to a computer use tool.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseComputerToolCall {
	pub id: String,
	pub action: ComputerAction,
	pub call_id: String,
	pub pending_safety_checks: Vec<PendingSafetyCheck>,
	pub status: CallStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CallStatus {
	InProgress,
	Completed,
	Incomplete,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ComputerAction {
	Click(ClickAction),
	DoubleClick(DoubleClickAction),
	Drag(DragAction),
	Keypress(KeypressAction),
	Move(MoveAction),
	Screenshot(ScreenshotAction),
	Scroll(ScrollAction),
	Type(TypeAction),
	Wait(WaitAction),
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ClickAction {
	pub button: String,
	pub x: f64,
	pub y: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct DoubleClickAction {
	pub x: f64,
	pub y: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct DragAction {
	pub path: Vec<drag_action::Path>,
}
pub mod drag_action {
	use super::*;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct Path {
		pub x: f64,
		pub y: f64,
	}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct KeypressAction {
	pub keys: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MoveAction {
	pub x: f64,
	pub y: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ScreenshotAction {}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ScrollAction {
	pub scroll_x: f64,
	pub scroll_y: f64,
	pub x: f64,
	pub y: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TypeAction {
	pub text: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WaitAction {}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PendingSafetyCheck {
	pub id: String,
	pub code: String,
	pub message: String,
}

/// A description of the chain of thought used by a reasoning model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseReasoningItem {
	pub id: String,
	pub summary: Vec<response_reasoning_item::Summary>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub content: Option<Vec<response_reasoning_item::Content>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub encrypted_content: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub status: Option<CallStatus>,
}
pub mod response_reasoning_item {
	use super::*;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(tag = "type", rename_all = "snake_case")]
	pub enum Summary {
		SummaryText { text: String },
	}
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(tag = "type", rename_all = "snake_case")]
	pub enum Content {
		ReasoningText { text: String },
	}
}

/// An image generation request made by the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ImageGenerationCall {
	pub id: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub result: Option<String>, // Base64 encoded
	pub status: ImageGenerationStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ImageGenerationStatus {
	InProgress,
	Completed,
	Generating,
	Failed,
}

/// A tool call to run code.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseCodeInterpreterToolCall {
	pub id: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub code: Option<String>,
	pub container_id: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub outputs: Option<Vec<CodeInterpreterOutput>>,
	pub status: CodeInterpreterStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CodeInterpreterStatus {
	InProgress,
	Completed,
	Incomplete,
	Interpreting,
	Failed,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum CodeInterpreterOutput {
	Logs { logs: String },
	Image { url: String },
}

/// A tool call to run a command on the local shell.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct LocalShellCall {
	pub id: String,
	pub action: local_shell_call::Action,
	pub call_id: String,
	pub status: CallStatus,
}
pub mod local_shell_call {
	use super::*;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	#[serde(tag = "type", rename_all = "snake_case")]
	pub enum Action {
		Exec {
			command: Vec<String>,
			env: HashMap<String, String>,
			#[serde(skip_serializing_if = "Option::is_none")]
			timeout_ms: Option<i64>,
			#[serde(skip_serializing_if = "Option::is_none")]
			user: Option<String>,
			#[serde(skip_serializing_if = "Option::is_none")]
			working_directory: Option<String>,
		},
	}
}

/// An invocation of a tool on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct McpCall {
	pub id: String,
	pub arguments: String, // JSON string
	pub name: String,
	pub server_label: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub error: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub output: Option<String>,
}

/// A list of tools available on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct McpListTools {
	pub id: String,
	pub server_label: String,
	pub tools: Vec<mcp_list_tools::Tool>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub error: Option<String>,
}
pub mod mcp_list_tools {
	use super::*;
	use serde_json::Value;
	#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
	pub struct Tool {
		pub input_schema: Value,
		pub name: String,
		#[serde(skip_serializing_if = "Option::is_none")]
		pub annotations: Option<Value>,
		#[serde(skip_serializing_if = "Option::is_none")]
		pub description: Option<String>,
	}
}

/// A request for human approval of a tool invocation.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct McpApprovalRequest {
	pub id: String,
	pub arguments: String, // JSON string
	pub name: String,
	pub server_label: String,
}

/// A call to a custom tool created by the model.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseCustomToolCall {
	pub call_id: String,
	pub input: String,
	pub name: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub id: Option<String>,
}

/// The output of a computer tool call.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseComputerToolCallOutputItem {
	pub id: String,
	pub call_id: String,
	pub output: ResponseComputerToolCallOutputScreenshot,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub acknowledged_safety_checks: Option<Vec<AcknowledgedSafetyCheck>>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub status: Option<CallStatus>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ResponseComputerToolCallOutputScreenshot {
	ComputerScreenshot {
		#[serde(skip_serializing_if = "Option::is_none")]
		file_id: Option<String>,
		#[serde(skip_serializing_if = "Option::is_none")]
		image_url: Option<String>,
	},
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct AcknowledgedSafetyCheck {
	pub id: String,
	pub code: String,
	pub message: String,
}

/// The output of a function tool call.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FunctionCallOutput {
	pub call_id: String,
	pub output: String, // JSON string
	#[serde(skip_serializing_if = "Option::is_none")]
	pub id: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub status: Option<CallStatus>,
}

/// The output of a local shell tool call.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct LocalShellCallOutput {
	pub id: String,
	pub output: String, // JSON string
	#[serde(skip_serializing_if = "Option::is_none")]
	pub status: Option<CallStatus>,
}

/// A response to an MCP approval request.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct McpApprovalResponse {
	pub approval_request_id: String,
	pub approve: bool,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub id: Option<String>,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub reason: Option<String>,
}

/// The output of a custom tool call from your code.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ResponseCustomToolCallOutput {
	pub call_id: String,
	pub output: String,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub id: Option<String>,
}

/// An internal identifier for an item to reference.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ItemReference {
	pub id: String,
}

// ---------------------
// OpenAI Responses API Streaming Types
// ---------------------

/// A streaming event from the OpenAI Responses API.
/// The `type` field determines which variant this is.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ResponsesStreamEvent {
	/// Emitted when a response is created
	#[serde(rename = "response.created")]
	ResponseCreated { sequence_number: i64, response: serde_json::Value },
	/// Emitted when the response is in progress
	#[serde(rename = "response.in_progress")]
	ResponseInProgress { sequence_number: i64, response: serde_json::Value },
	/// Emitted when the response is completed
	#[serde(rename = "response.completed")]
	ResponseCompleted {
		sequence_number: i64,
		response: ResponsesStreamCompletedResponse,
	},
	/// Emitted when the response fails
	#[serde(rename = "response.failed")]
	ResponseFailed { sequence_number: i64, response: serde_json::Value },
	/// Emitted when a response is incomplete
	#[serde(rename = "response.incomplete")]
	ResponseIncomplete { sequence_number: i64, response: serde_json::Value },
	/// Emitted when a response is queued
	#[serde(rename = "response.queued")]
	ResponseQueued { sequence_number: i64, response: serde_json::Value },
	/// Emitted when an output item is added
	#[serde(rename = "response.output_item.added")]
	OutputItemAdded {
		sequence_number: i64,
		output_index: i64,
		item: serde_json::Value,
	},
	/// Emitted when an output item is done
	#[serde(rename = "response.output_item.done")]
	OutputItemDone {
		sequence_number: i64,
		output_index: i64,
		item: serde_json::Value,
	},
	/// Emitted when a content part is added
	#[serde(rename = "response.content_part.added")]
	ContentPartAdded {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		part: serde_json::Value,
	},
	/// Emitted when a content part is done
	#[serde(rename = "response.content_part.done")]
	ContentPartDone {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		part: serde_json::Value,
	},
	/// Emitted when text is streamed
	#[serde(rename = "response.output_text.delta")]
	OutputTextDelta {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		delta: String,
		#[serde(default)]
		logprobs: Vec<serde_json::Value>,
		#[serde(default)]
		obfuscation: Option<String>,
	},
	/// Emitted when text output is done
	#[serde(rename = "response.output_text.done")]
	OutputTextDone {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		text: String,
		#[serde(default)]
		logprobs: Vec<serde_json::Value>,
	},
	/// Emitted when there is an annotation added to output text
	#[serde(rename = "response.output_text.annotation.added")]
	OutputTextAnnotationAdded {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		annotation_index: i64,
		annotation: serde_json::Value,
	},
	/// Emitted when a function call starts
	#[serde(rename = "response.function_call_arguments.delta")]
	FunctionCallArgumentsDelta {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		delta: String,
	},
	/// Emitted when a function call is done
	#[serde(rename = "response.function_call_arguments.done")]
	FunctionCallArgumentsDone {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		#[serde(default)]
		name: Option<String>,
		arguments: String,
	},
	/// Emitted when there is a partial refusal text
	#[serde(rename = "response.refusal.delta")]
	RefusalDelta {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		delta: String,
	},
	/// Emitted when refusal text is finalized
	#[serde(rename = "response.refusal.done")]
	RefusalDone {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		refusal: String,
	},
	/// Emitted when a file search call is initiated
	#[serde(rename = "response.file_search_call.in_progress")]
	FileSearchCallInProgress { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a file search is currently searching
	#[serde(rename = "response.file_search_call.searching")]
	FileSearchCallSearching { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a file search call is completed
	#[serde(rename = "response.file_search_call.completed")]
	FileSearchCallCompleted { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a web search call is initiated
	#[serde(rename = "response.web_search_call.in_progress")]
	WebSearchCallInProgress { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a web search call is executing
	#[serde(rename = "response.web_search_call.searching")]
	WebSearchCallSearching { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a web search call is completed
	#[serde(rename = "response.web_search_call.completed")]
	WebSearchCallCompleted { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a new reasoning summary part is added
	#[serde(rename = "response.reasoning_summary_part.added")]
	ReasoningSummaryPartAdded {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		summary_index: i64,
		part: serde_json::Value,
	},
	/// Emitted when a reasoning summary part is completed
	#[serde(rename = "response.reasoning_summary_part.done")]
	ReasoningSummaryPartDone {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		summary_index: i64,
		part: serde_json::Value,
	},
	/// Emitted when a delta is added to a reasoning summary text
	#[serde(rename = "response.reasoning_summary_text.delta")]
	ReasoningSummaryTextDelta {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		summary_index: i64,
		delta: String,
	},
	/// Emitted when a reasoning summary text is completed
	#[serde(rename = "response.reasoning_summary_text.done")]
	ReasoningSummaryTextDone {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		summary_index: i64,
		text: String,
	},
	/// Emitted when a delta is added to a reasoning text
	#[serde(rename = "response.reasoning_text.delta")]
	ReasoningTextDelta {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		delta: String,
	},
	/// Emitted when a reasoning text is completed
	#[serde(rename = "response.reasoning_text.done")]
	ReasoningTextDone {
		sequence_number: i64,
		item_id: String,
		output_index: i64,
		content_index: i64,
		text: String,
	},
	/// Emitted when an image generation tool call has completed
	#[serde(rename = "response.image_generation_call.completed")]
	ImageGenerationCallCompleted { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when an image generation tool call is actively generating
	#[serde(rename = "response.image_generation_call.generating")]
	ImageGenerationCallGenerating { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when an image generation tool call is in progress
	#[serde(rename = "response.image_generation_call.in_progress")]
	ImageGenerationCallInProgress { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a partial image is available during image generation
	#[serde(rename = "response.image_generation_call.partial_image")]
	ImageGenerationCallPartialImage {
		sequence_number: i64,
		output_index: i64,
		item_id: String,
		partial_image_index: i64,
		partial_image_b64: String,
	},
	/// Emitted when there is a delta to the arguments of an MCP tool call
	#[serde(rename = "response.mcp_call_arguments.delta")]
	McpCallArgumentsDelta {
		sequence_number: i64,
		output_index: i64,
		item_id: String,
		delta: String,
	},
	/// Emitted when the arguments for an MCP tool call are finalized
	#[serde(rename = "response.mcp_call_arguments.done")]
	McpCallArgumentsDone {
		sequence_number: i64,
		output_index: i64,
		item_id: String,
		arguments: String,
	},
	/// Emitted when an MCP tool call has completed successfully
	#[serde(rename = "response.mcp_call.completed")]
	McpCallCompleted { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when an MCP tool call has failed
	#[serde(rename = "response.mcp_call.failed")]
	McpCallFailed { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when an MCP tool call is in progress
	#[serde(rename = "response.mcp_call.in_progress")]
	McpCallInProgress { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when the list of available MCP tools has been successfully retrieved
	#[serde(rename = "response.mcp_list_tools.completed")]
	McpListToolsCompleted { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when the attempt to list available MCP tools has failed
	#[serde(rename = "response.mcp_list_tools.failed")]
	McpListToolsFailed { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when the system is in the process of retrieving the list of available MCP tools
	#[serde(rename = "response.mcp_list_tools.in_progress")]
	McpListToolsInProgress { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a code interpreter call is in progress
	#[serde(rename = "response.code_interpreter_call.in_progress")]
	CodeInterpreterCallInProgress { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when the code interpreter is actively interpreting
	#[serde(rename = "response.code_interpreter_call.interpreting")]
	CodeInterpreterCallInterpreting { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when the code interpreter call is completed
	#[serde(rename = "response.code_interpreter_call.completed")]
	CodeInterpreterCallCompleted { sequence_number: i64, output_index: i64, item_id: String },
	/// Emitted when a partial code snippet is streamed by the code interpreter
	#[serde(rename = "response.code_interpreter_call_code.delta")]
	CodeInterpreterCallCodeDelta {
		sequence_number: i64,
		output_index: i64,
		item_id: String,
		delta: String,
	},
	/// Emitted when the code snippet is finalized by the code interpreter
	#[serde(rename = "response.code_interpreter_call_code.done")]
	CodeInterpreterCallCodeDone {
		sequence_number: i64,
		output_index: i64,
		item_id: String,
		code: String,
	},
	/// Event representing a delta to the input of a custom tool call
	#[serde(rename = "response.custom_tool_call_input.delta")]
	CustomToolCallInputDelta {
		sequence_number: i64,
		output_index: i64,
		item_id: String,
		delta: String,
	},
	/// Event indicating that input for a custom tool call is complete
	#[serde(rename = "response.custom_tool_call_input.done")]
	CustomToolCallInputDone {
		sequence_number: i64,
		output_index: i64,
		item_id: String,
		input: String,
	},
	/// Emitted with an error
	#[serde(rename = "error")]
	Error {
		sequence_number: i64,
		code: Option<String>,
		message: String,
		#[serde(default)]
		param: Option<String>,
	},
	/// Catch-all for other events
	#[serde(other)]
	Unknown,
}

/// Response object in the completed event
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponsesStreamCompletedResponse {
	pub id: String,
	#[serde(default)]
	pub status: Option<String>,
	#[serde(default)]
	pub usage: Option<ResponsesStreamUsage>,
	#[serde(default)]
	pub error: Option<ResponseError>,
}

/// Usage information from completed response
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponsesStreamUsage {
	pub input_tokens: u32,
	pub output_tokens: u32,
	#[serde(default)]
	pub input_tokens_details: Option<ResponsesStreamInputTokensDetails>,
	#[serde(default)]
	pub output_tokens_details: Option<ResponsesStreamOutputTokensDetails>,
	#[serde(default)]
	pub total_tokens: Option<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponsesStreamInputTokensDetails {
	#[serde(default)]
	pub cached_tokens: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponsesStreamOutputTokensDetails {
	#[serde(default)]
	pub reasoning_tokens: i64,
}