openai_types/responses/

_gen.rs

// AUTO-GENERATED by py2rust — do not edit.
// Re-generate: python3 scripts/py2rust.py sync <python_dir> <rust_dir>
// Domain: responses
#![allow(unused_imports)]

use serde::{Deserialize, Serialize};
use super::*;

/// Allows the assistant to create, delete, or update files using unified diffs.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ApplyPatchTool {
    /// The type of the tool. Always `apply_patch`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CompactedResponse {
    /// The unique identifier for the compacted response.
    pub id: String,
    /// Unix timestamp (in seconds) when the compacted conversation was created.
    pub created_at: i64,
    /// The object type. Always `response.compaction`.
    pub object: String,
    /// The compacted list of output items.
    pub output: Vec<ResponseOutputItem>,
    /// Token accounting for the compaction pass, including cached, reasoning, and total
    pub usage: ResponseUsage,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ClickButton {
    #[serde(rename = "left")]
    Left,
    #[serde(rename = "right")]
    Right,
    #[serde(rename = "wheel")]
    Wheel,
    #[serde(rename = "back")]
    Back,
    #[serde(rename = "forward")]
    Forward,
}

/// A click action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Click {
    /// Indicates which mouse button was pressed during the click.
    pub button: ClickButton,
    /// Specifies the event type. For a click action, this property is always `click`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate where the click occurred.
    pub x: i64,
    /// The y-coordinate where the click occurred.
    pub y: i64,
}

/// A double click action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct DoubleClick {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate where the double click occurred.
    pub x: i64,
    /// The y-coordinate where the double click occurred.
    pub y: i64,
}

/// An x/y coordinate pair, e.g. `{ x: 100, y: 200 }`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct DragPath {
    /// The x-coordinate.
    pub x: i64,
    /// The y-coordinate.
    pub y: i64,
}

/// A drag action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Drag {
    /// An array of coordinates representing the path of the drag action.
    pub path: Vec<DragPath>,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A collection of keypresses the model would like to perform.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Keypress {
    /// The combination of keys the model is requesting to be pressed.
    pub keys: Vec<String>,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A mouse move action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Move {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate to move to.
    pub x: i64,
    /// The y-coordinate to move to.
    pub y: i64,
}

/// A screenshot action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Screenshot {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A scroll action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Scroll {
    /// The horizontal scroll distance.
    pub scroll_x: i64,
    /// The vertical scroll distance.
    pub scroll_y: i64,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate where the scroll occurred.
    pub x: i64,
    /// The y-coordinate where the scroll occurred.
    pub y: i64,
}

/// An action to type in text.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Type {
    /// The text to type.
    pub text: String,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A wait action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Wait {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ComputerAction = serde_json::Value;

pub type ComputerActionList = Vec<ComputerAction>;

/// A tool that controls a virtual computer.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ComputerTool {
    /// The type of the computer tool. Always `computer`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ComputerUsePreviewToolEnvironment {
    #[serde(rename = "windows")]
    Windows,
    #[serde(rename = "mac")]
    Mac,
    #[serde(rename = "linux")]
    Linux,
    #[serde(rename = "ubuntu")]
    Ubuntu,
    #[serde(rename = "browser")]
    Browser,
}

/// A tool that controls a virtual computer.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ComputerUsePreviewTool {
    /// The height of the computer display.
    pub display_height: i64,
    /// The width of the computer display.
    pub display_width: i64,
    /// The type of computer environment to control.
    pub environment: ComputerUsePreviewToolEnvironment,
    /// The type of the computer use tool. Always `computer_use_preview`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type NetworkPolicy = serde_json::Value;

pub type Skill = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ContainerAutoMemoryLimit {
    #[serde(rename = "1g")]
    V1g,
    #[serde(rename = "4g")]
    V4g,
    #[serde(rename = "16g")]
    V16g,
    #[serde(rename = "64g")]
    V64g,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ContainerAuto {
    /// Automatically creates a container for this request
    #[serde(rename = "type")]
    pub type_: String,
    /// An optional list of uploaded files to make available to your code.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_ids: Option<Vec<String>>,
    /// The memory limit for the container.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub memory_limit: Option<ContainerAutoMemoryLimit>,
    /// Network access policy for the container.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub network_policy: Option<NetworkPolicy>,
    /// An optional list of skills referenced by id or inline data.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub skills: Option<Vec<Skill>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ContainerNetworkPolicyAllowlist {
    /// A list of allowed domains when type is `allowlist`.
    pub allowed_domains: Vec<String>,
    /// Allow outbound network access only to specified domains. Always `allowlist`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional domain-scoped secrets for allowlisted domains.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub domain_secrets: Option<Vec<ContainerNetworkPolicyDomainSecret>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ContainerNetworkPolicyDisabled {
    /// Disable outbound network access. Always `disabled`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ContainerNetworkPolicyDomainSecret {
    /// The domain associated with the secret.
    pub domain: String,
    /// The name of the secret to inject for the domain.
    pub name: String,
    /// The secret value to inject for the domain.
    pub value: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ContainerReference {
    /// The ID of the referenced container.
    pub container_id: String,
    /// References a container created with the /v1/containers endpoint
    #[serde(rename = "type")]
    pub type_: String,
}

/// A custom tool that processes input using a specified format.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CustomTool {
    /// The name of the custom tool, used to identify it in tool calls.
    pub name: String,
    /// The type of the custom tool. Always `custom`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether this tool should be deferred and discovered via tool search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub defer_loading: Option<bool>,
    /// Optional description of the custom tool, used to provide more context.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub description: Option<String>,
    /// The input format for the custom tool. Default is unconstrained text.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<serde_json::Value>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum EasyInputMessageRole {
    #[serde(rename = "user")]
    User,
    #[serde(rename = "assistant")]
    Assistant,
    #[serde(rename = "system")]
    System,
    #[serde(rename = "developer")]
    Developer,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum EasyInputMessagePhase {
    #[serde(rename = "commentary")]
    Commentary,
    #[serde(rename = "final_answer")]
    FinalAnswer,
}

pub type Filters = serde_json::Value;

/// Weights that control how reciprocal rank fusion balances semantic embedding matches versus sparse keyword matches when hybrid search is enabled.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RankingOptionsHybridSearch {
    /// The weight of the embedding in the reciprocal ranking fusion.
    pub embedding_weight: f64,
    /// The weight of the text in the reciprocal ranking fusion.
    pub text_weight: f64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RankingOptionsRanker {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "default-2024-11-15")]
    Default20241115,
}

/// Ranking options for search.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RankingOptions {
    /// Weights that control how reciprocal rank fusion balances semantic embedding
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub hybrid_search: Option<RankingOptionsHybridSearch>,
    /// The ranker to use for the file search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub ranker: Option<RankingOptionsRanker>,
    /// The score threshold for the file search, a number between 0 and 1.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub score_threshold: Option<f64>,
}

/// A tool that searches for relevant content from uploaded files.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct FileSearchTool {
    /// The type of the file search tool. Always `file_search`.
    #[serde(rename = "type")]
    pub type_: String,
    /// 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", default)]
    pub filters: Option<Filters>,
    /// The maximum number of results to return.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_num_results: Option<i64>,
    /// Ranking options for search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub ranking_options: Option<RankingOptions>,
}

pub type Environment = serde_json::Value;

/// A tool that allows the model to execute shell commands.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct FunctionShellTool {
    /// The type of the shell tool. Always `shell`.
    #[serde(rename = "type")]
    pub type_: String,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub environment: Option<Environment>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InlineSkill {
    /// The description of the skill.
    pub description: String,
    /// The name of the skill.
    pub name: String,
    /// Inline skill payload
    pub source: InlineSkillSource,
    /// Defines an inline skill for this request.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Inline skill payload
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InlineSkillSource {
    /// Base64-encoded skill zip bundle.
    pub data: String,
    /// The media type of the inline skill payload. Must be `application/zip`.
    pub media_type: String,
    /// The type of the inline skill source. Must be `base64`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum InputItemListParamsOrder {
    #[serde(rename = "asc")]
    Asc,
    #[serde(rename = "desc")]
    Desc,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputItemListParams {
    /// An item ID to list items after, used in pagination.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub after: Option<String>,
    /// Additional fields to include in the response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<ResponseIncludable>>,
    /// A limit on the number of objects to be returned.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub limit: Option<i64>,
    /// The order to return the input items in. Default is `desc`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub order: Option<InputItemListParamsOrder>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum InputTokenCountParamsTruncation {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputTokenCountParams {
    /// The conversation that this response belongs to.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub conversation: Option<Conversation>,
    /// Text, image, or file inputs to the model, used to generate a response
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input: Option<String>,
    /// A system (or developer) message inserted into the model's context. When used
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// Model ID used to generate the response, like `gpt-4o` or `o3`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// Whether to allow the model to run tool calls in parallel.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub parallel_tool_calls: Option<bool>,
    /// The unique ID of the previous response to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_response_id: Option<String>,
    /// **gpt-5 and o-series models only** Configuration options for
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub reasoning: Option<serde_json::Value>,
    /// Configuration options for a text response from the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text: Option<Text>,
    /// Controls which tool the model should use, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_choice: Option<ToolChoice>,
    /// An array of tools the model may call while generating a response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tools: Option<Vec<serde_json::Value>>,
    /// The truncation strategy to use for the model response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub truncation: Option<InputTokenCountParamsTruncation>,
}

pub type Conversation = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum TextVerbosity {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

/// Configuration options for a text response from the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Text {
    /// An object specifying the format that the model must output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<serde_json::Value>,
    /// Constrains the verbosity of the model's response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub verbosity: Option<TextVerbosity>,
}

pub type ToolChoice = serde_json::Value;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputTokenCountResponse {
    pub input_tokens: i64,
    pub object: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LocalEnvironment {
    /// Use a local computer environment.
    #[serde(rename = "type")]
    pub type_: String,
    /// An optional list of skills.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub skills: Option<Vec<LocalSkill>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LocalSkill {
    /// The description of the skill.
    pub description: String,
    /// The name of the skill.
    pub name: String,
    /// The path to the directory containing the skill.
    pub path: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolFunction {
    pub name: String,
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether this function should be deferred and discovered via tool search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub defer_loading: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub parameters: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub strict: Option<bool>,
}

pub type Tool = serde_json::Value;

/// Groups function/custom tools under a shared namespace.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct NamespaceTool {
    /// A description of the namespace shown to the model.
    pub description: String,
    /// The namespace name used in tool calls (for example, `crm`).
    pub name: String,
    /// The function/custom tools available inside this namespace.
    pub tools: Vec<Tool>,
    /// The type of the tool. Always `namespace`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ParsedContent = serde_json::Value;

pub type ParsedResponseOutputItem = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum IncompleteDetailsReason {
    #[serde(rename = "max_output_tokens")]
    MaxOutputTokens,
    #[serde(rename = "content_filter")]
    ContentFilter,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponsePromptCacheRetention {
    #[serde(rename = "in-memory")]
    InMemory,
    #[serde(rename = "24h")]
    V24h,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseServiceTier {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "default")]
    Default,
    #[serde(rename = "flex")]
    Flex,
    #[serde(rename = "scale")]
    Scale,
    #[serde(rename = "priority")]
    Priority,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseTruncation {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "disabled")]
    Disabled,
}

/// Instruction describing how to create a file via the apply_patch tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OperationCreateFile {
    /// Diff to apply.
    pub diff: String,
    /// Path of the file to create.
    pub path: String,
    /// Create a new file with the provided diff.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Instruction describing how to delete a file via the apply_patch tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OperationDeleteFile {
    /// Path of the file to delete.
    pub path: String,
    /// Delete the specified file.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Instruction describing how to update a file via the apply_patch tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OperationUpdateFile {
    /// Diff to apply.
    pub diff: String,
    /// Path of the file to update.
    pub path: String,
    /// Update an existing file with the provided diff.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Operation = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseApplyPatchToolCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
}

/// A tool call that applies file diffs by creating, deleting, or updating files.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseApplyPatchToolCall {
    /// The unique ID of the apply patch tool call.
    pub id: String,
    /// The unique ID of the apply patch tool call generated by the model.
    pub call_id: String,
    /// One of the create_file, delete_file, or update_file operations applied via
    pub operation: Operation,
    /// The status of the apply patch tool call. One of `in_progress` or `completed`.
    pub status: ResponseApplyPatchToolCallStatus,
    /// The type of the item. Always `apply_patch_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the entity that created this tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseApplyPatchToolCallOutputStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
}

/// The output emitted by an apply patch tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseApplyPatchToolCallOutput {
    /// The unique ID of the apply patch tool call output.
    pub id: String,
    /// The unique ID of the apply patch tool call generated by the model.
    pub call_id: String,
    /// The status of the apply patch tool call output. One of `completed` or `failed`.
    pub status: ResponseApplyPatchToolCallOutputStatus,
    /// The type of the item. Always `apply_patch_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the entity that created this tool call output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
    /// Optional textual output returned by the apply patch tool.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<String>,
}

/// Emitted when there is a partial audio response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioDeltaEvent {
    /// A chunk of Base64 encoded response audio bytes.
    pub delta: String,
    /// A sequence number for this chunk of the stream response.
    pub sequence_number: i64,
    /// The type of the event. Always `response.audio.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the audio response is complete.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioDoneEvent {
    /// The sequence number of the delta.
    pub sequence_number: i64,
    /// The type of the event. Always `response.audio.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when there is a partial transcript of audio.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioTranscriptDeltaEvent {
    /// The partial transcript of the audio response.
    pub delta: String,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.audio.transcript.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the full audio transcript is completed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioTranscriptDoneEvent {
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.audio.transcript.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a partial code snippet is streamed by the code interpreter.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCodeInterpreterCallCodeDeltaEvent {
    /// The partial code snippet being streamed by the code interpreter.
    pub delta: String,
    /// The unique identifier of the code interpreter tool call item.
    pub item_id: String,
    /// The index of the output item in the response for which the code is being
    pub output_index: i64,
    /// The sequence number of this event, used to order streaming events.
    pub sequence_number: i64,
    /// The type of the event. Always `response.code_interpreter_call_code.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the code snippet is finalized by the code interpreter.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCodeInterpreterCallCodeDoneEvent {
    /// The final code snippet output by the code interpreter.
    pub code: String,
    /// The unique identifier of the code interpreter tool call item.
    pub item_id: String,
    /// The index of the output item in the response for which the code is finalized.
    pub output_index: i64,
    /// The sequence number of this event, used to order streaming events.
    pub sequence_number: i64,
    /// The type of the event. Always `response.code_interpreter_call_code.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the code interpreter call is completed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCodeInterpreterCallCompletedEvent {
    /// The unique identifier of the code interpreter tool call item.
    pub item_id: String,
    /// The index of the output item in the response for which the code interpreter call
    pub output_index: i64,
    /// The sequence number of this event, used to order streaming events.
    pub sequence_number: i64,
    /// The type of the event. Always `response.code_interpreter_call.completed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a code interpreter call is in progress.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCodeInterpreterCallInProgressEvent {
    /// The unique identifier of the code interpreter tool call item.
    pub item_id: String,
    /// The index of the output item in the response for which the code interpreter call
    pub output_index: i64,
    /// The sequence number of this event, used to order streaming events.
    pub sequence_number: i64,
    /// The type of the event. Always `response.code_interpreter_call.in_progress`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the code interpreter is actively interpreting the code snippet.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCodeInterpreterCallInterpretingEvent {
    /// The unique identifier of the code interpreter tool call item.
    pub item_id: String,
    /// The index of the output item in the response for which the code interpreter is
    pub output_index: i64,
    /// The sequence number of this event, used to order streaming events.
    pub sequence_number: i64,
    /// The type of the event. Always `response.code_interpreter_call.interpreting`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// The logs output from the code interpreter.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputLogs {
    /// The logs output from the code interpreter.
    pub logs: String,
    /// The type of the output. Always `logs`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// The image output from the code interpreter.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputImage {
    /// The type of the output. Always `image`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The URL of the image output from the code interpreter.
    pub url: String,
}

pub type Output = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseCodeInterpreterToolCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "interpreting")]
    Interpreting,
    #[serde(rename = "failed")]
    Failed,
}

/// A tool call to run code.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCodeInterpreterToolCall {
    /// The unique ID of the code interpreter tool call.
    pub id: String,
    /// The code to run, or null if not available.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub code: Option<String>,
    /// The ID of the container used to run the code.
    pub container_id: String,
    /// The outputs generated by the code interpreter, such as logs or images. Can be
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub outputs: Option<Vec<FunctionShellOutput>>,
    /// The status of the code interpreter tool call.
    pub status: ResponseCodeInterpreterToolCallStatus,
    /// The type of the code interpreter tool call. Always `code_interpreter_call`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCompactParams {
    /// Model ID used to generate the response, like `gpt-5` or `o3`.
    pub model: Option<String>,
    /// Text, image, or file inputs to the model, used to generate a response
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input: Option<String>,
    /// A system (or developer) message inserted into the model's context. When used
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// The unique ID of the previous response to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_response_id: Option<String>,
    /// A key to use when reading from or writing to the prompt cache.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt_cache_key: Option<String>,
}

/// A compaction item generated by the [`v1/responses/compact` API](https://platform.openai.com/docs/api-reference/responses/compact).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCompactionItem {
    /// The unique ID of the compaction item.
    pub id: String,
    /// The encrypted content that was produced by compaction.
    pub encrypted_content: String,
    /// The type of the item. Always `compaction`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The identifier of the actor that created the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
}

/// A pending safety check for the computer call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct PendingSafetyCheck {
    /// The ID of the pending safety check.
    pub id: String,
    /// The type of the pending safety check.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub code: Option<String>,
    /// Details about the pending safety check.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub message: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ActionClickButton {
    #[serde(rename = "left")]
    Left,
    #[serde(rename = "right")]
    Right,
    #[serde(rename = "wheel")]
    Wheel,
    #[serde(rename = "back")]
    Back,
    #[serde(rename = "forward")]
    Forward,
}

/// A click action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionClick {
    /// Indicates which mouse button was pressed during the click.
    pub button: ActionClickButton,
    /// Specifies the event type. For a click action, this property is always `click`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate where the click occurred.
    pub x: i64,
    /// The y-coordinate where the click occurred.
    pub y: i64,
}

/// A double click action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionDoubleClick {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate where the double click occurred.
    pub x: i64,
    /// The y-coordinate where the double click occurred.
    pub y: i64,
}

/// An x/y coordinate pair, e.g. `{ x: 100, y: 200 }`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionDragPath {
    /// The x-coordinate.
    pub x: i64,
    /// The y-coordinate.
    pub y: i64,
}

/// A drag action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionDrag {
    /// An array of coordinates representing the path of the drag action.
    pub path: Vec<ActionDragPath>,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A collection of keypresses the model would like to perform.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionKeypress {
    /// The combination of keys the model is requesting to be pressed.
    pub keys: Vec<String>,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A mouse move action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionMove {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate to move to.
    pub x: i64,
    /// The y-coordinate to move to.
    pub y: i64,
}

/// A screenshot action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionScreenshot {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A scroll action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionScroll {
    /// The horizontal scroll distance.
    pub scroll_x: i64,
    /// The vertical scroll distance.
    pub scroll_y: i64,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The x-coordinate where the scroll occurred.
    pub x: i64,
    /// The y-coordinate where the scroll occurred.
    pub y: i64,
}

/// An action to type in text.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionType {
    /// The text to type.
    pub text: String,
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A wait action.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionWait {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Action = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseComputerToolCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// A tool call to a computer use tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseComputerToolCall {
    /// The unique ID of the computer call.
    pub id: String,
    /// An identifier used when responding to the tool call with output.
    pub call_id: String,
    /// The pending safety checks for the computer call.
    pub pending_safety_checks: Vec<PendingSafetyCheck>,
    /// The status of the item.
    pub status: ResponseComputerToolCallStatus,
    /// The type of the computer call. Always `computer_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// A click action.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub action: Option<FunctionShellAction>,
    /// Flattened batched actions for `computer_use`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub actions: Option<ComputerActionList>,
}

/// A pending safety check for the computer call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AcknowledgedSafetyCheck {
    /// The ID of the pending safety check.
    pub id: String,
    /// The type of the pending safety check.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub code: Option<String>,
    /// Details about the pending safety check.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub message: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseComputerToolCallOutputItemStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseComputerToolCallOutputItem {
    /// The unique ID of the computer call tool output.
    pub id: String,
    /// The ID of the computer tool call that produced the output.
    pub call_id: String,
    /// A computer screenshot image used with the computer use tool.
    pub output: ResponseComputerToolCallOutputScreenshot,
    /// The type of the computer tool call output. Always `computer_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The safety checks reported by the API that have been acknowledged by the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub acknowledged_safety_checks: Option<Vec<AcknowledgedSafetyCheck>>,
    /// The status of the message input.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ResponseComputerToolCallOutputItemStatus>,
}

/// A computer screenshot image used with the computer use tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseComputerToolCallOutputScreenshot {
    /// Specifies the event type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The identifier of an uploaded file that contains the screenshot.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_id: Option<String>,
    /// The URL of the screenshot image.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub image_url: Option<String>,
}

/// Represents a container created with /v1/containers.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseContainerReference {
    pub container_id: String,
    /// The environment type. Always `container_reference`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Reasoning text from the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct PartReasoningText {
    /// The reasoning text from the model.
    pub text: String,
    /// The type of the reasoning text. Always `reasoning_text`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Part = serde_json::Value;

/// Emitted when a new content part is added.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseContentPartAddedEvent {
    /// The index of the content part that was added.
    pub content_index: i64,
    /// The ID of the output item that the content part was added to.
    pub item_id: String,
    /// The index of the output item that the content part was added to.
    pub output_index: i64,
    /// The content part that was added.
    pub part: ReasoningSummaryPart,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.content_part.added`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a content part is done.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseContentPartDoneEvent {
    /// The index of the content part that is done.
    pub content_index: i64,
    /// The ID of the output item that the content part was added to.
    pub item_id: String,
    /// The index of the output item that the content part was added to.
    pub output_index: i64,
    /// The content part that is done.
    pub part: ReasoningSummaryPart,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.content_part.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseCreateParamsBasePromptCacheRetention {
    #[serde(rename = "in-memory")]
    InMemory,
    #[serde(rename = "24h")]
    V24h,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseCreateParamsBaseServiceTier {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "default")]
    Default,
    #[serde(rename = "flex")]
    Flex,
    #[serde(rename = "scale")]
    Scale,
    #[serde(rename = "priority")]
    Priority,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseCreateParamsBaseTruncation {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCreateParamsBase {
    /// Whether to run the model response in the background.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub background: Option<bool>,
    /// Context management configuration for this request.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub context_management: Option<Vec<ContextManagement>>,
    /// The conversation that this response belongs to.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub conversation: Option<Conversation>,
    /// Specify additional output data to include in the model response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<ResponseIncludable>>,
    /// Text, image, or file inputs to the model, used to generate a response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input: Option<String>,
    /// A system (or developer) message inserted into the model's context.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// An upper bound for the number of tokens that can be generated for a response,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_tokens: Option<i64>,
    /// The maximum number of total calls to built-in tools that can be processed in a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_tool_calls: Option<i64>,
    /// Set of 16 key-value pairs that can be attached to an object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub metadata: Option<serde_json::Value>,
    /// Model ID used to generate the response, like `gpt-4o` or `o3`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<serde_json::Value>,
    /// Whether to allow the model to run tool calls in parallel.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub parallel_tool_calls: Option<bool>,
    /// The unique ID of the previous response to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_response_id: Option<String>,
    /// Reference to a prompt template and its variables.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt: Option<serde_json::Value>,
    /// Used by OpenAI to cache responses for similar requests to optimize your cache
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt_cache_key: Option<String>,
    /// The retention policy for the prompt cache.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt_cache_retention: Option<ResponseCreateParamsBasePromptCacheRetention>,
    /// **gpt-5 and o-series models only**
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub reasoning: Option<serde_json::Value>,
    /// A stable identifier used to help detect users of your application that may be
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub safety_identifier: Option<String>,
    /// Specifies the processing type used for serving the request.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub service_tier: Option<ResponseCreateParamsBaseServiceTier>,
    /// Whether to store the generated model response for later retrieval via API.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub store: Option<bool>,
    /// Options for streaming responses. Only set this when you set `stream: true`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub stream_options: Option<StreamOptions>,
    /// What sampling temperature to use, between 0 and 2.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub temperature: Option<f64>,
    /// Configuration options for a text response from the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text: Option<serde_json::Value>,
    /// How the model should select which tool (or tools) to use when generating a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_choice: Option<ToolChoice>,
    /// An array of tools the model may call while generating a response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tools: Option<Vec<serde_json::Value>>,
    /// An integer between 0 and 20 specifying the number of most likely tokens to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub top_logprobs: Option<i64>,
    /// An alternative to sampling with temperature, called nucleus sampling, where the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub top_p: Option<f64>,
    /// The truncation strategy to use for the model response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub truncation: Option<ResponseCreateParamsBaseTruncation>,
    /// This field is being replaced by `safety_identifier` and `prompt_cache_key`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ContextManagement {
    /// The context management entry type. Currently only 'compaction' is supported.
    #[serde(rename = "type")]
    pub type_: String,
    /// Token threshold at which compaction should be triggered for this entry.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub compact_threshold: Option<i64>,
}

/// Options for streaming responses. Only set this when you set `stream: true`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct StreamOptions {
    /// When true, stream obfuscation will be enabled.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include_obfuscation: Option<bool>,
}

pub type ResponseCreateParams = serde_json::Value;

/// An event that is emitted when a response is created.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCreatedEvent {
    /// The response that was created.
    pub response: Response,
    /// The sequence number for this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.created`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A call to a custom tool created by the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCustomToolCall {
    /// An identifier used to map this custom tool call to a tool call output.
    pub call_id: String,
    /// The input for the custom tool call generated by the model.
    pub input: String,
    /// The name of the custom tool being called.
    pub name: String,
    /// The type of the custom tool call. Always `custom_tool_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the custom tool call in the OpenAI platform.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The namespace of the custom tool being called.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub namespace: Option<String>,
}

/// Event representing a delta (partial update) to the input of a custom tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCustomToolCallInputDeltaEvent {
    /// The incremental input data (delta) for the custom tool call.
    pub delta: String,
    /// Unique identifier for the API item associated with this event.
    pub item_id: String,
    /// The index of the output this delta applies to.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The event type identifier.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Event indicating that input for a custom tool call is complete.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCustomToolCallInputDoneEvent {
    /// The complete input data for the custom tool call.
    pub input: String,
    /// Unique identifier for the API item associated with this event.
    pub item_id: String,
    /// The index of the output this event applies to.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The event type identifier.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type OutputOutputContentList = serde_json::Value;

/// The output of a custom tool call from your code, being sent back to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCustomToolCallOutput {
    /// The call ID, used to map this custom tool call output to a custom tool call.
    pub call_id: String,
    /// The output from the custom tool call generated by your code. Can be a string or
    pub output: String,
    /// The type of the custom tool call output. Always `custom_tool_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the custom tool call output in the OpenAI platform.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseErrorCode {
    #[serde(rename = "server_error")]
    ServerError,
    #[serde(rename = "rate_limit_exceeded")]
    RateLimitExceeded,
    #[serde(rename = "invalid_prompt")]
    InvalidPrompt,
    #[serde(rename = "vector_store_timeout")]
    VectorStoreTimeout,
    #[serde(rename = "invalid_image")]
    InvalidImage,
    #[serde(rename = "invalid_image_format")]
    InvalidImageFormat,
    #[serde(rename = "invalid_base64_image")]
    InvalidBase64Image,
    #[serde(rename = "invalid_image_url")]
    InvalidImageUrl,
    #[serde(rename = "image_too_large")]
    ImageTooLarge,
    #[serde(rename = "image_too_small")]
    ImageTooSmall,
    #[serde(rename = "image_parse_error")]
    ImageParseError,
    #[serde(rename = "image_content_policy_violation")]
    ImageContentPolicyViolation,
    #[serde(rename = "invalid_image_mode")]
    InvalidImageMode,
    #[serde(rename = "image_file_too_large")]
    ImageFileTooLarge,
    #[serde(rename = "unsupported_image_media_type")]
    UnsupportedImageMediaType,
    #[serde(rename = "empty_image_file")]
    EmptyImageFile,
    #[serde(rename = "failed_to_download_image")]
    FailedToDownloadImage,
    #[serde(rename = "image_file_not_found")]
    ImageFileNotFound,
}

/// Emitted when a file search call is completed (results found).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFileSearchCallCompletedEvent {
    /// The ID of the output item that the file search call is initiated.
    pub item_id: String,
    /// The index of the output item that the file search call is initiated.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.file_search_call.completed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a file search call is initiated.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFileSearchCallInProgressEvent {
    /// The ID of the output item that the file search call is initiated.
    pub item_id: String,
    /// The index of the output item that the file search call is initiated.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.file_search_call.in_progress`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a file search is currently searching.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFileSearchCallSearchingEvent {
    /// The ID of the output item that the file search call is initiated.
    pub item_id: String,
    /// The index of the output item that the file search call is searching.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.file_search_call.searching`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct FileSearchResult {
    /// Set of 16 key-value pairs that can be attached to an object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub attributes: Option<std::collections::HashMap<String, serde_json::Value>>,
    /// The unique ID of the file.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_id: Option<String>,
    /// The name of the file.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub filename: Option<String>,
    /// The relevance score of the file - a value between 0 and 1.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub score: Option<f64>,
    /// The text that was retrieved from the file.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseFileSearchToolCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "searching")]
    Searching,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "failed")]
    Failed,
}

/// The results of a file search tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFileSearchToolCall {
    /// The unique ID of the file search tool call.
    pub id: String,
    /// The queries used to search for files.
    pub queries: Vec<String>,
    /// The status of the file search tool call.
    pub status: ResponseFileSearchToolCallStatus,
    /// The type of the file search tool call. Always `file_search_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The results of the file search tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub results: Option<Vec<FileSearchResult>>,
}

pub type ResponseFormatTextConfig = serde_json::Value;

/// JSON Schema response format.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFormatTextJSONSchemaConfig {
    /// The name of the response format.
    pub name: String,
    /// The schema for the response format, described as a JSON Schema object. Learn how
    #[serde(rename = "schema")]
    pub schema_: std::collections::HashMap<String, serde_json::Value>,
    /// The type of response format being defined. Always `json_schema`.
    #[serde(rename = "type")]
    pub type_: String,
    /// A description of what the response format is for, used by the model to determine
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub description: Option<String>,
    /// Whether to enable strict schema adherence when generating the output. If set to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub strict: Option<bool>,
}

pub type ResponseFunctionCallOutputItem = serde_json::Value;

pub type ResponseFunctionCallOutputItemList = Vec<ResponseFunctionCallOutputItem>;

/// Indicates that the shell call exceeded its configured time limit.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutcomeTimeout {
    /// The outcome type. Always `timeout`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Indicates that the shell commands finished and returned an exit code.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutcomeExit {
    /// The exit code returned by the shell process.
    pub exit_code: i64,
    /// The outcome type. Always `exit`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Outcome = serde_json::Value;

/// Captured stdout and stderr for a portion of a shell tool call output.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionShellCallOutputContent {
    /// The exit or timeout outcome associated with this shell call.
    pub outcome: Outcome,
    /// Captured stderr output for the shell call.
    pub stderr: String,
    /// Captured stdout output for the shell call.
    pub stdout: String,
}

/// The shell commands and limits that describe how to run the tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct FunctionShellAction {
    pub commands: Vec<String>,
    /// Optional maximum number of characters to return from each command.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_length: Option<i64>,
    /// Optional timeout in milliseconds for the commands.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub timeout_ms: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseFunctionShellToolCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// A tool call that executes one or more shell commands in a managed environment.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionShellToolCall {
    /// The unique ID of the shell tool call.
    pub id: String,
    /// The shell commands and limits that describe how to run the tool call.
    pub action: FunctionShellAction,
    /// The unique ID of the shell tool call generated by the model.
    pub call_id: String,
    /// Represents the use of a local environment to perform shell actions.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub environment: Option<Environment>,
    /// The status of the shell call.
    pub status: ResponseFunctionShellToolCallStatus,
    /// The type of the item. Always `shell_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the entity that created this tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
}

/// Indicates that the shell call exceeded its configured time limit.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputOutcomeTimeout {
    /// The outcome type. Always `timeout`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Indicates that the shell commands finished and returned an exit code.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputOutcomeExit {
    /// Exit code from the shell process.
    pub exit_code: i64,
    /// The outcome type. Always `exit`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type OutputOutcome = serde_json::Value;

/// The content of a shell tool call output that was emitted.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct FunctionShellOutput {
    /// Represents either an exit outcome (with an exit code) or a timeout outcome for a
    pub outcome: OutputOutcome,
    /// The standard error output that was captured.
    pub stderr: String,
    /// The standard output that was captured.
    pub stdout: String,
    /// The identifier of the actor that created the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseFunctionShellToolCallOutputStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// The output of a shell tool call that was emitted.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionShellToolCallOutput {
    /// The unique ID of the shell call output.
    pub id: String,
    /// The unique ID of the shell tool call generated by the model.
    pub call_id: String,
    /// The maximum length of the shell command output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_length: Option<i64>,
    /// An array of shell call output contents
    pub output: Vec<FunctionShellOutput>,
    /// The status of the shell call output.
    pub status: ResponseFunctionShellToolCallOutputStatus,
    /// The type of the shell call output. Always `shell_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The identifier of the actor that created the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseFunctionToolCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// A tool call to run a function.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionToolCall {
    /// A JSON string of the arguments to pass to the function.
    pub arguments: String,
    /// The unique ID of the function tool call generated by the model.
    pub call_id: String,
    /// The name of the function to run.
    pub name: String,
    /// The type of the function tool call. Always `function_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the function tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The namespace of the function to run.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub namespace: Option<String>,
    /// The status of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ResponseFunctionToolCallStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseFunctionToolCallOutputItemStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionToolCallOutputItem {
    /// The unique ID of the function call tool output.
    pub id: String,
    /// The unique ID of the function tool call generated by the model.
    pub call_id: String,
    /// The output from the function call generated by your code. Can be a string or an
    pub output: String,
    /// The type of the function tool call output. Always `function_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The status of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ResponseFunctionToolCallOutputItemStatus>,
}

/// A source used in the search.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionSearchSource {
    /// The type of source. Always `url`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The URL of the source.
    pub url: String,
}

/// Action type "search" - Performs a web search query.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionSearch {
    /// [DEPRECATED] The search query.
    pub query: String,
    /// The action type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The search queries.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub queries: Option<Vec<String>>,
    /// The sources used in the search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub sources: Option<Vec<ActionSearchSource>>,
}

/// Action type "open_page" - Opens a specific URL from search results.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionOpenPage {
    /// The action type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The URL opened by the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub url: Option<String>,
}

/// Action type "find_in_page": Searches for a pattern within a loaded page.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ActionFind {
    /// The pattern or text to search for within the page.
    pub pattern: String,
    /// The action type.
    #[serde(rename = "type")]
    pub type_: String,
    /// The URL of the page searched for the pattern.
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseFunctionWebSearchStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "searching")]
    Searching,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
}

/// The results of a web search tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionWebSearch {
    /// The unique ID of the web search tool call.
    pub id: String,
    /// An object describing the specific action taken in this web search call. Includes
    pub action: FunctionShellAction,
    /// The status of the web search tool call.
    pub status: ResponseFunctionWebSearchStatus,
    /// The type of the web search tool call. Always `web_search_call`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when an image generation tool call has completed and the final image is available.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseImageGenCallCompletedEvent {
    /// The unique identifier of the image generation item being processed.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.image_generation_call.completed'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when an image generation tool call is actively generating an image (intermediate state).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseImageGenCallGeneratingEvent {
    /// The unique identifier of the image generation item being processed.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// The sequence number of the image generation item being processed.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.image_generation_call.generating'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when an image generation tool call is in progress.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseImageGenCallInProgressEvent {
    /// The unique identifier of the image generation item being processed.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// The sequence number of the image generation item being processed.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.image_generation_call.in_progress'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a partial image is available during image generation streaming.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseImageGenCallPartialImageEvent {
    /// The unique identifier of the image generation item being processed.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// Base64-encoded partial image data, suitable for rendering as an image.
    pub partial_image_b64: String,
    /// 0-based index for the partial image (backend is 1-based, but this is 0-based for
    pub partial_image_index: i64,
    /// The sequence number of the image generation item being processed.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.image_generation_call.partial_image'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the response is in progress.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInProgressEvent {
    /// The response that is in progress.
    pub response: Response,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.in_progress`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseIncludable {
    #[serde(rename = "file_search_call.results")]
    FileSearchCallResults,
    #[serde(rename = "web_search_call.results")]
    WebSearchCallResults,
    #[serde(rename = "web_search_call.action.sources")]
    WebSearchCallActionSources,
    #[serde(rename = "message.input_image.image_url")]
    MessageInputImageImageUrl,
    #[serde(rename = "computer_call_output.output.image_url")]
    ComputerCallOutputOutputImageUrl,
    #[serde(rename = "code_interpreter_call.outputs")]
    CodeInterpreterCallOutputs,
    #[serde(rename = "reasoning.encrypted_content")]
    ReasoningEncryptedContent,
    #[serde(rename = "message.output_text.logprobs")]
    MessageOutputTextLogprobs,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum InputAudioFormat {
    #[serde(rename = "mp3")]
    Mp3,
    #[serde(rename = "wav")]
    Wav,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudio {
    /// Base64-encoded audio data.
    pub data: String,
    /// The format of the audio data. Currently supported formats are `mp3` and `wav`.
    pub format: InputAudioFormat,
}

/// An audio input to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputAudio {
    pub input_audio: InputAudio,
    /// The type of the input item. Always `input_audio`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ResponseInputContent = serde_json::Value;

/// A file input to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputFile {
    /// The type of the input item. Always `input_file`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The content of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_data: Option<String>,
    /// The ID of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_id: Option<String>,
    /// The URL of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_url: Option<String>,
    /// The name of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub filename: Option<String>,
}

/// A file input to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputFileContent {
    /// The type of the input item. Always `input_file`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The base64-encoded data of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_data: Option<String>,
    /// The ID of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_id: Option<String>,
    /// The URL of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_url: Option<String>,
    /// The name of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub filename: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseInputImageDetail {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "original")]
    Original,
}

/// An image input to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputImage {
    /// The detail level of the image to be sent to the model.
    pub detail: ResponseInputImageDetail,
    /// The type of the input item. Always `input_image`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_id: Option<String>,
    /// The URL of the image to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub image_url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseInputImageContentDetail {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "original")]
    Original,
}

/// An image input to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputImageContent {
    /// The type of the input item. Always `input_image`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The detail level of the image to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub detail: Option<ResponseInputImageContentDetail>,
    /// The ID of the file to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_id: Option<String>,
    /// The URL of the image to be sent to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub image_url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum MessageRole {
    #[serde(rename = "user")]
    User,
    #[serde(rename = "system")]
    System,
    #[serde(rename = "developer")]
    Developer,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum MessageStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// A message input to the model with a role indicating instruction following
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Message {
    /// A list of one or many input items to the model, containing different content
    pub content: ResponseInputMessageContentList,
    /// The role of the message input. One of `user`, `system`, or `developer`.
    pub role: MessageRole,
    /// The status of item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<MessageStatus>,
    /// The type of the message input. Always set to `message`.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

/// A pending safety check for the computer call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ComputerCallOutputAcknowledgedSafetyCheck {
    /// The ID of the pending safety check.
    pub id: String,
    /// The type of the pending safety check.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub code: Option<String>,
    /// Details about the pending safety check.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub message: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ComputerCallOutputStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// The output of a computer tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ComputerCallOutput {
    /// The ID of the computer tool call that produced the output.
    pub call_id: String,
    /// A computer screenshot image used with the computer use tool.
    pub output: ResponseComputerToolCallOutputScreenshot,
    /// The type of the computer tool call output. Always `computer_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the computer tool call output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The safety checks reported by the API that have been acknowledged by the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub acknowledged_safety_checks: Option<Vec<ComputerCallOutputAcknowledgedSafetyCheck>>,
    /// The status of the message input.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ComputerCallOutputStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum FunctionCallOutputStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ToolSearchCallExecution {
    #[serde(rename = "server")]
    Server,
    #[serde(rename = "client")]
    Client,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ToolSearchCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolSearchCall {
    /// The arguments supplied to the tool search call.
    pub arguments: serde_json::Value,
    /// The item type. Always `tool_search_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of this tool search call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The unique ID of the tool search call generated by the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub call_id: Option<String>,
    /// Whether tool search was executed by the server or by the client.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub execution: Option<ToolSearchCallExecution>,
    /// The status of the tool search call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ToolSearchCallStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "generating")]
    Generating,
    #[serde(rename = "failed")]
    Failed,
}

/// An image generation request made by the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageGenerationCall {
    /// The unique ID of the image generation call.
    pub id: String,
    /// The generated image encoded in base64.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub result: Option<String>,
    /// The status of the image generation call.
    pub status: ImageGenerationCallStatus,
    /// The type of the image generation call. Always `image_generation_call`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Execute a shell command on the server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LocalShellCallAction {
    /// The command to run.
    pub command: Vec<String>,
    /// Environment variables to set for the command.
    pub env: std::collections::HashMap<String, String>,
    /// The type of the local shell action. Always `exec`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional timeout in milliseconds for the command.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub timeout_ms: Option<i64>,
    /// Optional user to run the command as.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user: Option<String>,
    /// Optional working directory to run the command in.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub working_directory: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum LocalShellCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// A tool call to run a command on the local shell.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LocalShellCall {
    /// The unique ID of the local shell call.
    pub id: String,
    /// Execute a shell command on the server.
    pub action: LocalShellCallAction,
    /// The unique ID of the local shell tool call generated by the model.
    pub call_id: String,
    /// The status of the local shell call.
    pub status: LocalShellCallStatus,
    /// The type of the local shell call. Always `local_shell_call`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum LocalShellCallOutputStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// The output of a local shell tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LocalShellCallOutput {
    /// The unique ID of the local shell tool call generated by the model.
    pub id: String,
    /// A JSON string of the output of the local shell tool call.
    pub output: String,
    /// The type of the local shell tool call output. Always `local_shell_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The status of the item. One of `in_progress`, `completed`, or `incomplete`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<LocalShellCallOutputStatus>,
}

/// The shell commands and limits that describe how to run the tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ShellCallAction {
    /// Ordered shell commands for the execution environment to run.
    pub commands: Vec<String>,
    /// Maximum number of UTF-8 characters to capture from combined stdout and stderr
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_length: Option<i64>,
    /// Maximum wall-clock time in milliseconds to allow the shell commands to run.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub timeout_ms: Option<i64>,
}

pub type ShellCallEnvironment = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ShellCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// A tool representing a request to execute one or more shell commands.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ShellCall {
    /// The shell commands and limits that describe how to run the tool call.
    pub action: ShellCallAction,
    /// The unique ID of the shell tool call generated by the model.
    pub call_id: String,
    /// The type of the item. Always `shell_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the shell tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The environment to execute the shell commands in.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub environment: Option<ShellCallEnvironment>,
    /// The status of the shell call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ShellCallStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ShellCallOutputStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// The streamed output items emitted by a shell tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ShellCallOutput {
    /// The unique ID of the shell tool call generated by the model.
    pub call_id: String,
    /// Captured chunks of stdout and stderr output, along with their associated
    pub output: Vec<ResponseFunctionShellCallOutputContent>,
    /// The type of the item. Always `shell_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the shell tool call output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The maximum number of UTF-8 characters captured for this shell call's combined
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_length: Option<i64>,
    /// The status of the shell call output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ShellCallOutputStatus>,
}

/// Instruction for creating a new file via the apply_patch tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ApplyPatchCallOperationCreateFile {
    /// Unified diff content to apply when creating the file.
    pub diff: String,
    /// Path of the file to create relative to the workspace root.
    pub path: String,
    /// The operation type. Always `create_file`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Instruction for deleting an existing file via the apply_patch tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ApplyPatchCallOperationDeleteFile {
    /// Path of the file to delete relative to the workspace root.
    pub path: String,
    /// The operation type. Always `delete_file`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Instruction for updating an existing file via the apply_patch tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ApplyPatchCallOperationUpdateFile {
    /// Unified diff content to apply to the existing file.
    pub diff: String,
    /// Path of the file to update relative to the workspace root.
    pub path: String,
    /// The operation type. Always `update_file`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ApplyPatchCallOperation = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ApplyPatchCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
}

/// A tool call representing a request to create, delete, or update files using diff patches.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ApplyPatchCall {
    /// The unique ID of the apply patch tool call generated by the model.
    pub call_id: String,
    /// The specific create, delete, or update instruction for the apply_patch tool
    pub operation: ApplyPatchCallOperation,
    /// The status of the apply patch tool call. One of `in_progress` or `completed`.
    pub status: ApplyPatchCallStatus,
    /// The type of the item. Always `apply_patch_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the apply patch tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ApplyPatchCallOutputStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
}

/// The streamed output emitted by an apply patch tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ApplyPatchCallOutput {
    /// The unique ID of the apply patch tool call generated by the model.
    pub call_id: String,
    /// The status of the apply patch tool call output. One of `completed` or `failed`.
    pub status: ApplyPatchCallOutputStatus,
    /// The type of the item. Always `apply_patch_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the apply patch tool call output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// Optional human-readable log text from the apply patch tool (e.g., patch results
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<String>,
}

/// A tool available on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpListToolsTool {
    /// The JSON schema describing the tool's input.
    pub input_schema: serde_json::Value,
    /// The name of the tool.
    pub name: String,
    /// Additional annotations about the tool.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub annotations: Option<serde_json::Value>,
    /// The description of the tool.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub description: Option<String>,
}

/// A list of tools available on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpListTools {
    /// The unique ID of the list.
    pub id: String,
    /// The label of the MCP server.
    pub server_label: String,
    /// The tools available on the server.
    pub tools: Vec<McpListToolsTool>,
    /// The type of the item. Always `mcp_list_tools`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Error message if the server could not list tools.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub error: Option<String>,
}

/// A request for human approval of a tool invocation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpApprovalRequest {
    /// The unique ID of the approval request.
    pub id: String,
    /// A JSON string of arguments for the tool.
    pub arguments: String,
    /// The name of the tool to run.
    pub name: String,
    /// The label of the MCP server making the request.
    pub server_label: String,
    /// The type of the item. Always `mcp_approval_request`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A response to an MCP approval request.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpApprovalResponse {
    /// The ID of the approval request being answered.
    pub approval_request_id: String,
    /// Whether the request was approved.
    pub approve: bool,
    /// The type of the item. Always `mcp_approval_response`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the approval response
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// Optional reason for the decision.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub reason: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum McpCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "calling")]
    Calling,
    #[serde(rename = "failed")]
    Failed,
}

/// An invocation of a tool on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpCall {
    /// The unique ID of the tool call.
    pub id: String,
    /// A JSON string of the arguments passed to the tool.
    pub arguments: String,
    /// The name of the tool that was run.
    pub name: String,
    /// The label of the MCP server running the tool.
    pub server_label: String,
    /// The type of the item. Always `mcp_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Unique identifier for the MCP tool call approval request. Include this value in
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub approval_request_id: Option<String>,
    /// The error from the tool call, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub error: Option<String>,
    /// The output from the tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<String>,
    /// The status of the tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<McpCallStatus>,
}

/// An internal identifier for an item to reference.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ItemReference {
    /// The ID of the item to reference.
    pub id: String,
    /// The type of item to reference. Always `item_reference`.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

pub type ResponseInputMessageContentList = Vec<ResponseInputContent>;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseInputMessageItemRole {
    #[serde(rename = "user")]
    User,
    #[serde(rename = "system")]
    System,
    #[serde(rename = "developer")]
    Developer,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseInputMessageItemStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputMessageItem {
    /// The unique ID of the message input.
    pub id: String,
    /// A list of one or many input items to the model, containing different content
    pub content: ResponseInputMessageContentList,
    /// The role of the message input. One of `user`, `system`, or `developer`.
    pub role: ResponseInputMessageItemRole,
    /// The status of item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ResponseInputMessageItemStatus>,
    /// The type of the message input. Always set to `message`.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

/// A text input to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputText {
    /// The text input to the model.
    pub text: String,
    /// The type of the input item. Always `input_text`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A text input to the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseInputTextContent {
    /// The text input to the model.
    pub text: String,
    /// The type of the input item. Always `input_text`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ResponseItem = serde_json::Value;

/// A list of Response items.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseItemList {
    /// A list of items used to generate this response.
    pub data: Vec<ResponseItem>,
    /// The ID of the first item in the list.
    pub first_id: String,
    /// Whether there are more items available.
    pub has_more: bool,
    /// The ID of the last item in the list.
    pub last_id: String,
    /// The type of object returned, must be `list`.
    pub object: String,
}

/// Represents the use of a local environment to perform shell actions.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseLocalEnvironment {
    /// The environment type. Always `local`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when there is a delta (partial update) to the arguments of an MCP tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallArgumentsDeltaEvent {
    /// A JSON string containing the partial update to the arguments for the MCP tool
    pub delta: String,
    /// The unique identifier of the MCP tool call item being processed.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_call_arguments.delta'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the arguments for an MCP tool call are finalized.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallArgumentsDoneEvent {
    /// A JSON string containing the finalized arguments for the MCP tool call.
    pub arguments: String,
    /// The unique identifier of the MCP tool call item being processed.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_call_arguments.done'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when an MCP  tool call has completed successfully.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallCompletedEvent {
    /// The ID of the MCP tool call item that completed.
    pub item_id: String,
    /// The index of the output item that completed.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_call.completed'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when an MCP  tool call has failed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallFailedEvent {
    /// The ID of the MCP tool call item that failed.
    pub item_id: String,
    /// The index of the output item that failed.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_call.failed'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when an MCP  tool call is in progress.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallInProgressEvent {
    /// The unique identifier of the MCP tool call item being processed.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_call.in_progress'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the list of available MCP tools has been successfully retrieved.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpListToolsCompletedEvent {
    /// The ID of the MCP tool call item that produced this output.
    pub item_id: String,
    /// The index of the output item that was processed.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_list_tools.completed'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the attempt to list available MCP tools has failed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpListToolsFailedEvent {
    /// The ID of the MCP tool call item that failed.
    pub item_id: String,
    /// The index of the output item that failed.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_list_tools.failed'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when the system is in the process of retrieving the list of available MCP tools.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpListToolsInProgressEvent {
    /// The ID of the MCP tool call item that is being processed.
    pub item_id: String,
    /// The index of the output item that is being processed.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.mcp_list_tools.in_progress'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when an output item is marked done.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseOutputItemDoneEvent {
    /// The output item that was marked done.
    pub item: ResponseOutputItem,
    /// The index of the output item that was marked done.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.output_item.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Content = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseOutputMessageStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseOutputMessagePhase {
    #[serde(rename = "commentary")]
    Commentary,
    #[serde(rename = "final_answer")]
    FinalAnswer,
}

/// An output message from the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseOutputMessage {
    /// The unique ID of the output message.
    pub id: String,
    /// The content of the output message.
    pub content: Vec<ReasoningItemContent>,
    /// The role of the output message. Always `assistant`.
    pub role: String,
    /// The status of the message input.
    pub status: ResponseOutputMessageStatus,
    /// The type of the output message. Always `message`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Labels an `assistant` message as intermediate commentary (`commentary`) or the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub phase: Option<ResponseOutputMessagePhase>,
}

/// A refusal from the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseOutputRefusal {
    /// The refusal explanation from the model.
    pub refusal: String,
    /// The type of the refusal. Always `refusal`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A citation to a file.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AnnotationFileCitation {
    /// The ID of the file.
    pub file_id: String,
    /// The filename of the file cited.
    pub filename: String,
    /// The index of the file in the list of files.
    pub index: i64,
    /// The type of the file citation. Always `file_citation`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A citation for a web resource used to generate a model response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AnnotationURLCitation {
    /// The index of the last character of the URL citation in the message.
    pub end_index: i64,
    /// The index of the first character of the URL citation in the message.
    pub start_index: i64,
    /// The title of the web resource.
    pub title: String,
    /// The type of the URL citation. Always `url_citation`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The URL of the web resource.
    pub url: String,
}

/// A citation for a container file used to generate a model response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AnnotationContainerFileCitation {
    /// The ID of the container file.
    pub container_id: String,
    /// The index of the last character of the container file citation in the message.
    pub end_index: i64,
    /// The ID of the file.
    pub file_id: String,
    /// The filename of the container file cited.
    pub filename: String,
    /// The index of the first character of the container file citation in the message.
    pub start_index: i64,
    /// The type of the container file citation. Always `container_file_citation`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A path to a file.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AnnotationFilePath {
    /// The ID of the file.
    pub file_id: String,
    /// The index of the file in the list of files.
    pub index: i64,
    /// The type of the file path. Always `file_path`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Annotation = serde_json::Value;

/// The top log probability of a token.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LogprobTopLogprob {
    pub token: String,
    pub bytes: Vec<i64>,
    pub logprob: f64,
}

/// The log probability of a token.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Logprob {
    pub token: String,
    pub bytes: Vec<i64>,
    pub logprob: f64,
    pub top_logprobs: Vec<LogprobTopLogprob>,
}

/// A text output from the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseOutputText {
    /// The annotations of the text output.
    pub annotations: Vec<Annotation>,
    /// The text output from the model.
    pub text: String,
    /// The type of the output text. Always `output_text`.
    #[serde(rename = "type")]
    pub type_: String,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub logprobs: Option<Vec<Logprob>>,
}

/// Emitted when an annotation is added to output text content.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseOutputTextAnnotationAddedEvent {
    /// The annotation object being added. (See annotation schema for details.)
    pub annotation: serde_json::Value,
    /// The index of the annotation within the content part.
    pub annotation_index: i64,
    /// The index of the content part within the output item.
    pub content_index: i64,
    /// The unique identifier of the item to which the annotation is being added.
    pub item_id: String,
    /// The index of the output item in the response's output array.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.output_text.annotation.added'.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Variables = serde_json::Value;

/// Reference to a prompt template and its variables.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponsePrompt {
    /// The unique identifier of the prompt template to use.
    pub id: String,
    /// Optional map of values to substitute in for variables in your prompt.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub variables: Option<std::collections::HashMap<String, Variables>>,
    /// Optional version of the prompt template.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub version: Option<String>,
}

/// Emitted when a response is queued and waiting to be processed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseQueuedEvent {
    /// The full response object that is queued.
    pub response: Response,
    /// The sequence number for this event.
    pub sequence_number: i64,
    /// The type of the event. Always 'response.queued'.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A summary text from the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ReasoningItemSummary {
    /// A summary of the reasoning output from the model so far.
    pub text: String,
    /// The type of the object. Always `summary_text`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Reasoning text from the model.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ReasoningItemContent {
    /// The reasoning text from the model.
    pub text: String,
    /// The type of the reasoning text. Always `reasoning_text`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseReasoningItemStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

/// A description of the chain of thought used by a reasoning model while generating
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseReasoningItem {
    /// The unique identifier of the reasoning content.
    pub id: String,
    /// Reasoning summary content.
    pub summary: Vec<ReasoningItemSummary>,
    /// The type of the object. Always `reasoning`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Reasoning text content.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub content: Option<Vec<ReasoningItemContent>>,
    /// The encrypted content of the reasoning item - populated when a response is
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub encrypted_content: Option<String>,
    /// The status of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<ResponseReasoningItemStatus>,
}

/// The summary part that was added.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ReasoningSummaryPart {
    /// The text of the summary part.
    pub text: String,
    /// The type of the summary part. Always `summary_text`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a new reasoning summary part is added.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseReasoningSummaryPartAddedEvent {
    /// The ID of the item this summary part is associated with.
    pub item_id: String,
    /// The index of the output item this summary part is associated with.
    pub output_index: i64,
    /// The summary part that was added.
    pub part: ReasoningSummaryPart,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The index of the summary part within the reasoning summary.
    pub summary_index: i64,
    /// The type of the event. Always `response.reasoning_summary_part.added`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a reasoning summary part is completed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseReasoningSummaryPartDoneEvent {
    /// The ID of the item this summary part is associated with.
    pub item_id: String,
    /// The index of the output item this summary part is associated with.
    pub output_index: i64,
    /// The completed summary part.
    pub part: ReasoningSummaryPart,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The index of the summary part within the reasoning summary.
    pub summary_index: i64,
    /// The type of the event. Always `response.reasoning_summary_part.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a reasoning summary text is completed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseReasoningSummaryTextDoneEvent {
    /// The ID of the item this summary text is associated with.
    pub item_id: String,
    /// The index of the output item this summary text is associated with.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The index of the summary part within the reasoning summary.
    pub summary_index: i64,
    /// The full text of the completed reasoning summary.
    pub text: String,
    /// The type of the event. Always `response.reasoning_summary_text.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a reasoning text is completed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseReasoningTextDoneEvent {
    /// The index of the reasoning content part.
    pub content_index: i64,
    /// The ID of the item this reasoning text is associated with.
    pub item_id: String,
    /// The index of the output item this reasoning text is associated with.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The full text of the completed reasoning content.
    pub text: String,
    /// The type of the event. Always `response.reasoning_text.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when there is a partial refusal text.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseRefusalDeltaEvent {
    /// The index of the content part that the refusal text is added to.
    pub content_index: i64,
    /// The refusal text that is added.
    pub delta: String,
    /// The ID of the output item that the refusal text is added to.
    pub item_id: String,
    /// The index of the output item that the refusal text is added to.
    pub output_index: i64,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.refusal.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when refusal text is finalized.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseRefusalDoneEvent {
    /// The index of the content part that the refusal text is finalized.
    pub content_index: i64,
    /// The ID of the output item that the refusal text is finalized.
    pub item_id: String,
    /// The index of the output item that the refusal text is finalized.
    pub output_index: i64,
    /// The refusal text that is finalized.
    pub refusal: String,
    /// The sequence number of this event.
    pub sequence_number: i64,
    /// The type of the event. Always `response.refusal.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseRetrieveParamsBase {
    /// Additional fields to include in the response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<ResponseIncludable>>,
    /// When true, stream obfuscation will be enabled.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include_obfuscation: Option<bool>,
    /// The sequence number of the event after which to start streaming.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub starting_after: Option<i64>,
}

pub type ResponseRetrieveParams = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "cancelled")]
    Cancelled,
    #[serde(rename = "queued")]
    Queued,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseTextConfigVerbosity {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

/// Emitted when text content is finalized.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseTextDoneEvent {
    /// The index of the content part that the text content is finalized.
    pub content_index: i64,
    /// The ID of the output item that the text content is finalized.
    pub item_id: String,
    /// The log probabilities of the tokens in the delta.
    pub logprobs: Vec<Logprob>,
    /// The index of the output item that the text content is finalized.
    pub output_index: i64,
    /// The sequence number for this event.
    pub sequence_number: i64,
    /// The text content that is finalized.
    pub text: String,
    /// The type of the event. Always `response.output_text.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseToolSearchCallExecution {
    #[serde(rename = "server")]
    Server,
    #[serde(rename = "client")]
    Client,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseToolSearchCallStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseToolSearchCall {
    /// The unique ID of the tool search call item.
    pub id: String,
    /// Arguments used for the tool search call.
    pub arguments: serde_json::Value,
    /// The unique ID of the tool search call generated by the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub call_id: Option<String>,
    /// Whether tool search was executed by the server or by the client.
    pub execution: ResponseToolSearchCallExecution,
    /// The status of the tool search call item that was recorded.
    pub status: ResponseToolSearchCallStatus,
    /// The type of the item. Always `tool_search_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The identifier of the actor that created the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseToolSearchOutputItemExecution {
    #[serde(rename = "server")]
    Server,
    #[serde(rename = "client")]
    Client,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponseToolSearchOutputItemStatus {
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseToolSearchOutputItem {
    /// The unique ID of the tool search output item.
    pub id: String,
    /// The unique ID of the tool search call generated by the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub call_id: Option<String>,
    /// Whether tool search was executed by the server or by the client.
    pub execution: ResponseToolSearchOutputItemExecution,
    /// The status of the tool search output item that was recorded.
    pub status: ResponseToolSearchOutputItemStatus,
    /// The loaded tool definitions returned by tool search.
    pub tools: Vec<Tool>,
    /// The type of the item. Always `tool_search_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The identifier of the actor that created the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub created_by: Option<String>,
}

/// Emitted when a web search call is completed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseWebSearchCallCompletedEvent {
    /// Unique ID for the output item associated with the web search call.
    pub item_id: String,
    /// The index of the output item that the web search call is associated with.
    pub output_index: i64,
    /// The sequence number of the web search call being processed.
    pub sequence_number: i64,
    /// The type of the event. Always `response.web_search_call.completed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a web search call is initiated.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseWebSearchCallInProgressEvent {
    /// Unique ID for the output item associated with the web search call.
    pub item_id: String,
    /// The index of the output item that the web search call is associated with.
    pub output_index: i64,
    /// The sequence number of the web search call being processed.
    pub sequence_number: i64,
    /// The type of the event. Always `response.web_search_call.in_progress`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Emitted when a web search call is executing.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseWebSearchCallSearchingEvent {
    /// Unique ID for the output item associated with the web search call.
    pub item_id: String,
    /// The index of the output item that the web search call is associated with.
    pub output_index: i64,
    /// The sequence number of the web search call being processed.
    pub sequence_number: i64,
    /// The type of the event. Always `response.web_search_call.searching`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponsesClientEventPromptCacheRetention {
    #[serde(rename = "in-memory")]
    InMemory,
    #[serde(rename = "24h")]
    V24h,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponsesClientEventServiceTier {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "default")]
    Default,
    #[serde(rename = "flex")]
    Flex,
    #[serde(rename = "scale")]
    Scale,
    #[serde(rename = "priority")]
    Priority,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ResponsesClientEventTruncation {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponsesClientEvent {
    /// The type of the client event. Always `response.create`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether to run the model response in the background.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub background: Option<bool>,
    /// Context management configuration for this request.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub context_management: Option<Vec<ContextManagement>>,
    /// The conversation that this response belongs to.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub conversation: Option<Conversation>,
    /// Specify additional output data to include in the model response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<ResponseIncludable>>,
    /// Text, image, or file inputs to the model, used to generate a response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input: Option<String>,
    /// A system (or developer) message inserted into the model's context.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// An upper bound for the number of tokens that can be generated for a response,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_tokens: Option<i64>,
    /// The maximum number of total calls to built-in tools that can be processed in a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_tool_calls: Option<i64>,
    /// Set of 16 key-value pairs that can be attached to an object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub metadata: Option<serde_json::Value>,
    /// Model ID used to generate the response, like `gpt-4o` or `o3`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<serde_json::Value>,
    /// Whether to allow the model to run tool calls in parallel.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub parallel_tool_calls: Option<bool>,
    /// The unique ID of the previous response to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_response_id: Option<String>,
    /// Reference to a prompt template and its variables.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt: Option<ResponsePrompt>,
    /// Used by OpenAI to cache responses for similar requests to optimize your cache
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt_cache_key: Option<String>,
    /// The retention policy for the prompt cache.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt_cache_retention: Option<ResponsesClientEventPromptCacheRetention>,
    /// **gpt-5 and o-series models only**
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub reasoning: Option<serde_json::Value>,
    /// A stable identifier used to help detect users of your application that may be
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub safety_identifier: Option<String>,
    /// Specifies the processing type used for serving the request.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub service_tier: Option<ResponsesClientEventServiceTier>,
    /// Whether to store the generated model response for later retrieval via API.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub store: Option<bool>,
    /// If set to true, the model response data will be streamed to the client as it is
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub stream: Option<bool>,
    /// Options for streaming responses. Only set this when you set `stream: true`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub stream_options: Option<StreamOptions>,
    /// What sampling temperature to use, between 0 and 2.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub temperature: Option<f64>,
    /// Configuration options for a text response from the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text: Option<ResponseTextConfig>,
    /// How the model should select which tool (or tools) to use when generating a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_choice: Option<ToolChoice>,
    /// An array of tools the model may call while generating a response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tools: Option<Vec<Tool>>,
    /// An integer between 0 and 20 specifying the number of most likely tokens to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub top_logprobs: Option<i64>,
    /// An alternative to sampling with temperature, called nucleus sampling, where the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub top_p: Option<f64>,
    /// The truncation strategy to use for the model response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub truncation: Option<ResponsesClientEventTruncation>,
    /// This field is being replaced by `safety_identifier` and `prompt_cache_key`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user: Option<String>,
}

pub type ResponsesServerEvent = serde_json::Value;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct SkillReference {
    /// The ID of the referenced skill.
    pub skill_id: String,
    /// References a skill created with the /v1/skills endpoint.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional skill version. Use a positive integer or 'latest'. Omit for default.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub version: Option<String>,
}

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpAllowedToolsMcpToolFilter {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

pub type McpAllowedTools = serde_json::Value;

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpRequireApprovalMcpToolApprovalFilterAlways {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpRequireApprovalMcpToolApprovalFilterNever {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// Specify which of the MCP server's tools require approval.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpRequireApprovalMcpToolApprovalFilter {
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub always: Option<McpRequireApprovalMcpToolApprovalFilterAlways>,
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub never: Option<McpRequireApprovalMcpToolApprovalFilterNever>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum McpRequireApproval {
    Always,
    Never,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum McpConnectorId {
    #[serde(rename = "connector_dropbox")]
    ConnectorDropbox,
    #[serde(rename = "connector_gmail")]
    ConnectorGmail,
    #[serde(rename = "connector_googlecalendar")]
    ConnectorGooglecalendar,
    #[serde(rename = "connector_googledrive")]
    ConnectorGoogledrive,
    #[serde(rename = "connector_microsoftteams")]
    ConnectorMicrosoftteams,
    #[serde(rename = "connector_outlookcalendar")]
    ConnectorOutlookcalendar,
    #[serde(rename = "connector_outlookemail")]
    ConnectorOutlookemail,
    #[serde(rename = "connector_sharepoint")]
    ConnectorSharepoint,
}

/// Give the model access to additional tools via remote Model Context Protocol
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Mcp {
    /// A label for this MCP server, used to identify it in tool calls.
    pub server_label: String,
    /// The type of the MCP tool. Always `mcp`.
    #[serde(rename = "type")]
    pub type_: String,
    /// List of allowed tool names or a filter object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub allowed_tools: Option<McpAllowedTools>,
    /// An OAuth access token that can be used with a remote MCP server, either with a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub authorization: Option<String>,
    /// Identifier for service connectors, like those available in ChatGPT.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub connector_id: Option<McpConnectorId>,
    /// Whether this MCP tool is deferred and discovered via tool search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub defer_loading: Option<bool>,
    /// Optional HTTP headers to send to the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub headers: Option<std::collections::HashMap<String, String>>,
    /// Specify which of the MCP server's tools require approval.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub require_approval: Option<McpRequireApproval>,
    /// Optional description of the MCP server, used to provide more context.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_description: Option<String>,
    /// The URL for the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_url: Option<String>,
}

pub type CodeInterpreterContainerCodeInterpreterToolAutoNetworkPolicy = serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum CodeInterpreterContainerCodeInterpreterToolAutoMemoryLimit {
    #[serde(rename = "1g")]
    V1g,
    #[serde(rename = "4g")]
    V4g,
    #[serde(rename = "16g")]
    V16g,
    #[serde(rename = "64g")]
    V64g,
}

/// Configuration for a code interpreter container.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CodeInterpreterContainerCodeInterpreterToolAuto {
    /// Always `auto`.
    #[serde(rename = "type")]
    pub type_: String,
    /// An optional list of uploaded files to make available to your code.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_ids: Option<Vec<String>>,
    /// The memory limit for the code interpreter container.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub memory_limit: Option<CodeInterpreterContainerCodeInterpreterToolAutoMemoryLimit>,
    /// Network access policy for the container.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub network_policy: Option<CodeInterpreterContainerCodeInterpreterToolAutoNetworkPolicy>,
}

pub type CodeInterpreterContainer = serde_json::Value;

/// A tool that runs Python code to help generate a response to a prompt.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CodeInterpreter {
    /// The code interpreter container.
    pub container: CodeInterpreterContainer,
    /// The type of the code interpreter tool. Always `code_interpreter`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Optional mask for inpainting.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageGenerationInputImageMask {
    /// File ID for the mask image.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub file_id: Option<String>,
    /// Base64-encoded mask image.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub image_url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationAction {
    #[serde(rename = "generate")]
    Generate,
    #[serde(rename = "edit")]
    Edit,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationBackground {
    #[serde(rename = "transparent")]
    Transparent,
    #[serde(rename = "opaque")]
    Opaque,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationInputFidelity {
    #[serde(rename = "high")]
    High,
    #[serde(rename = "low")]
    Low,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationModeration {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "low")]
    Low,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationOutputFormat {
    #[serde(rename = "png")]
    Png,
    #[serde(rename = "webp")]
    Webp,
    #[serde(rename = "jpeg")]
    Jpeg,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationQuality {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ImageGenerationSize {
    #[serde(rename = "1024x1024")]
    V1024x1024,
    #[serde(rename = "1024x1536")]
    V1024x1536,
    #[serde(rename = "1536x1024")]
    V1536x1024,
    #[serde(rename = "auto")]
    Auto,
}

/// A tool that generates images using the GPT image models.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ImageGeneration {
    /// The type of the image generation tool. Always `image_generation`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether to generate a new image or edit an existing image. Default: `auto`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub action: Option<ImageGenerationAction>,
    /// Background type for the generated image.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub background: Option<ImageGenerationBackground>,
    /// Control how much effort the model will exert to match the style and features,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input_fidelity: Option<ImageGenerationInputFidelity>,
    /// Optional mask for inpainting.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input_image_mask: Option<ImageGenerationInputImageMask>,
    /// The image generation model to use. Default: `gpt-image-1`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// Moderation level for the generated image. Default: `auto`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub moderation: Option<ImageGenerationModeration>,
    /// Compression level for the output image. Default: 100.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_compression: Option<i64>,
    /// The output format of the generated image.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_format: Option<ImageGenerationOutputFormat>,
    /// Number of partial images to generate in streaming mode, from 0 (default value)
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub partial_images: Option<i64>,
    /// The quality of the generated image.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub quality: Option<ImageGenerationQuality>,
    /// The size of the generated image.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub size: Option<ImageGenerationSize>,
}

/// A tool that allows the model to execute shell commands in a local environment.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LocalShell {
    /// The type of the local shell tool. Always `local_shell`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ToolChoiceAllowedMode {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "required")]
    Required,
}

/// Constrains the tools available to the model to a pre-defined set.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolChoiceAllowed {
    /// Constrains the tools available to the model to a pre-defined set.
    pub mode: ToolChoiceAllowedMode,
    /// A list of tool definitions that the model should be allowed to call.
    pub tools: Vec<std::collections::HashMap<String, serde_json::Value>>,
    /// Allowed tool configuration type. Always `allowed_tools`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Forces the model to call the apply_patch tool when executing a tool call.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolChoiceApplyPatch {
    /// The tool to call. Always `apply_patch`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Use this option to force the model to call a specific custom tool.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolChoiceCustom {
    /// The name of the custom tool to call.
    pub name: String,
    /// For custom tool calling, the type is always `custom`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Use this option to force the model to call a specific tool on a remote MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolChoiceMcp {
    /// The label of the MCP server to use.
    pub server_label: String,
    /// For MCP tools, the type is always `mcp`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The name of the tool to call on the server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub name: Option<String>,
}

/// Forces the model to call the shell tool when a tool call is required.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolChoiceShell {
    /// The tool to call. Always `shell`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ToolChoiceTypesType {
    #[serde(rename = "file_search")]
    FileSearch,
    #[serde(rename = "web_search_preview")]
    WebSearchPreview,
    #[serde(rename = "computer")]
    Computer,
    #[serde(rename = "computer_use_preview")]
    ComputerUsePreview,
    #[serde(rename = "computer_use")]
    ComputerUse,
    #[serde(rename = "web_search_preview_2025_03_11")]
    WebSearchPreview20250311,
    #[serde(rename = "image_generation")]
    ImageGeneration,
    #[serde(rename = "code_interpreter")]
    CodeInterpreter,
}

/// Indicates that the model should use a built-in tool to generate a response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolChoiceTypes {
    /// The type of hosted tool the model should to use.
    #[serde(rename = "type")]
    pub type_: ToolChoiceTypesType,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ToolSearchToolExecution {
    #[serde(rename = "server")]
    Server,
    #[serde(rename = "client")]
    Client,
}

/// Hosted or BYOT tool search configuration for deferred tools.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolSearchTool {
    /// The type of the tool. Always `tool_search`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Description shown to the model for a client-executed tool search tool.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub description: Option<String>,
    /// Whether tool search is executed by the server or by the client.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub execution: Option<ToolSearchToolExecution>,
    /// Parameter schema for a client-executed tool search tool.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub parameters: Option<serde_json::Value>,
}

/// The user's location.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct UserLocation {
    /// The type of location approximation. Always `approximate`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Free text input for the city of the user, e.g. `San Francisco`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub city: Option<String>,
    /// The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub country: Option<String>,
    /// Free text input for the region of the user, e.g. `California`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub region: Option<String>,
    /// The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub timezone: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum WebSearchPreviewToolType {
    #[serde(rename = "web_search_preview")]
    WebSearchPreview,
    #[serde(rename = "web_search_preview_2025_03_11")]
    WebSearchPreview20250311,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum WebSearchPreviewToolSearchContextSize {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

/// This tool searches the web for relevant results to use in a response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct WebSearchPreviewTool {
    /// The type of the web search tool.
    #[serde(rename = "type")]
    pub type_: WebSearchPreviewToolType,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub search_content_types: Option<Vec<serde_json::Value>>,
    /// High level guidance for the amount of context window space to use for the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub search_context_size: Option<WebSearchPreviewToolSearchContextSize>,
    /// The user's location.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user_location: Option<UserLocation>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum WebSearchToolType {
    #[serde(rename = "web_search")]
    WebSearch,
    #[serde(rename = "web_search_2025_08_26")]
    WebSearch20250826,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum WebSearchToolSearchContextSize {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

/// Search the Internet for sources related to the prompt.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct WebSearchTool {
    /// The type of the web search tool.
    #[serde(rename = "type")]
    pub type_: WebSearchToolType,
    /// Filters for the search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub filters: Option<Filters>,
    /// High level guidance for the amount of context window space to use for the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub search_context_size: Option<WebSearchToolSearchContextSize>,
    /// The approximate location of the user.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub user_location: Option<UserLocation>,
}