async-openai 0.36.1

use crate::types::mcp::MCPTool;
use crate::types::responses::{
    ApplyPatchCallOutputStatus, ApplyPatchCallOutputStatusParam, ApplyPatchCallStatus,
    ApplyPatchCallStatusParam, ApplyPatchCreateFileOperation, ApplyPatchCreateFileOperationParam,
    ApplyPatchDeleteFileOperation, ApplyPatchDeleteFileOperationParam, ApplyPatchOperation,
    ApplyPatchOperationParam, ApplyPatchToolCall, ApplyPatchToolCallItemParam,
    ApplyPatchToolCallOutput, ApplyPatchToolCallOutputItemParam, ApplyPatchUpdateFileOperation,
    ApplyPatchUpdateFileOperationParam, CodeInterpreterContainerAuto, CodeInterpreterTool,
    CodeInterpreterToolCall, CodeInterpreterToolContainer, CompactionBody,
    CompactionSummaryItemParam, ComputerCallOutputItemParam, ComputerTool, ComputerToolCall,
    ComputerToolCallOutputResource, ComputerUsePreviewTool, ContainerReferenceParam,
    ContainerReferenceResource, ConversationParam, CustomToolCall, CustomToolCallOutput,
    CustomToolCallOutputResource, CustomToolParam, EasyInputContent, EasyInputMessage,
    FileSearchTool, FileSearchToolCall, FunctionCallOutput, FunctionCallOutputItemParam,
    FunctionCallOutputStatusEnum, FunctionCallStatus, FunctionShellAction,
    FunctionShellActionParam, FunctionShellCall, FunctionShellCallEnvironment,
    FunctionShellCallItemEnvironment, FunctionShellCallItemParam, FunctionShellCallItemStatus,
    FunctionShellCallOutput, FunctionShellCallOutputContent, FunctionShellCallOutputContentParam,
    FunctionShellCallOutputExitOutcome, FunctionShellCallOutputExitOutcomeParam,
    FunctionShellCallOutputItemParam, FunctionShellCallOutputOutcome,
    FunctionShellCallOutputOutcomeParam, FunctionTool, FunctionToolCall,
    FunctionToolCallOutputResource, ImageGenTool, ImageGenToolCall, InputContent, InputFileContent,
    InputImageContent, InputItem, InputMessage, InputParam, InputTextContent, Item, ItemReference,
    ItemReferenceType, LocalEnvironmentParam, LocalShellCallStatus, LocalShellToolCall,
    LocalShellToolCallOutput, MCPApprovalRequest, MCPApprovalResponse, MCPListTools, MCPToolCall,
    MessageItem, MessageType, NamespaceToolParam, OutputItem, OutputMessage, OutputMessageContent,
    OutputStatus, OutputTextContent, Prompt, Reasoning, ReasoningEffort, ReasoningItem,
    ReasoningSummary, RefusalContent, ResponseFormatJsonSchema, ResponsePromptVariables,
    ResponseStreamOptions, ResponseTextParam, Role, TextResponseFormatConfiguration, Tool,
    ToolChoiceCustom, ToolChoiceFunction, ToolChoiceMCP, ToolChoiceOptions, ToolChoiceParam,
    ToolChoiceTypes, ToolSearchCall, ToolSearchCallItemParam, ToolSearchOutput,
    ToolSearchOutputItemParam, ToolSearchToolParam, WebSearchTool, WebSearchToolCall,
};

impl<S: Into<String>> From<S> for EasyInputMessage {
    fn from(value: S) -> Self {
        EasyInputMessage {
            r#type: MessageType::Message,
            role: Role::User,
            content: EasyInputContent::Text(value.into()),
            phase: None,
        }
    }
}

impl From<EasyInputMessage> for InputItem {
    fn from(msg: EasyInputMessage) -> Self {
        InputItem::EasyMessage(msg)
    }
}

// InputItem ergonomics

impl From<InputMessage> for InputItem {
    fn from(msg: InputMessage) -> Self {
        InputItem::Item(Item::Message(MessageItem::Input(msg)))
    }
}

impl From<Item> for InputItem {
    fn from(item: Item) -> Self {
        InputItem::Item(item)
    }
}

impl From<ItemReference> for InputItem {
    fn from(item: ItemReference) -> Self {
        InputItem::ItemReference(item)
    }
}

// InputParam ergonomics: from InputItem

impl From<InputItem> for InputParam {
    fn from(item: InputItem) -> Self {
        InputParam::Items(vec![item])
    }
}

impl From<Item> for InputParam {
    fn from(item: Item) -> Self {
        InputParam::Items(vec![InputItem::Item(item)])
    }
}

impl From<MessageItem> for InputParam {
    fn from(item: MessageItem) -> Self {
        InputParam::Items(vec![InputItem::Item(Item::Message(item))])
    }
}

impl From<InputMessage> for InputParam {
    fn from(msg: InputMessage) -> Self {
        InputParam::Items(vec![InputItem::Item(Item::Message(MessageItem::Input(
            msg,
        )))])
    }
}

impl<I: Into<InputItem>> From<Vec<I>> for InputParam {
    fn from(items: Vec<I>) -> Self {
        InputParam::Items(items.into_iter().map(|item| item.into()).collect())
    }
}

impl<I: Into<InputItem>, const N: usize> From<[I; N]> for InputParam {
    fn from(items: [I; N]) -> Self {
        InputParam::Items(items.into_iter().map(|item| item.into()).collect())
    }
}

// InputParam ergonomics: from string "family"

impl From<&str> for InputParam {
    fn from(value: &str) -> Self {
        InputParam::Text(value.into())
    }
}

impl From<String> for InputParam {
    fn from(value: String) -> Self {
        InputParam::Text(value)
    }
}

impl From<&String> for InputParam {
    fn from(value: &String) -> Self {
        InputParam::Text(value.clone())
    }
}

// InputParam ergonomics: from vector family

macro_rules! impl_inputparam_easy_from_collection {
    // Vec<T>
    ($t:ty, $map:expr, $clone:expr) => {
        impl From<Vec<$t>> for InputParam {
            fn from(values: Vec<$t>) -> Self {
                InputParam::Items(
                    values
                        .into_iter()
                        .map(|value| {
                            InputItem::EasyMessage(EasyInputMessage {
                                r#type: MessageType::Message,
                                role: Role::User,
                                content: EasyInputContent::Text($map(value)),
                                phase: None,
                            })
                        })
                        .collect(),
                )
            }
        }
        // &[T; N]
        impl<const N: usize> From<[$t; N]> for InputParam {
            fn from(values: [$t; N]) -> Self {
                InputParam::Items(
                    values
                        .into_iter()
                        .map(|value| {
                            InputItem::EasyMessage(EasyInputMessage {
                                r#type: MessageType::Message,
                                role: Role::User,
                                content: EasyInputContent::Text($map(value)),
                                phase: None,
                            })
                        })
                        .collect(),
                )
            }
        }
        // &Vec<T>
        impl From<&Vec<$t>> for InputParam {
            fn from(values: &Vec<$t>) -> Self {
                InputParam::Items(
                    values
                        .iter()
                        .map(|value| {
                            InputItem::EasyMessage(EasyInputMessage {
                                r#type: MessageType::Message,
                                role: Role::User,
                                content: EasyInputContent::Text($clone(value)),
                                phase: None,
                            })
                        })
                        .collect(),
                )
            }
        }
    };
}

// Apply for &str
impl_inputparam_easy_from_collection!(&str, |v: &str| v.to_string(), |v: &str| v.to_string());
// Apply for String
impl_inputparam_easy_from_collection!(String, |v: String| v, |v: &String| v.clone());
// Apply for &String
impl_inputparam_easy_from_collection!(&String, |v: &String| v.clone(), |v: &String| v.clone());

// ConversationParam ergonomics

impl<S: Into<String>> From<S> for ConversationParam {
    fn from(id: S) -> Self {
        ConversationParam::ConversationID(id.into())
    }
}

// ToolChoiceParam ergonomics

impl From<ToolChoiceOptions> for ToolChoiceParam {
    fn from(mode: ToolChoiceOptions) -> Self {
        ToolChoiceParam::Mode(mode)
    }
}

impl From<ToolChoiceTypes> for ToolChoiceParam {
    fn from(tool_type: ToolChoiceTypes) -> Self {
        ToolChoiceParam::Hosted(tool_type)
    }
}

impl<S: Into<String>> From<S> for ToolChoiceParam {
    fn from(name: S) -> Self {
        ToolChoiceParam::Function(ToolChoiceFunction { name: name.into() })
    }
}

impl From<ToolChoiceFunction> for ToolChoiceParam {
    fn from(function: ToolChoiceFunction) -> Self {
        ToolChoiceParam::Function(function)
    }
}

impl From<ToolChoiceMCP> for ToolChoiceParam {
    fn from(mcp: ToolChoiceMCP) -> Self {
        ToolChoiceParam::Mcp(mcp)
    }
}

impl From<ToolChoiceCustom> for ToolChoiceParam {
    fn from(custom: ToolChoiceCustom) -> Self {
        ToolChoiceParam::Custom(custom)
    }
}

// ResponseTextParam ergonomics

impl From<TextResponseFormatConfiguration> for ResponseTextParam {
    fn from(format: TextResponseFormatConfiguration) -> Self {
        ResponseTextParam {
            format,
            verbosity: None,
        }
    }
}

impl From<ResponseFormatJsonSchema> for ResponseTextParam {
    fn from(schema: ResponseFormatJsonSchema) -> Self {
        ResponseTextParam {
            format: TextResponseFormatConfiguration::JsonSchema(schema),
            verbosity: None,
        }
    }
}

// ResponseStreamOptions ergonomics

impl From<bool> for ResponseStreamOptions {
    fn from(include_obfuscation: bool) -> Self {
        ResponseStreamOptions {
            include_obfuscation: Some(include_obfuscation),
        }
    }
}

// Reasoning ergonomics

impl From<ReasoningEffort> for Reasoning {
    fn from(effort: ReasoningEffort) -> Self {
        Reasoning {
            effort: Some(effort),
            summary: None,
        }
    }
}

impl From<ReasoningSummary> for Reasoning {
    fn from(summary: ReasoningSummary) -> Self {
        Reasoning {
            effort: None,
            summary: Some(summary),
        }
    }
}

// Prompt ergonomics

impl<S: Into<String>> From<S> for Prompt {
    fn from(id: S) -> Self {
        Prompt {
            id: id.into(),
            version: None,
            variables: None,
        }
    }
}

// InputTextContent ergonomics

impl<S: Into<String>> From<S> for InputTextContent {
    fn from(text: S) -> Self {
        InputTextContent { text: text.into() }
    }
}

// InputContent ergonomics

impl From<InputTextContent> for InputContent {
    fn from(content: InputTextContent) -> Self {
        InputContent::InputText(content)
    }
}

impl From<InputImageContent> for InputContent {
    fn from(content: InputImageContent) -> Self {
        InputContent::InputImage(content)
    }
}

impl From<InputFileContent> for InputContent {
    fn from(content: InputFileContent) -> Self {
        InputContent::InputFile(content)
    }
}

impl<S: Into<String>> From<S> for InputContent {
    fn from(text: S) -> Self {
        InputContent::InputText(InputTextContent { text: text.into() })
    }
}

// ResponsePromptVariables ergonomics

impl From<InputContent> for ResponsePromptVariables {
    fn from(content: InputContent) -> Self {
        ResponsePromptVariables::Content(content)
    }
}

impl<S: Into<String>> From<S> for ResponsePromptVariables {
    fn from(text: S) -> Self {
        ResponsePromptVariables::String(text.into())
    }
}

// MessageItem ergonomics

impl From<InputMessage> for MessageItem {
    fn from(msg: InputMessage) -> Self {
        MessageItem::Input(msg)
    }
}

impl From<OutputMessage> for MessageItem {
    fn from(msg: OutputMessage) -> Self {
        MessageItem::Output(msg)
    }
}

// FunctionCallOutput ergonomics

impl From<&str> for FunctionCallOutput {
    fn from(text: &str) -> Self {
        FunctionCallOutput::Text(text.to_string())
    }
}

impl From<String> for FunctionCallOutput {
    fn from(text: String) -> Self {
        FunctionCallOutput::Text(text)
    }
}

impl From<Vec<InputContent>> for FunctionCallOutput {
    fn from(content: Vec<InputContent>) -> Self {
        FunctionCallOutput::Content(content)
    }
}

// RefusalContent ergonomics

impl<S: Into<String>> From<S> for RefusalContent {
    fn from(refusal: S) -> Self {
        RefusalContent {
            refusal: refusal.into(),
        }
    }
}

// OutputMessageContent ergonomics

impl From<OutputTextContent> for OutputMessageContent {
    fn from(content: OutputTextContent) -> Self {
        OutputMessageContent::OutputText(content)
    }
}

impl From<RefusalContent> for OutputMessageContent {
    fn from(content: RefusalContent) -> Self {
        OutputMessageContent::Refusal(content)
    }
}

// Item ergonomics

impl From<MessageItem> for Item {
    fn from(item: MessageItem) -> Self {
        Item::Message(item)
    }
}

impl From<FileSearchToolCall> for Item {
    fn from(call: FileSearchToolCall) -> Self {
        Item::FileSearchCall(call)
    }
}

impl From<ComputerToolCall> for Item {
    fn from(call: ComputerToolCall) -> Self {
        Item::ComputerCall(call)
    }
}

impl From<ComputerCallOutputItemParam> for Item {
    fn from(output: ComputerCallOutputItemParam) -> Self {
        Item::ComputerCallOutput(output)
    }
}

impl From<WebSearchToolCall> for Item {
    fn from(call: WebSearchToolCall) -> Self {
        Item::WebSearchCall(call)
    }
}

impl From<FunctionToolCall> for Item {
    fn from(call: FunctionToolCall) -> Self {
        Item::FunctionCall(call)
    }
}

impl From<FunctionCallOutputItemParam> for Item {
    fn from(output: FunctionCallOutputItemParam) -> Self {
        Item::FunctionCallOutput(output)
    }
}

impl From<ReasoningItem> for Item {
    fn from(item: ReasoningItem) -> Self {
        Item::Reasoning(item)
    }
}

impl From<ImageGenToolCall> for Item {
    fn from(call: ImageGenToolCall) -> Self {
        Item::ImageGenerationCall(call)
    }
}

impl From<CodeInterpreterToolCall> for Item {
    fn from(call: CodeInterpreterToolCall) -> Self {
        Item::CodeInterpreterCall(call)
    }
}

impl From<LocalShellToolCall> for Item {
    fn from(call: LocalShellToolCall) -> Self {
        Item::LocalShellCall(call)
    }
}

impl From<LocalShellToolCallOutput> for Item {
    fn from(output: LocalShellToolCallOutput) -> Self {
        Item::LocalShellCallOutput(output)
    }
}

impl From<FunctionShellCallItemParam> for Item {
    fn from(call: FunctionShellCallItemParam) -> Self {
        Item::ShellCall(call)
    }
}

impl From<FunctionShellCallOutputItemParam> for Item {
    fn from(output: FunctionShellCallOutputItemParam) -> Self {
        Item::ShellCallOutput(output)
    }
}

impl From<ApplyPatchToolCallItemParam> for Item {
    fn from(call: ApplyPatchToolCallItemParam) -> Self {
        Item::ApplyPatchCall(call)
    }
}

impl From<ApplyPatchToolCallOutputItemParam> for Item {
    fn from(output: ApplyPatchToolCallOutputItemParam) -> Self {
        Item::ApplyPatchCallOutput(output)
    }
}

impl From<MCPListTools> for Item {
    fn from(tools: MCPListTools) -> Self {
        Item::McpListTools(tools)
    }
}

impl From<MCPApprovalRequest> for Item {
    fn from(request: MCPApprovalRequest) -> Self {
        Item::McpApprovalRequest(request)
    }
}

impl From<MCPApprovalResponse> for Item {
    fn from(response: MCPApprovalResponse) -> Self {
        Item::McpApprovalResponse(response)
    }
}

impl From<MCPToolCall> for Item {
    fn from(call: MCPToolCall) -> Self {
        Item::McpCall(call)
    }
}

impl From<CustomToolCallOutput> for Item {
    fn from(output: CustomToolCallOutput) -> Self {
        Item::CustomToolCallOutput(output)
    }
}

impl From<CustomToolCall> for Item {
    fn from(call: CustomToolCall) -> Self {
        Item::CustomToolCall(call)
    }
}

impl From<ToolSearchCallItemParam> for Item {
    fn from(call: ToolSearchCallItemParam) -> Self {
        Item::ToolSearchCall(call)
    }
}

impl From<ToolSearchOutputItemParam> for Item {
    fn from(output: ToolSearchOutputItemParam) -> Self {
        Item::ToolSearchOutput(output)
    }
}

// Tool ergonomics

impl From<FunctionTool> for Tool {
    fn from(tool: FunctionTool) -> Self {
        Tool::Function(tool)
    }
}

impl From<FileSearchTool> for Tool {
    fn from(tool: FileSearchTool) -> Self {
        Tool::FileSearch(tool)
    }
}

impl From<ComputerUsePreviewTool> for Tool {
    fn from(tool: ComputerUsePreviewTool) -> Self {
        Tool::ComputerUsePreview(tool)
    }
}

impl From<WebSearchTool> for Tool {
    fn from(tool: WebSearchTool) -> Self {
        Tool::WebSearch(tool)
    }
}

impl From<MCPTool> for Tool {
    fn from(tool: MCPTool) -> Self {
        Tool::Mcp(tool)
    }
}

impl From<CodeInterpreterTool> for Tool {
    fn from(tool: CodeInterpreterTool) -> Self {
        Tool::CodeInterpreter(tool)
    }
}

impl From<ImageGenTool> for Tool {
    fn from(tool: ImageGenTool) -> Self {
        Tool::ImageGeneration(tool)
    }
}

impl From<CustomToolParam> for Tool {
    fn from(tool: CustomToolParam) -> Self {
        Tool::Custom(tool)
    }
}

impl From<ComputerTool> for Tool {
    fn from(tool: ComputerTool) -> Self {
        Tool::Computer(tool)
    }
}

impl From<NamespaceToolParam> for Tool {
    fn from(tool: NamespaceToolParam) -> Self {
        Tool::Namespace(tool)
    }
}

impl From<ToolSearchToolParam> for Tool {
    fn from(tool: ToolSearchToolParam) -> Self {
        Tool::ToolSearch(tool)
    }
}

// Vec<Tool> ergonomics

impl From<Tool> for Vec<Tool> {
    fn from(tool: Tool) -> Self {
        vec![tool]
    }
}

impl From<FunctionTool> for Vec<Tool> {
    fn from(tool: FunctionTool) -> Self {
        vec![Tool::Function(tool)]
    }
}

impl From<FileSearchTool> for Vec<Tool> {
    fn from(tool: FileSearchTool) -> Self {
        vec![Tool::FileSearch(tool)]
    }
}

impl From<ComputerUsePreviewTool> for Vec<Tool> {
    fn from(tool: ComputerUsePreviewTool) -> Self {
        vec![Tool::ComputerUsePreview(tool)]
    }
}

impl From<WebSearchTool> for Vec<Tool> {
    fn from(tool: WebSearchTool) -> Self {
        vec![Tool::WebSearch(tool)]
    }
}

impl From<MCPTool> for Vec<Tool> {
    fn from(tool: MCPTool) -> Self {
        vec![Tool::Mcp(tool)]
    }
}

impl From<CodeInterpreterTool> for Vec<Tool> {
    fn from(tool: CodeInterpreterTool) -> Self {
        vec![Tool::CodeInterpreter(tool)]
    }
}

impl From<ImageGenTool> for Vec<Tool> {
    fn from(tool: ImageGenTool) -> Self {
        vec![Tool::ImageGeneration(tool)]
    }
}

impl From<CustomToolParam> for Vec<Tool> {
    fn from(tool: CustomToolParam) -> Self {
        vec![Tool::Custom(tool)]
    }
}

// EasyInputContent ergonomics

impl Default for EasyInputContent {
    fn default() -> Self {
        Self::Text("".to_string())
    }
}

impl From<String> for EasyInputContent {
    fn from(value: String) -> Self {
        Self::Text(value)
    }
}

impl From<&str> for EasyInputContent {
    fn from(value: &str) -> Self {
        Self::Text(value.to_owned())
    }
}

// Defaults

impl Default for CodeInterpreterToolContainer {
    fn default() -> Self {
        Self::Auto(CodeInterpreterContainerAuto::default())
    }
}

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

impl ItemReference {
    /// Create a new item reference with the given ID.
    pub fn new(id: impl Into<String>) -> Self {
        Self {
            r#type: Some(ItemReferenceType::ItemReference),
            id: id.into(),
        }
    }
}

// ──────────────────────────────────────────────────────────────────────────
// OutputItem -> Item / InputItem (multi-turn responses helpers)
//
// The Responses API requires reasoning items to be echoed back into the
// next request's `input` alongside the function-call items they preceded —
// otherwise the server rejects the request with
// `Item 'fc_...' was provided without its required 'reasoning' item: ...`.
// In the official Python and Node SDKs the canonical pattern is just
// `input_list += response.output`, since their input/output item types
// are the same. In Rust the OpenAPI-derived schemas split into Item (input
// side) and OutputItem (output side), so an explicit conversion is needed.
//
// The conversions below give that "just append the output" ergonomic via
// `From<OutputItem> for Item` (and through it, `From<OutputItem> for
// InputItem`). For variants where input and output already share a struct
// the conversion is a one-liner; for the handful of variants where the
// schemas differ (resource types carry required `id`/`status`, while their
// input-side `*ItemParam` counterparts have those optional), per-pair
// `From` impls map the fields so callers don't have to write boilerplate
// per use site.
//
// References:
//   - https://github.com/64bit/async-openai/issues/492
//   - https://platform.openai.com/docs/guides/conversation-state
// ──────────────────────────────────────────────────────────────────────────

// Status enum mappings (resource side → param side).

impl From<FunctionCallOutputStatusEnum> for OutputStatus {
    fn from(status: FunctionCallOutputStatusEnum) -> Self {
        match status {
            FunctionCallOutputStatusEnum::InProgress => OutputStatus::InProgress,
            FunctionCallOutputStatusEnum::Completed => OutputStatus::Completed,
            FunctionCallOutputStatusEnum::Incomplete => OutputStatus::Incomplete,
        }
    }
}

impl From<FunctionCallStatus> for OutputStatus {
    fn from(status: FunctionCallStatus) -> Self {
        match status {
            FunctionCallStatus::InProgress => OutputStatus::InProgress,
            FunctionCallStatus::Completed => OutputStatus::Completed,
            FunctionCallStatus::Incomplete => OutputStatus::Incomplete,
        }
    }
}

impl From<LocalShellCallStatus> for FunctionShellCallItemStatus {
    fn from(status: LocalShellCallStatus) -> Self {
        match status {
            LocalShellCallStatus::InProgress => FunctionShellCallItemStatus::InProgress,
            LocalShellCallStatus::Completed => FunctionShellCallItemStatus::Completed,
            LocalShellCallStatus::Incomplete => FunctionShellCallItemStatus::Incomplete,
        }
    }
}

impl From<ApplyPatchCallStatus> for ApplyPatchCallStatusParam {
    fn from(status: ApplyPatchCallStatus) -> Self {
        match status {
            ApplyPatchCallStatus::InProgress => ApplyPatchCallStatusParam::InProgress,
            ApplyPatchCallStatus::Completed => ApplyPatchCallStatusParam::Completed,
        }
    }
}

impl From<ApplyPatchCallOutputStatus> for ApplyPatchCallOutputStatusParam {
    fn from(status: ApplyPatchCallOutputStatus) -> Self {
        match status {
            ApplyPatchCallOutputStatus::Completed => ApplyPatchCallOutputStatusParam::Completed,
            ApplyPatchCallOutputStatus::Failed => ApplyPatchCallOutputStatusParam::Failed,
        }
    }
}

// Shell environment / outcome mappings.

impl From<ContainerReferenceResource> for ContainerReferenceParam {
    fn from(r: ContainerReferenceResource) -> Self {
        ContainerReferenceParam {
            container_id: r.container_id,
        }
    }
}

impl From<FunctionShellCallEnvironment> for FunctionShellCallItemEnvironment {
    fn from(env: FunctionShellCallEnvironment) -> Self {
        match env {
            // The response side carries no payload for `Local`; the param
            // side accepts an optional `skills` list which we leave None
            // (it's a request-only knob).
            FunctionShellCallEnvironment::Local => {
                FunctionShellCallItemEnvironment::Local(LocalEnvironmentParam { skills: None })
            }
            FunctionShellCallEnvironment::ContainerReference(r) => {
                FunctionShellCallItemEnvironment::ContainerReference(r.into())
            }
        }
    }
}

impl From<FunctionShellCallOutputExitOutcome> for FunctionShellCallOutputExitOutcomeParam {
    fn from(o: FunctionShellCallOutputExitOutcome) -> Self {
        FunctionShellCallOutputExitOutcomeParam {
            exit_code: o.exit_code,
        }
    }
}

impl From<FunctionShellCallOutputOutcome> for FunctionShellCallOutputOutcomeParam {
    fn from(o: FunctionShellCallOutputOutcome) -> Self {
        match o {
            FunctionShellCallOutputOutcome::Timeout => FunctionShellCallOutputOutcomeParam::Timeout,
            FunctionShellCallOutputOutcome::Exit(e) => {
                FunctionShellCallOutputOutcomeParam::Exit(e.into())
            }
        }
    }
}

impl From<FunctionShellCallOutputContent> for FunctionShellCallOutputContentParam {
    fn from(c: FunctionShellCallOutputContent) -> Self {
        FunctionShellCallOutputContentParam {
            stdout: c.stdout,
            stderr: c.stderr,
            outcome: c.outcome.into(),
        }
    }
}

impl From<FunctionShellAction> for FunctionShellActionParam {
    fn from(a: FunctionShellAction) -> Self {
        FunctionShellActionParam {
            commands: a.commands,
            timeout_ms: a.timeout_ms,
            max_output_length: a.max_output_length,
        }
    }
}

// ApplyPatch operation mappings.

impl From<ApplyPatchCreateFileOperation> for ApplyPatchCreateFileOperationParam {
    fn from(op: ApplyPatchCreateFileOperation) -> Self {
        ApplyPatchCreateFileOperationParam {
            path: op.path,
            diff: op.diff,
        }
    }
}

impl From<ApplyPatchDeleteFileOperation> for ApplyPatchDeleteFileOperationParam {
    fn from(op: ApplyPatchDeleteFileOperation) -> Self {
        ApplyPatchDeleteFileOperationParam { path: op.path }
    }
}

impl From<ApplyPatchUpdateFileOperation> for ApplyPatchUpdateFileOperationParam {
    fn from(op: ApplyPatchUpdateFileOperation) -> Self {
        ApplyPatchUpdateFileOperationParam {
            path: op.path,
            diff: op.diff,
        }
    }
}

impl From<ApplyPatchOperation> for ApplyPatchOperationParam {
    fn from(op: ApplyPatchOperation) -> Self {
        match op {
            ApplyPatchOperation::CreateFile(o) => ApplyPatchOperationParam::CreateFile(o.into()),
            ApplyPatchOperation::DeleteFile(o) => ApplyPatchOperationParam::DeleteFile(o.into()),
            ApplyPatchOperation::UpdateFile(o) => ApplyPatchOperationParam::UpdateFile(o.into()),
        }
    }
}

// Per-resource-output → input-param conversions. Required `id` / `status`
// fields on the resource side become wrapped in `Some(...)` on the input
// side; status enums fold through the `From` impls above. The `created_by`
// field exists only on the resource side and is dropped on the way in —
// it's a server-assigned annotation that the input schema doesn't accept.

impl From<FunctionToolCallOutputResource> for FunctionCallOutputItemParam {
    fn from(r: FunctionToolCallOutputResource) -> Self {
        FunctionCallOutputItemParam {
            call_id: r.call_id,
            output: r.output,
            id: Some(r.id),
            status: Some(r.status.into()),
        }
    }
}

impl From<ComputerToolCallOutputResource> for ComputerCallOutputItemParam {
    fn from(r: ComputerToolCallOutputResource) -> Self {
        ComputerCallOutputItemParam {
            call_id: r.call_id,
            output: r.output,
            acknowledged_safety_checks: r.acknowledged_safety_checks,
            id: Some(r.id),
            // ComputerCallOutputStatus has a `Failed` variant that
            // OutputStatus doesn't model. The Responses API silently
            // accepts a missing status here, so collapse `Failed` to None
            // rather than fabricate a value the schema can't represent.
            status: match r.status {
                crate::types::responses::ComputerCallOutputStatus::InProgress => {
                    Some(OutputStatus::InProgress)
                }
                crate::types::responses::ComputerCallOutputStatus::Completed => {
                    Some(OutputStatus::Completed)
                }
                crate::types::responses::ComputerCallOutputStatus::Incomplete => {
                    Some(OutputStatus::Incomplete)
                }
                crate::types::responses::ComputerCallOutputStatus::Failed => None,
            },
        }
    }
}

impl From<CustomToolCallOutputResource> for CustomToolCallOutput {
    fn from(r: CustomToolCallOutputResource) -> Self {
        CustomToolCallOutput {
            call_id: r.call_id,
            output: r.output,
            id: Some(r.id),
        }
    }
}

impl From<FunctionShellCall> for FunctionShellCallItemParam {
    fn from(c: FunctionShellCall) -> Self {
        FunctionShellCallItemParam {
            id: Some(c.id),
            call_id: c.call_id,
            action: c.action.into(),
            status: Some(c.status.into()),
            environment: c.environment.map(Into::into),
        }
    }
}

impl From<FunctionShellCallOutput> for FunctionShellCallOutputItemParam {
    fn from(o: FunctionShellCallOutput) -> Self {
        FunctionShellCallOutputItemParam {
            id: Some(o.id),
            call_id: o.call_id,
            output: o.output.into_iter().map(Into::into).collect(),
            max_output_length: o.max_output_length,
        }
    }
}

impl From<ApplyPatchToolCall> for ApplyPatchToolCallItemParam {
    fn from(c: ApplyPatchToolCall) -> Self {
        ApplyPatchToolCallItemParam {
            id: Some(c.id),
            call_id: c.call_id,
            status: c.status.into(),
            operation: c.operation.into(),
        }
    }
}

impl From<ApplyPatchToolCallOutput> for ApplyPatchToolCallOutputItemParam {
    fn from(o: ApplyPatchToolCallOutput) -> Self {
        ApplyPatchToolCallOutputItemParam {
            id: Some(o.id),
            call_id: o.call_id,
            status: o.status.into(),
            output: o.output,
        }
    }
}

impl From<CompactionBody> for CompactionSummaryItemParam {
    fn from(b: CompactionBody) -> Self {
        CompactionSummaryItemParam {
            id: Some(b.id),
            encrypted_content: b.encrypted_content,
        }
    }
}

impl From<ToolSearchCall> for ToolSearchCallItemParam {
    fn from(c: ToolSearchCall) -> Self {
        ToolSearchCallItemParam {
            id: Some(c.id),
            call_id: c.call_id,
            execution: Some(c.execution),
            arguments: c.arguments,
            status: Some(c.status.into()),
        }
    }
}

impl From<ToolSearchOutput> for ToolSearchOutputItemParam {
    fn from(o: ToolSearchOutput) -> Self {
        ToolSearchOutputItemParam {
            id: Some(o.id),
            call_id: o.call_id,
            execution: Some(o.execution),
            tools: o.tools,
            status: Some(o.status.into()),
        }
    }
}

// Top-level: any output item rolls into an Item, and through the existing
// `From<Item> for InputItem` impl, into an InputItem too. This is the entry
// point callers actually want — see the `responses-multi-turn-reasoning`
// example for the round-trip pattern.

impl From<OutputItem> for Item {
    fn from(item: OutputItem) -> Self {
        match item {
            OutputItem::Message(m) => Item::Message(m.into()),
            OutputItem::FileSearchCall(c) => c.into(),
            OutputItem::FunctionCall(c) => c.into(),
            OutputItem::FunctionCallOutput(o) => Item::FunctionCallOutput(o.into()),
            OutputItem::WebSearchCall(c) => c.into(),
            OutputItem::ComputerCall(c) => c.into(),
            OutputItem::ComputerCallOutput(o) => Item::ComputerCallOutput(o.into()),
            OutputItem::Reasoning(r) => r.into(),
            OutputItem::Compaction(c) => Item::Compaction(c.into()),
            OutputItem::ImageGenerationCall(c) => c.into(),
            OutputItem::CodeInterpreterCall(c) => c.into(),
            OutputItem::LocalShellCall(c) => c.into(),
            OutputItem::ShellCall(c) => Item::ShellCall(c.into()),
            OutputItem::ShellCallOutput(o) => Item::ShellCallOutput(o.into()),
            OutputItem::ApplyPatchCall(c) => Item::ApplyPatchCall(c.into()),
            OutputItem::ApplyPatchCallOutput(o) => Item::ApplyPatchCallOutput(o.into()),
            OutputItem::McpCall(c) => c.into(),
            OutputItem::McpListTools(c) => c.into(),
            OutputItem::McpApprovalRequest(c) => c.into(),
            OutputItem::CustomToolCall(c) => c.into(),
            OutputItem::CustomToolCallOutput(o) => Item::CustomToolCallOutput(o.into()),
            OutputItem::ToolSearchCall(c) => Item::ToolSearchCall(c.into()),
            OutputItem::ToolSearchOutput(o) => Item::ToolSearchOutput(o.into()),
        }
    }
}

impl From<OutputItem> for InputItem {
    fn from(item: OutputItem) -> Self {
        Item::from(item).into()
    }
}