agent_client_protocol_schema/v2/

tool_call.rs

//! Tool calls represent actions that language models request agents to perform.
//!
//! Examples include reading a file or running a command. The agent executes the tool call on
//! the model's behalf and reports its progress to the client.
//!
/// See protocol docs: [Tool Calls](https://agentclientprotocol.com/protocol/v2/tool-calls)
use std::{collections::BTreeMap, sync::Arc};

use derive_more::{Display, From};
#[cfg(feature = "schemars")]
use schemars::Schema;
use serde::{Deserialize, Serialize};
use serde_with::{DefaultOnError, VecSkipError, serde_as, skip_serializing_none};

use super::{AbsolutePath, ContentBlock, MediaType, Meta, Terminal, apply_meta_update};
use crate::{IntoMaybeUndefined, IntoOption, MaybeUndefined};

/// Represents an upsert for a tool call that the language model has requested.
///
/// Tool calls are actions that the agent executes on behalf of the language model,
/// such as reading files, executing code, or fetching data from external sources.
///
/// Only `toolCallId` is required. Other fields have patch semantics:
/// omitted fields leave the existing tool call value unchanged, `null` clears or
/// unsets the value, and concrete values replace the previous value. For
/// collection fields, concrete arrays replace the previous collection, and both
/// `null` and `[]` clear the collection. A concrete `_meta` object instead
/// patches the stored metadata by top-level key. When a client receives a tool
/// call ID it has not seen before, omitted fields start at their protocol defaults.
///
/// See protocol docs: [Tool Calls](https://agentclientprotocol.com/protocol/v2/tool-calls)
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct ToolCallUpdate {
    /// Unique identifier for this tool call within the session.
    pub tool_call_id: ToolCallId,
    /// Programmatic name of the tool being invoked.
    ///
    /// This field is optional and has patch semantics. Omission means no
    /// change, `null` clears the name, and a string replaces it. For a tool
    /// call ID the client has not seen before, omission or `null` means that no
    /// tool name is available.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub name: MaybeUndefined<String>,
    /// Human-readable title describing what the tool is doing.
    ///
    /// Omission leaves the title unchanged, `null` unsets it, and a string replaces it.
    /// A new tool call starts without a title.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub title: MaybeUndefined<String>,
    /// The category of tool being invoked.
    /// Helps clients choose appropriate icons and UI treatment.
    ///
    /// Omission leaves the kind unchanged, `null` resets it to `other`, and a value replaces it.
    /// A new tool call starts as `other`.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub kind: MaybeUndefined<ToolKind>,
    /// Current execution status of the tool call.
    ///
    /// Omission leaves the status unchanged, `null` resets it to `pending`, and a value
    /// replaces it. A new tool call starts as `pending`.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub status: MaybeUndefined<ToolCallStatus>,
    /// Content produced by the tool call.
    #[serde_as(deserialize_as = "DefaultOnError<MaybeUndefined<VecSkipError<_>>>")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true, "x-deserialize-skip-invalid-items" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub content: MaybeUndefined<Vec<ToolCallContent>>,
    /// File locations affected by this tool call.
    /// Enables "follow-along" features in clients.
    #[serde_as(deserialize_as = "DefaultOnError<MaybeUndefined<VecSkipError<_>>>")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true, "x-deserialize-skip-invalid-items" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub locations: MaybeUndefined<Vec<ToolCallLocation>>,
    /// Raw input parameters sent to the tool.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub raw_input: MaybeUndefined<serde_json::Value>,
    /// Raw output returned by the tool.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub raw_output: MaybeUndefined<serde_json::Value>,
    /// Client-initiated controls this tool call currently supports, such as cancellation.
    ///
    /// Omission leaves the capabilities unchanged, `null` clears them, and an object replaces
    /// the whole previous value. A new tool call starts with none.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default, skip_serializing_if = "MaybeUndefined::is_undefined")]
    pub capabilities: MaybeUndefined<ToolCallCapabilities>,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted leaves the stored metadata unchanged. `null`
    /// clears it. An object patches the stored metadata by top-level key: keys it omits are
    /// unchanged, a key set to `null` is removed, and any other value replaces that key's
    /// stored value without merging nested objects. Beyond this patch rule, implementations
    /// MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Metadata Patches](https://agentclientprotocol.com/protocol/v2/extensibility#metadata-patches)
    #[serde_as(deserialize_as = "DefaultOnError<MaybeUndefined<_>>")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(
        rename = "_meta",
        default,
        skip_serializing_if = "MaybeUndefined::is_undefined"
    )]
    pub meta: MaybeUndefined<Meta>,
}

impl ToolCallUpdate {
    /// Builds [`ToolCallUpdate`] with the required fields set. Optional fields start unset or empty.
    #[must_use]
    pub fn new(tool_call_id: impl Into<ToolCallId>) -> Self {
        Self {
            tool_call_id: tool_call_id.into(),
            name: MaybeUndefined::Undefined,
            title: MaybeUndefined::Undefined,
            kind: MaybeUndefined::Undefined,
            status: MaybeUndefined::Undefined,
            content: MaybeUndefined::Undefined,
            locations: MaybeUndefined::Undefined,
            raw_input: MaybeUndefined::Undefined,
            raw_output: MaybeUndefined::Undefined,
            capabilities: MaybeUndefined::Undefined,
            meta: MaybeUndefined::Undefined,
        }
    }

    /// Programmatic name of the tool being invoked.
    #[must_use]
    pub fn name(mut self, name: impl IntoMaybeUndefined<String>) -> Self {
        self.name = name.into_maybe_undefined();
        self
    }

    /// Human-readable title describing what the tool is doing.
    #[must_use]
    pub fn title(mut self, title: impl IntoMaybeUndefined<String>) -> Self {
        self.title = title.into_maybe_undefined();
        self
    }

    /// The category of tool being invoked.
    /// Helps clients choose appropriate icons and UI treatment.
    #[must_use]
    pub fn kind(mut self, kind: impl IntoMaybeUndefined<ToolKind>) -> Self {
        self.kind = kind.into_maybe_undefined();
        self
    }

    /// Current execution status of the tool call.
    #[must_use]
    pub fn status(mut self, status: impl IntoMaybeUndefined<ToolCallStatus>) -> Self {
        self.status = status.into_maybe_undefined();
        self
    }

    /// Content produced by the tool call.
    #[must_use]
    pub fn content(mut self, content: impl IntoMaybeUndefined<Vec<ToolCallContent>>) -> Self {
        self.content = content.into_maybe_undefined();
        self
    }

    /// File locations affected by this tool call.
    /// Enables "follow-along" features in clients.
    #[must_use]
    pub fn locations(mut self, locations: impl IntoMaybeUndefined<Vec<ToolCallLocation>>) -> Self {
        self.locations = locations.into_maybe_undefined();
        self
    }

    /// Raw input parameters sent to the tool.
    #[must_use]
    pub fn raw_input(mut self, raw_input: impl IntoMaybeUndefined<serde_json::Value>) -> Self {
        self.raw_input = raw_input.into_maybe_undefined();
        self
    }

    /// Raw output returned by the tool.
    #[must_use]
    pub fn raw_output(mut self, raw_output: impl IntoMaybeUndefined<serde_json::Value>) -> Self {
        self.raw_output = raw_output.into_maybe_undefined();
        self
    }

    /// Sets, clears, or leaves unchanged the Client-initiated controls.
    #[must_use]
    pub fn capabilities(
        mut self,
        capabilities: impl IntoMaybeUndefined<ToolCallCapabilities>,
    ) -> Self {
        self.capabilities = capabilities.into_maybe_undefined();
        self
    }

    /// Patches, clears, or leaves unchanged tool-call metadata.
    ///
    /// A concrete object patches stored metadata by top-level key. See
    /// [`apply_meta_update`].
    #[must_use]
    pub fn meta(mut self, meta: impl IntoMaybeUndefined<Meta>) -> Self {
        self.meta = meta.into_maybe_undefined();
        self
    }

    /// Applies a later tool-call patch to this stored tool-call state.
    ///
    /// Fields set to `null` are preserved as `null` so callers can decide how to
    /// render an explicitly cleared value. A concrete `_meta` object patches the
    /// stored metadata by top-level key, as described by [`apply_meta_update`].
    pub fn apply_update(&mut self, update: ToolCallUpdate) {
        debug_assert_eq!(self.tool_call_id, update.tool_call_id);
        if !update.name.is_undefined() {
            self.name = update.name;
        }
        if !update.title.is_undefined() {
            self.title = update.title;
        }
        if !update.kind.is_undefined() {
            self.kind = update.kind;
        }
        if !update.status.is_undefined() {
            self.status = update.status;
        }
        if !update.content.is_undefined() {
            self.content = update.content;
        }
        if !update.locations.is_undefined() {
            self.locations = update.locations;
        }
        if !update.raw_input.is_undefined() {
            self.raw_input = update.raw_input;
        }
        if !update.raw_output.is_undefined() {
            self.raw_output = update.raw_output;
        }
        if !update.capabilities.is_undefined() {
            self.capabilities = update.capabilities;
        }
        apply_meta_update(&mut self.meta, update.meta);
    }
}

/// Client-initiated controls a tool call currently supports.
///
/// A malformed value falls back to no controls, so the Client never sends a request the
/// Agent did not advertise.
///
/// See protocol docs: [Cancelling Tool Calls](https://agentclientprotocol.com/protocol/v2/tool-calls#cancelling-tool-calls)
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct ToolCallCapabilities {
    /// Permits the Client to cancel this tool call with `tool_call/cancel`.
    ///
    /// Omitted and `null` are equivalent and mean unsupported. An object (including `{}`)
    /// means supported. Agents SHOULD stop advertising it once the tool call reaches a final status.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    pub cancel: Option<ToolCallCancelCapabilities>,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl ToolCallCapabilities {
    /// Builds an empty capability set. Cancellation is not advertised.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets or removes permission to cancel this tool call.
    #[must_use]
    pub fn cancel(mut self, cancel: impl IntoOption<ToolCallCancelCapabilities>) -> Self {
        self.cancel = cancel.into_option();
        self
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

/// Capability to cancel a tool call with `tool_call/cancel`.
///
/// Supplying `{}` advertises support. An omitted or `null` `cancel` does not.
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[non_exhaustive]
pub struct ToolCallCancelCapabilities {
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl ToolCallCancelCapabilities {
    /// Builds an empty capability object advertising cancellation support.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

/// A streamed item of tool-call content.
///
/// Tool-call content chunks append one `ToolCallContent` item to the current
/// content for the matching `toolCallId`. Agents can send a `tool_call_update`
/// with `content` when they need to replace the whole content collection
/// instead.
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct ToolCallContentChunk {
    /// The ID of the tool call this content belongs to.
    pub tool_call_id: ToolCallId,
    /// A single item of content produced by the tool call.
    pub content: ToolCallContent,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    /// This metadata is scoped to the chunk and does not patch stored metadata.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl ToolCallContentChunk {
    /// Builds [`ToolCallContentChunk`] with the required fields set. Optional fields start unset or empty.
    #[must_use]
    pub fn new(tool_call_id: impl Into<ToolCallId>, content: impl Into<ToolCallContent>) -> Self {
        Self {
            tool_call_id: tool_call_id.into(),
            content: content.into(),
            meta: None,
        }
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize. This field is chunk-scoped.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

/// Unique identifier for a tool call within a session.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash, Display, From)]
#[serde(transparent)]
#[from(forward)]
#[non_exhaustive]
pub struct ToolCallId(pub Arc<str>);

impl ToolCallId {
    /// Wraps a protocol string as a typed [`ToolCallId`].
    #[must_use]
    pub fn new(id: impl Into<Self>) -> Self {
        id.into()
    }
}

impl IntoOption<ToolCallId> for &str {
    fn into_option(self) -> Option<ToolCallId> {
        Some(ToolCallId::new(self))
    }
}

/// Categories of tools that can be invoked.
///
/// Tool kinds help clients choose appropriate icons and optimize how they
/// display tool execution progress.
///
/// See protocol docs: [Reporting](https://agentclientprotocol.com/protocol/v2/tool-calls#reporting)
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum ToolKind {
    /// Reading files or data.
    Read,
    /// Modifying files or content.
    Edit,
    /// Removing files or data.
    Delete,
    /// Moving or renaming files.
    Move,
    /// Searching for information.
    Search,
    /// Running commands or code.
    Execute,
    /// Internal reasoning or planning.
    Think,
    /// Retrieving external data.
    Fetch,
    /// Changing the session's mode, a [config option](https://agentclientprotocol.com/protocol/v2/session-config-options) with the `mode` category.
    SwitchMode,
    /// Other tool types (default).
    #[default]
    Other,
    /// Custom or future tool kind.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants. Clients display an unrecognized kind as `other`.
    #[serde(untagged)]
    Unknown(String),
}

/// Execution status of a tool call.
///
/// Tool calls progress through different statuses during their lifecycle.
///
/// See protocol docs: [Status](https://agentclientprotocol.com/protocol/v2/tool-calls#status)
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum ToolCallStatus {
    /// The tool call hasn't started running yet, for example because its input is
    /// streaming, it is awaiting approval, or it is scheduled to run later.
    #[default]
    Pending,
    /// The tool call is currently running.
    InProgress,
    /// The tool call has started, is not running now, and will not continue until
    /// something resumes it. It may return to `in_progress` any number of times.
    Paused,
    /// The tool call completed successfully.
    Completed,
    /// The tool call failed with an error.
    Failed,
    /// The tool call was cancelled before it completed.
    Cancelled,
    /// Custom or future tool call status.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants.
    ///
    /// Clients treat a tool call with an unrecognized status as still in progress.
    #[serde(untagged)]
    Other(String),
}

/// Content produced by a tool call.
///
/// Tool calls can produce different types of content including standard
/// content blocks (text, images), file diffs, or display-only terminals.
///
/// See protocol docs: [Content](https://agentclientprotocol.com/protocol/v2/tool-calls#content)
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
#[non_exhaustive]
pub enum ToolCallContent {
    /// Standard content block (text, images, resources).
    Content(Box<Content>),
    /// File modification shown as a diff.
    Diff(Diff),
    /// A display-only reference to an agent-owned terminal.
    Terminal(Terminal),
    /// Custom or future tool call content.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants.
    ///
    /// Receivers that do not understand this content type should preserve the
    /// raw payload when storing, replaying, proxying, or forwarding tool call
    /// output, and otherwise ignore it or display it generically.
    #[serde(untagged)]
    Other(OtherToolCallContent),
}

/// Custom or future tool call content payload.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[cfg_attr(feature = "schemars", schemars(inline))]
#[cfg_attr(feature = "schemars", schemars(transform = other_tool_call_content_schema))]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct OtherToolCallContent {
    /// Custom or future tool call content type.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants.
    #[serde(rename = "type")]
    pub type_: String,
    /// Additional fields from the unknown tool call content payload.
    #[serde(flatten)]
    pub fields: BTreeMap<String, serde_json::Value>,
}

impl OtherToolCallContent {
    /// Builds [`OtherToolCallContent`] from an unknown discriminator and preserves the remaining extension fields.
    #[must_use]
    pub fn new(type_: impl Into<String>, mut fields: BTreeMap<String, serde_json::Value>) -> Self {
        fields.remove("type");
        Self {
            type_: type_.into(),
            fields,
        }
    }
}

impl<'de> Deserialize<'de> for OtherToolCallContent {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let mut fields = BTreeMap::<String, serde_json::Value>::deserialize(deserializer)?;
        let type_ = fields
            .remove("type")
            .ok_or_else(|| serde::de::Error::missing_field("type"))?;
        let serde_json::Value::String(type_) = type_ else {
            return Err(serde::de::Error::custom("`type` must be a string"));
        };

        if is_known_tool_call_content_type(&type_) {
            return Err(serde::de::Error::custom(format!(
                "known tool call content `{type_}` did not match its schema"
            )));
        }

        Ok(Self { type_, fields })
    }
}

fn is_known_tool_call_content_type(type_: &str) -> bool {
    matches!(type_, "content" | "diff" | "terminal")
}

#[cfg(feature = "schemars")]
fn other_tool_call_content_schema(schema: &mut Schema) {
    super::schema_util::reject_known_string_discriminators(
        schema,
        "type",
        &["content", "diff", "terminal"],
    );
}

impl<T: Into<ContentBlock>> From<T> for ToolCallContent {
    fn from(content: T) -> Self {
        ToolCallContent::Content(Box::new(Content::new(content)))
    }
}

impl From<Diff> for ToolCallContent {
    fn from(diff: Diff) -> Self {
        ToolCallContent::Diff(diff)
    }
}

impl From<Terminal> for ToolCallContent {
    fn from(terminal: Terminal) -> Self {
        ToolCallContent::Terminal(terminal)
    }
}

/// Standard content block (text, images, resources).
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct Content {
    /// The actual content block.
    pub content: ContentBlock,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl Content {
    /// Builds [`Content`] with the required fields set. Optional fields start unset or empty.
    #[must_use]
    pub fn new(content: impl Into<ContentBlock>) -> Self {
        Self {
            content: content.into(),
            meta: None,
        }
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

/// File changes produced by a tool call.
///
/// `changes` is authoritative for affected absolute paths and operations.
/// `patch` optionally carries renderable text for some or all of those changes
/// and MUST be consistent with `changes`. Agents SHOULD provide `patch` whenever
/// feasible. Clients MUST handle diffs where `patch` is omitted or `null`.
///
/// See protocol docs: [Content](https://agentclientprotocol.com/protocol/v2/tool-calls#content)
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct Diff {
    /// Structured file changes described by this diff.
    ///
    /// Clients can use this field without parsing patch text to determine affected paths.
    #[serde_as(deserialize_as = "VecSkipError<_>")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-skip-invalid-items" = true)))]
    pub changes: Vec<DiffChange>,
    /// Renderable patch text for some or all of the structured changes.
    ///
    /// Agents SHOULD provide patch text whenever feasible. Omitted and `null` are
    /// equivalent and mean no renderable patch text was provided.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    pub patch: Option<DiffPatch>,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl Diff {
    /// Builds [`Diff`] with structured file changes.
    #[must_use]
    pub fn new(changes: Vec<DiffChange>) -> Self {
        Self {
            changes,
            patch: None,
            meta: None,
        }
    }

    /// Builds [`Diff`] with Git `--patch` text and structured file changes.
    #[must_use]
    pub fn patch(text: impl Into<String>, changes: Vec<DiffChange>) -> Self {
        Self::new(changes).with_patch(DiffPatch::new(text))
    }

    /// Sets renderable patch text.
    #[must_use]
    pub fn with_patch(mut self, patch: impl IntoOption<DiffPatch>) -> Self {
        self.patch = patch.into_option();
        self
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

/// Renderable patch text and its format.
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct DiffPatch {
    /// Patch format. The only ACP-defined value is `git_patch`.
    pub format: DiffPatchFormat,
    /// Patch text in the format named by `format`.
    pub text: String,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl DiffPatch {
    /// Builds [`DiffPatch`] with Git `--patch` text.
    #[must_use]
    pub fn new(text: impl Into<String>) -> Self {
        Self {
            format: DiffPatchFormat::GitPatch,
            text: text.into(),
            meta: None,
        }
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

/// Text patch format used by `DiffPatch`.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum DiffPatchFormat {
    /// One or more `diff --git` sections in Git's `--patch` (`-p`) text format.
    ///
    /// Unlike Git, which writes paths relative to the repository root, every
    /// path MUST be absolute, including in `rename from`, `rename to`,
    /// `copy from`, and `copy to` lines, and MUST NOT have a prefix such as
    /// Git's default `a/` and `b/`. Otherwise paths follow Git: `/dev/null`
    /// names the missing side of an added or deleted file in the `---` and
    /// `+++` lines, and paths with unusual characters are quoted as Git quotes
    /// them. Each path, once unquoted, is the same native absolute path string as
    /// the matching `changes` entry. Surrounding commit metadata and email envelopes MUST NOT be
    /// included.
    GitPatch,
    /// Custom or future patch format.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants.
    #[serde(untagged)]
    Other(String),
}

/// Kind of file content represented by a diff change.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum DiffFileType {
    /// Text content.
    Text,
    /// Binary or otherwise non-text content.
    Binary,
    /// Directory entry.
    Directory,
    /// Symbolic link.
    Symlink,
    /// Custom or future file type.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants.
    #[serde(untagged)]
    Other(String),
}

/// One file-level change described by a `Diff`.
///
/// Structured change metadata lets clients identify affected files and
/// operations without parsing the text patch.
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct DiffChange {
    /// File content kind after the operation (for `delete`, of the deleted file).
    ///
    /// Omitted and `null` are equivalent and mean the content kind is unknown.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    pub file_type: Option<DiffFileType>,
    /// MIME type of the file contents after the operation (for `delete`, of the deleted file).
    ///
    /// Omitted and `null` are equivalent and mean the MIME type is unknown.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    pub mime_type: Option<MediaType>,
    /// File operation-specific fields.
    #[serde(flatten)]
    pub operation: DiffChangeOperation,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl DiffChange {
    /// Builds [`DiffChange`] with the required fields set. Optional fields start unset or empty.
    #[must_use]
    pub fn new(operation: DiffChangeOperation) -> Self {
        Self {
            file_type: None,
            mime_type: None,
            operation,
            meta: None,
        }
    }

    /// Builds a file add change.
    #[must_use]
    pub fn add(path: impl Into<AbsolutePath>) -> Self {
        Self::new(DiffChangeOperation::Add(DiffPathChange::new(path)))
    }

    /// Builds a file delete change.
    #[must_use]
    pub fn delete(path: impl Into<AbsolutePath>) -> Self {
        Self::new(DiffChangeOperation::Delete(DiffPathChange::new(path)))
    }

    /// Builds a file modify change.
    #[must_use]
    pub fn modify(path: impl Into<AbsolutePath>) -> Self {
        Self::new(DiffChangeOperation::Modify(DiffPathChange::new(path)))
    }

    /// Builds a file move or rename change.
    #[must_use]
    pub fn move_file(old_path: impl Into<AbsolutePath>, path: impl Into<AbsolutePath>) -> Self {
        Self::new(DiffChangeOperation::Move(DiffPathPairChange::new(
            old_path, path,
        )))
    }

    /// Builds a file copy change.
    #[must_use]
    pub fn copy(old_path: impl Into<AbsolutePath>, path: impl Into<AbsolutePath>) -> Self {
        Self::new(DiffChangeOperation::Copy(DiffPathPairChange::new(
            old_path, path,
        )))
    }

    /// File content kind.
    ///
    /// Omitted and `null` are equivalent and mean the content kind is unknown.
    #[must_use]
    pub fn file_type(mut self, file_type: impl IntoOption<DiffFileType>) -> Self {
        self.file_type = file_type.into_option();
        self
    }

    /// MIME type of the file contents.
    ///
    /// Omitted and `null` are equivalent and mean the MIME type is unknown.
    #[must_use]
    pub fn mime_type(mut self, mime_type: impl IntoOption<MediaType>) -> Self {
        self.mime_type = mime_type.into_option();
        self
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

/// File operation for a [`DiffChange`].
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "operation", rename_all = "snake_case")]
#[non_exhaustive]
pub enum DiffChangeOperation {
    /// A file was added.
    Add(DiffPathChange),
    /// A file was deleted.
    Delete(DiffPathChange),
    /// A file was modified in place.
    Modify(DiffPathChange),
    /// A file was moved or renamed.
    Move(DiffPathPairChange),
    /// A file was copied.
    Copy(DiffPathPairChange),
    /// Custom or future file operation.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants.
    #[serde(untagged)]
    Other(OtherDiffChange),
}

/// Operation metadata for add, delete, and modify changes.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct DiffPathChange {
    /// Absolute path for the operation.
    pub path: AbsolutePath,
}

impl DiffPathChange {
    /// Builds [`DiffPathChange`] with the required fields set. Optional fields start unset or empty.
    #[must_use]
    pub fn new(path: impl Into<AbsolutePath>) -> Self {
        Self { path: path.into() }
    }
}

/// Operation metadata for move and copy changes.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct DiffPathPairChange {
    /// Absolute path before the operation.
    pub old_path: AbsolutePath,
    /// Absolute path after the operation.
    pub path: AbsolutePath,
}

impl DiffPathPairChange {
    /// Builds [`DiffPathPairChange`] with the required fields set. Optional fields start unset or empty.
    #[must_use]
    pub fn new(old_path: impl Into<AbsolutePath>, path: impl Into<AbsolutePath>) -> Self {
        Self {
            old_path: old_path.into(),
            path: path.into(),
        }
    }
}

/// Custom or future file operation payload.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[cfg_attr(feature = "schemars", schemars(inline))]
#[cfg_attr(feature = "schemars", schemars(transform = other_diff_change_schema))]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct OtherDiffChange {
    /// Custom or future file operation.
    ///
    /// Values beginning with `_` are reserved for implementation-specific
    /// extensions. Unknown values that do not begin with `_` are reserved for
    /// future ACP variants.
    pub operation: String,
    /// Additional fields from the unknown file operation payload.
    #[serde(flatten)]
    pub fields: BTreeMap<String, serde_json::Value>,
}

impl OtherDiffChange {
    /// Builds [`OtherDiffChange`] from an unknown discriminator and preserves the remaining extension fields.
    #[must_use]
    pub fn new(
        operation: impl Into<String>,
        mut fields: BTreeMap<String, serde_json::Value>,
    ) -> Self {
        fields.remove("operation");
        fields.remove("fileType");
        fields.remove("mimeType");
        fields.remove("_meta");
        Self {
            operation: operation.into(),
            fields,
        }
    }
}

impl<'de> Deserialize<'de> for OtherDiffChange {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let mut fields = BTreeMap::<String, serde_json::Value>::deserialize(deserializer)?;
        let operation = fields
            .remove("operation")
            .ok_or_else(|| serde::de::Error::missing_field("operation"))?;
        let serde_json::Value::String(operation) = operation else {
            return Err(serde::de::Error::custom("`operation` must be a string"));
        };

        if is_known_diff_change_operation(&operation) {
            return Err(serde::de::Error::custom(format!(
                "known diff change operation `{operation}` did not match its schema"
            )));
        }
        fields.remove("fileType");
        fields.remove("mimeType");
        fields.remove("_meta");

        Ok(Self { operation, fields })
    }
}

fn is_known_diff_change_operation(operation: &str) -> bool {
    matches!(operation, "add" | "delete" | "modify" | "move" | "copy")
}

#[cfg(feature = "schemars")]
fn other_diff_change_schema(schema: &mut Schema) {
    super::schema_util::reject_known_string_discriminators(
        schema,
        "operation",
        &["add", "delete", "modify", "move", "copy"],
    );
}

/// A file location being accessed or modified by a tool.
///
/// Enables clients to implement "follow-along" features that track
/// which files the agent is working with in real-time.
///
/// See protocol docs: [Following the Agent](https://agentclientprotocol.com/protocol/v2/tool-calls#following-the-agent)
#[serde_as]
#[skip_serializing_none]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct ToolCallLocation {
    /// The absolute file path being accessed or modified.
    pub path: AbsolutePath,
    /// Optional 1-based line number within the file. Omitted and `null` are equivalent and
    /// mean no specific line. `0` is invalid.
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    pub line: Option<std::num::NonZeroU32>,
    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Omitted and `null` are equivalent and mean no metadata.
    /// Implementations MUST NOT assign meaning to keys they do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[serde_as(deserialize_as = "DefaultOnError")]
    #[cfg_attr(feature = "schemars", schemars(extend("x-deserialize-default-on-error" = true)))]
    #[serde(default)]
    #[serde(rename = "_meta")]
    pub meta: Option<Meta>,
}

impl ToolCallLocation {
    /// Builds [`ToolCallLocation`] with the required fields set. Optional fields start unset or empty.
    #[must_use]
    pub fn new(path: impl Into<AbsolutePath>) -> Self {
        Self {
            path: path.into(),
            line: None,
            meta: None,
        }
    }

    /// Optional line number within the file.
    ///
    /// Line numbers are 1-based, and `0` is invalid on the wire. This builder maps `0` to no
    /// specific line.
    #[must_use]
    pub fn line(mut self, line: impl IntoOption<u32>) -> Self {
        self.line = line.into_option().and_then(std::num::NonZeroU32::new);
        self
    }

    /// The _meta property is reserved by ACP to allow clients and agents to attach additional
    /// metadata to their interactions. Implementations MUST NOT assign meaning to keys they
    /// do not recognize.
    ///
    /// See protocol docs: [Extensibility](https://agentclientprotocol.com/protocol/v2/extensibility)
    #[must_use]
    pub fn meta(mut self, meta: impl IntoOption<Meta>) -> Self {
        self.meta = meta.into_option();
        self
    }
}

#[cfg(test)]
mod tests {

    #[test]
    fn location_line_is_one_based() {
        let location: ToolCallLocation =
            serde_json::from_value(serde_json::json!({ "path": "/a.rs", "line": 0 })).unwrap();
        assert_eq!(location.line, None);
        let location: ToolCallLocation =
            serde_json::from_value(serde_json::json!({ "path": "/a.rs", "line": 3 })).unwrap();
        assert_eq!(location.line.map(std::num::NonZeroU32::get), Some(3));
        assert_eq!(ToolCallLocation::new("/a.rs").line(0).line, None);
    }

    #[test]
    fn toolcall_capabilities_patch_and_tolerate_malformed_values() {
        use serde_json::json;
        let update = ToolCallUpdate::new("call_012")
            .capabilities(ToolCallCapabilities::new().cancel(ToolCallCancelCapabilities::new()));
        assert_eq!(
            serde_json::to_value(&update).unwrap(),
            json!({ "toolCallId": "call_012", "capabilities": { "cancel": {} } })
        );

        let mut stored = update;
        stored.apply_update(ToolCallUpdate::new("call_012"));
        assert!(stored.capabilities.is_value());
        stored.apply_update(ToolCallUpdate::new("call_012").capabilities(MaybeUndefined::Null));
        assert!(stored.capabilities.is_null());

        for bad in [json!("yes"), json!(1)] {
            let parsed: ToolCallUpdate =
                serde_json::from_value(json!({ "toolCallId": "call_012", "capabilities": bad }))
                    .unwrap();
            assert!(parsed.capabilities.is_undefined());
        }
        let parsed: ToolCallCapabilities =
            serde_json::from_value(json!({ "cancel": "yes" })).unwrap();
        assert_eq!(parsed.cancel, None);
    }

    #[test]
    fn paused_is_a_known_tool_call_status() {
        use serde_json::json;
        assert_eq!(
            serde_json::to_value(ToolCallStatus::Paused).unwrap(),
            json!("paused")
        );
        assert_eq!(
            serde_json::from_value::<ToolCallStatus>(json!("paused")).unwrap(),
            ToolCallStatus::Paused
        );
    }

    use super::*;
    use crate::MaybeUndefined;
    use serde_json::{from_value, json, to_value};

    #[test]
    fn tool_call_serializes_as_upsert() {
        let tool_call = ToolCallUpdate::new("tc_1")
            .title("Reading configuration")
            .status(ToolCallStatus::InProgress)
            .raw_input(serde_json::json!({"path": "settings.json"}));

        assert_eq!(
            serde_json::to_value(tool_call).unwrap(),
            serde_json::json!({
                "toolCallId": "tc_1",
                "title": "Reading configuration",
                "status": "in_progress",
                "rawInput": {
                    "path": "settings.json"
                }
            })
        );
    }

    #[test]
    fn tool_call_update_distinguishes_omitted_null_and_value() {
        let tool_call = ToolCallUpdate::new("tc_1")
            .status(ToolCallStatus::Completed)
            .content(None::<Vec<ToolCallContent>>);

        assert_eq!(
            serde_json::to_value(tool_call).unwrap(),
            serde_json::json!({
                "toolCallId": "tc_1",
                "status": "completed",
                "content": null
            })
        );

        let deserialized: ToolCallUpdate = serde_json::from_value(serde_json::json!({
            "toolCallId": "tc_1",
            "status": null,
            "locations": []
        }))
        .unwrap();
        assert_eq!(deserialized.title, MaybeUndefined::Undefined);
        assert_eq!(deserialized.status, MaybeUndefined::Null);
        assert_eq!(deserialized.locations, MaybeUndefined::Value(Vec::new()));
    }

    #[test]
    fn tool_call_name_patch_distinguishes_omitted_null_and_value() {
        let named = ToolCallUpdate::new("tc_1").name("read_file");
        assert_eq!(
            serde_json::to_value(named).unwrap(),
            serde_json::json!({
                "toolCallId": "tc_1",
                "name": "read_file"
            })
        );

        let omitted = ToolCallUpdate::new("tc_1");
        assert_eq!(omitted.name, MaybeUndefined::Undefined);

        let from_null: ToolCallUpdate = serde_json::from_value(serde_json::json!({
            "toolCallId": "tc_1",
            "name": null
        }))
        .unwrap();
        assert_eq!(from_null.name, MaybeUndefined::Null);

        let mut stored = ToolCallUpdate::new("tc_1").name("read_file");
        stored.apply_update(ToolCallUpdate::new("tc_1"));
        assert_eq!(stored.name, MaybeUndefined::Value("read_file".to_string()));

        stored.apply_update(ToolCallUpdate::new("tc_1").name(None::<String>));
        assert_eq!(stored.name, MaybeUndefined::Null);

        stored.apply_update(ToolCallUpdate::new("tc_1").name("write_file"));
        assert_eq!(stored.name, MaybeUndefined::Value("write_file".to_string()));
    }

    #[test]
    fn tool_call_update_distinguishes_meta_omitted_null_and_value() {
        let mut meta = Meta::new();
        meta.insert("source".to_string(), serde_json::json!("tool-call"));

        assert_eq!(
            serde_json::to_value(ToolCallUpdate::new("tc_1").meta(meta.clone())).unwrap(),
            serde_json::json!({
                "toolCallId": "tc_1",
                "_meta": {
                    "source": "tool-call"
                }
            })
        );

        assert_eq!(
            serde_json::to_value(ToolCallUpdate::new("tc_1").meta(None::<Meta>)).unwrap(),
            serde_json::json!({
                "toolCallId": "tc_1",
                "_meta": null
            })
        );

        let deserialized: ToolCallUpdate = serde_json::from_value(serde_json::json!({
            "toolCallId": "tc_1",
            "_meta": null
        }))
        .unwrap();
        assert_eq!(deserialized.meta, MaybeUndefined::Null);

        let patch = ToolCallUpdate::new("tc_1");
        assert_eq!(patch.meta, MaybeUndefined::Undefined);

        let mut stored = ToolCallUpdate::new("tc_1").meta(meta);
        stored.apply_update(ToolCallUpdate::new("tc_1").meta(None::<Meta>));
        assert_eq!(stored.meta, MaybeUndefined::Null);
    }

    #[test]
    fn tool_call_update_patches_meta_by_top_level_key() {
        let mut stored: ToolCallUpdate = from_value(json!({
            "toolCallId": "tc_1",
            "_meta": {"zed.dev/a": 1, "acme.dev/b": {"x": 1}}
        }))
        .unwrap();

        // A writer that only knows its own key must not erase other keys.
        stored.apply_update(
            from_value(json!({"toolCallId": "tc_1", "_meta": {"proxy.dev/c": true}})).unwrap(),
        );
        stored.apply_update(
            from_value(json!({
                "toolCallId": "tc_1",
                "_meta": {"zed.dev/a": null, "acme.dev/b": {"y": 2}}
            }))
            .unwrap(),
        );

        assert_eq!(
            to_value(&stored).unwrap(),
            json!({
                "toolCallId": "tc_1",
                "_meta": {"acme.dev/b": {"y": 2}, "proxy.dev/c": true}
            })
        );
    }

    #[test]
    fn tool_call_wire_patches_preserve_omitted_fields_and_replace_values() {
        let initial = json!({
            "toolCallId": "tc_1",
            "_meta": {"source": "replay", "opaque": {"sequence": 1}}
        });
        let mut stored: ToolCallUpdate = from_value(initial.clone()).unwrap();
        // A metadata-only first update must not invent content or a status.
        assert_eq!(to_value(&stored).unwrap(), initial);

        let populated = json!({
            "toolCallId": "tc_1",
            "name": "read_file",
            "title": "Reading configuration",
            "kind": "read",
            "status": "in_progress",
            "content": [{
                "type": "content",
                "content": {
                    "type": "text",
                    "text": "old",
                    "_meta": {"source": "tool"}
                }
            }],
            "locations": [{"path": "/workspace/config.json", "line": 3}],
            "rawInput": {"path": "/workspace/config.json"},
            "rawOutput": {"text": "old"}
        });
        stored.apply_update(from_value(populated.clone()).unwrap());
        let mut expected = populated;
        expected["_meta"] = initial["_meta"].clone();
        assert_eq!(to_value(&stored).unwrap(), expected);

        for (field, empty) in [
            ("content", json!([])),
            ("locations", json!([])),
            ("rawInput", json!({})),
            ("rawOutput", json!({})),
        ] {
            let original = expected[field].clone();
            // Empty values replace rather than merge; null remains distinct.
            // Restoring the value also checks that clearing is not permanent.
            for replacement in [empty, json!(null), original] {
                stored.apply_update(
                    from_value(json!({"toolCallId": "tc_1", (field): replacement})).unwrap(),
                );
                expected[field] = replacement;
                assert_eq!(to_value(&stored).unwrap(), expected, "patching {field}");

                stored.apply_update(from_value(json!({"toolCallId": "tc_1"})).unwrap());
                assert_eq!(to_value(&stored).unwrap(), expected, "omitting {field}");
            }
        }
    }

    #[test]
    fn tool_call_wire_patches_preserve_unknown_statuses() {
        for status in ["deferred", "_awaiting_review"] {
            let mut stored = ToolCallUpdate::new("tc_1").status(ToolCallStatus::InProgress);
            stored
                .apply_update(from_value(json!({"toolCallId": "tc_1", "status": status})).unwrap());
            let expected_status = MaybeUndefined::Value(ToolCallStatus::Other(status.to_owned()));
            assert_eq!(stored.status, expected_status);

            // An unrelated patch must not reset a future or extension status
            // to a known value, including a success or failure state.
            stored.apply_update(
                from_value(json!({"toolCallId": "tc_1", "title": "Still waiting"})).unwrap(),
            );
            assert_eq!(stored.status, expected_status);
            assert_eq!(
                to_value(&stored).unwrap(),
                json!({"toolCallId": "tc_1", "title": "Still waiting", "status": status})
            );
        }
    }

    #[test]
    fn tool_call_update_skips_malformed_list_items() {
        let deserialized: ToolCallUpdate = serde_json::from_value(serde_json::json!({
            "toolCallId": "tc_1",
            "content": [
                {
                    "type": "content",
                    "content": {
                        "type": "text",
                        "text": "ok"
                    }
                },
                {
                    "type": "diff",
                    "path": "/bad"
                }
            ],
            "locations": [
                {
                    "path": "/ok",
                    "line": 3
                },
                {
                    "line": 4
                }
            ]
        }))
        .unwrap();

        let MaybeUndefined::Value(content) = deserialized.content else {
            panic!("content should deserialize to a value");
        };
        assert_eq!(content.len(), 1);

        let MaybeUndefined::Value(locations) = deserialized.locations else {
            panic!("locations should deserialize to a value");
        };
        assert_eq!(locations.len(), 1);
    }

    #[test]
    fn tool_call_content_chunk_serializes_single_content_item() {
        let chunk = ToolCallContentChunk::new(
            "tc_1",
            ContentBlock::Text(crate::v2::TextContent::new("partial output")),
        );

        assert_eq!(
            serde_json::to_value(chunk).unwrap(),
            serde_json::json!({
                "toolCallId": "tc_1",
                "content": {
                    "type": "content",
                    "content": {
                        "type": "text",
                        "text": "partial output"
                    }
                }
            })
        );
    }

    #[test]
    fn terminal_content_serializes_as_display_reference() {
        let terminal = ToolCallContent::from(Terminal::new("term_1"));

        assert_eq!(
            serde_json::to_value(terminal).unwrap(),
            serde_json::json!({
                "type": "terminal",
                "terminalId": "term_1"
            })
        );
    }

    #[test]
    fn diff_patch_serializes_git_patch_with_structured_changes() {
        let patch_text = "diff --git /repo/config.json /repo/config.json\n--- /repo/config.json\n+++ /repo/config.json\n@@ -1 +1 @@\n-old\n+new\n";
        let diff = ToolCallContent::Diff(Diff::patch(
            patch_text,
            vec![
                DiffChange::modify("/repo/config.json")
                    .file_type(DiffFileType::Text)
                    .mime_type("application/json"),
            ],
        ));

        assert_eq!(
            serde_json::to_value(diff).unwrap(),
            serde_json::json!({
                "type": "diff",
                "changes": [
                    {
                        "operation": "modify",
                        "path": "/repo/config.json",
                        "fileType": "text",
                        "mimeType": "application/json"
                    }
                ],
                "patch": {
                    "format": "git_patch",
                    "text": patch_text
                }
            })
        );
    }

    #[test]
    fn diff_patch_requires_text() {
        let result = serde_json::from_value::<DiffPatch>(serde_json::json!({
            "format": "git_patch",
            "diff": "diff --git /repo/config.json /repo/config.json\n"
        }));

        assert!(result.is_err());
    }

    #[test]
    fn diff_serializes_binary_modify_without_patch_text() {
        let diff = ToolCallContent::Diff(Diff::new(vec![
            DiffChange::modify("/repo/assets/logo.png")
                .file_type(DiffFileType::Binary)
                .mime_type("image/png"),
        ]));

        assert_eq!(
            serde_json::to_value(diff).unwrap(),
            serde_json::json!({
                "type": "diff",
                "changes": [
                    {
                        "operation": "modify",
                        "path": "/repo/assets/logo.png",
                        "fileType": "binary",
                        "mimeType": "image/png"
                    }
                ]
            })
        );
    }

    #[test]
    fn diff_move_serializes_shared_fields_with_operation_payload() {
        let diff = ToolCallContent::Diff(Diff::new(vec![
            DiffChange::move_file("/repo/src/old.rs", "/repo/src/new.rs")
                .file_type(DiffFileType::Text)
                .mime_type("text/rust"),
        ]));

        assert_eq!(
            serde_json::to_value(diff).unwrap(),
            serde_json::json!({
                "type": "diff",
                "changes": [
                    {
                        "operation": "move",
                        "oldPath": "/repo/src/old.rs",
                        "path": "/repo/src/new.rs",
                        "fileType": "text",
                        "mimeType": "text/rust"
                    }
                ]
            })
        );
    }

    #[test]
    fn diff_changes_skip_malformed_list_items() {
        let patch_text = "diff --git /ok /ok\ndeleted file mode 100644\n--- /ok\n+++ /dev/null\n@@ -1 +0,0 @@\n-old\n";
        let content: ToolCallContent = serde_json::from_value(serde_json::json!({
            "type": "diff",
            "changes": [
                {
                    "operation": "modify"
                },
                {
                    "operation": "delete",
                    "path": "/ok"
                }
            ],
            "patch": {
                "format": "git_patch",
                "text": patch_text
            }
        }))
        .unwrap();

        let ToolCallContent::Diff(diff) = content else {
            panic!("expected diff content");
        };
        assert_eq!(diff.changes, vec![DiffChange::delete("/ok")]);
        assert_eq!(diff.patch, Some(DiffPatch::new(patch_text)));
    }

    #[test]
    fn tool_kind_preserves_unknown_variant() {
        let kind: ToolKind = serde_json::from_str("\"review\"").unwrap();
        assert_eq!(kind, ToolKind::Unknown("review".to_string()));
        assert_eq!(serde_json::to_value(&kind).unwrap(), "review");
    }

    #[test]
    fn tool_call_status_preserves_unknown_variant() {
        let status: ToolCallStatus = serde_json::from_str("\"deferred\"").unwrap();
        assert_eq!(status, ToolCallStatus::Other("deferred".to_string()));
        assert_eq!(serde_json::to_value(&status).unwrap(), "deferred");
    }

    #[test]
    fn tool_call_status_recognizes_cancelled_variant() {
        let status: ToolCallStatus = serde_json::from_str("\"cancelled\"").unwrap();
        assert_eq!(status, ToolCallStatus::Cancelled);
        assert_eq!(serde_json::to_value(&status).unwrap(), "cancelled");
    }

    #[test]
    fn tool_call_content_preserves_unknown_variant() {
        let content: ToolCallContent = serde_json::from_value(serde_json::json!({
            "type": "_chart",
            "title": "Tests",
            "data": [1, 2, 3]
        }))
        .unwrap();

        let ToolCallContent::Other(unknown) = content else {
            panic!("expected unknown tool call content");
        };

        assert_eq!(unknown.type_, "_chart");
        assert_eq!(
            unknown.fields.get("title"),
            Some(&serde_json::json!("Tests"))
        );
        assert_eq!(
            serde_json::to_value(ToolCallContent::Other(unknown)).unwrap(),
            serde_json::json!({
                "type": "_chart",
                "title": "Tests",
                "data": [1, 2, 3]
            })
        );
    }

    #[test]
    fn tool_call_content_does_not_hide_malformed_known_variant() {
        assert!(
            serde_json::from_value::<ToolCallContent>(serde_json::json!({
                "type": "diff"
            }))
            .is_err()
        );
        assert!(
            serde_json::from_value::<ToolCallContent>(serde_json::json!({
                "type": "terminal"
            }))
            .is_err()
        );
    }
}