swink-agent 0.13.2

//! Foundation types for the swink agent.
//!
//! This module defines every type that crosses a public boundary in the harness.
//! All other modules depend on it; it depends on nothing else in the crate.

mod custom_message;
pub mod message_codec;
mod model;

pub use custom_message::*;
pub use message_codec::{
    MessageSlot, SerializedCustomMessage, SerializedMessages, clone_messages_for_send,
    restore_messages, restore_single_custom, serialize_messages,
};
pub use model::*;

use std::collections::HashMap;
use std::fmt;
use std::ops::{Add, AddAssign};
use std::sync::Arc;

use serde::{Deserialize, Serialize};

// ─── Content ────────────────────────────────────────────────────────────────

/// The atomic unit of all message content.
///
/// Different variants are permitted in different message roles:
/// - `Text`: user, assistant, tool result
/// - `Thinking`: assistant only
/// - `ToolCall`: assistant only
/// - `Image`: user, tool result
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ContentBlock {
    /// A plain text string.
    Text { text: String },

    /// A reasoning / chain-of-thought string with an optional provider signature.
    Thinking {
        thinking: String,
        signature: Option<String>,
    },

    /// A tool invocation with an ID, tool name, parsed arguments, and an
    /// optional partial JSON buffer used during streaming.
    ToolCall {
        id: String,
        name: String,
        arguments: serde_json::Value,
        partial_json: Option<String>,
    },

    /// Image data from a supported source type.
    Image { source: ImageSource },

    /// An extension content block for plugin-defined types.
    ///
    /// Allows multimodal plugins to pass structured data without flattening to `Text`.
    Extension {
        type_name: String,
        data: serde_json::Value,
    },
}

impl ContentBlock {
    /// Extract concatenated text from a slice of content blocks.
    ///
    /// Returns the joined text of all `Text` variants, ignoring other block types.
    pub fn extract_text(blocks: &[Self]) -> String {
        let mut result = String::new();
        for block in blocks {
            if let Self::Text { text } = block {
                result.push_str(text);
            }
        }
        result
    }
}

/// Source for image data.
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ImageSource {
    /// Base64-encoded image data with a media type.
    Base64 { media_type: String, data: String },

    /// A URL pointing to an image.
    Url { url: String, media_type: String },

    /// A local file path pointing to an image.
    File {
        path: std::path::PathBuf,
        media_type: String,
    },
}

// ─── Messages ───────────────────────────────────────────────────────────────

/// A message from the user.
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct UserMessage {
    pub content: Vec<ContentBlock>,
    pub timestamp: u64,
    /// Provider-agnostic cache hint for this message.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_hint: Option<crate::context_cache::CacheHint>,
}

impl UserMessage {
    /// Create a new user message with the given content.
    ///
    /// `timestamp` defaults to now and `cache_hint` defaults to `None`.
    #[must_use]
    pub fn new(content: Vec<ContentBlock>) -> Self {
        Self {
            content,
            timestamp: crate::util::now_timestamp(),
            cache_hint: None,
        }
    }

    #[must_use]
    pub const fn with_timestamp(mut self, timestamp: u64) -> Self {
        self.timestamp = timestamp;
        self
    }

    #[must_use]
    pub fn with_cache_hint(mut self, cache_hint: crate::context_cache::CacheHint) -> Self {
        self.cache_hint = Some(cache_hint);
        self
    }
}

/// A message from the assistant (LLM response).
#[non_exhaustive]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AssistantMessage {
    pub content: Vec<ContentBlock>,
    pub provider: String,
    pub model_id: String,
    pub usage: Usage,
    pub cost: Cost,
    pub stop_reason: StopReason,
    pub error_message: Option<String>,
    /// Structured error classification carried from the stream `Error` event.
    ///
    /// When present, the agent loop uses this to classify the error without
    /// falling back to string matching on `error_message`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_kind: Option<crate::stream_error_kind::StreamErrorKind>,
    pub timestamp: u64,
    /// Provider-agnostic cache hint for this message.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_hint: Option<crate::context_cache::CacheHint>,
}

impl AssistantMessage {
    /// Create a new assistant message with the given content, provider, and model ID.
    ///
    /// `usage`/`cost` default to zero, `stop_reason` defaults to
    /// [`StopReason::Stop`], `error_message`/`error_kind` default to `None`,
    /// `timestamp` defaults to now, and `cache_hint` defaults to `None`.
    #[must_use]
    pub fn new(
        content: Vec<ContentBlock>,
        provider: impl Into<String>,
        model_id: impl Into<String>,
    ) -> Self {
        Self {
            content,
            provider: provider.into(),
            model_id: model_id.into(),
            usage: Usage::default(),
            cost: Cost::default(),
            stop_reason: StopReason::Stop,
            error_message: None,
            error_kind: None,
            timestamp: crate::util::now_timestamp(),
            cache_hint: None,
        }
    }

    #[must_use]
    pub fn with_usage(mut self, usage: Usage) -> Self {
        self.usage = usage;
        self
    }

    #[must_use]
    pub fn with_cost(mut self, cost: Cost) -> Self {
        self.cost = cost;
        self
    }

    #[must_use]
    pub const fn with_stop_reason(mut self, stop_reason: StopReason) -> Self {
        self.stop_reason = stop_reason;
        self
    }

    #[must_use]
    pub fn with_error_message(mut self, error_message: impl Into<String>) -> Self {
        self.error_message = Some(error_message.into());
        self
    }

    #[must_use]
    pub const fn with_error_kind(
        mut self,
        error_kind: crate::stream_error_kind::StreamErrorKind,
    ) -> Self {
        self.error_kind = Some(error_kind);
        self
    }

    #[must_use]
    pub const fn with_timestamp(mut self, timestamp: u64) -> Self {
        self.timestamp = timestamp;
        self
    }

    #[must_use]
    pub fn with_cache_hint(mut self, cache_hint: crate::context_cache::CacheHint) -> Self {
        self.cache_hint = Some(cache_hint);
        self
    }

    /// Whether this message contains anything a consumer would surface:
    /// non-whitespace text, a tool call, an image, or an extension block.
    ///
    /// `Thinking` blocks are *not* visible content — they are hidden-channel
    /// reasoning that hosts collapse or omit by default. A message that fails
    /// this check produced nothing the user (or a tool dispatcher) can see.
    #[must_use]
    pub fn has_visible_content(&self) -> bool {
        self.content.iter().any(|block| match block {
            ContentBlock::Text { text } => !text.trim().is_empty(),
            ContentBlock::Thinking { .. } => false,
            // Tool calls, images, and any plugin-defined block count as
            // visible: they carry consumer-facing (or actionable) payload.
            _ => true,
        })
    }

    /// Whether this message consists of hidden-channel reasoning only:
    /// at least one `Thinking` block and no visible content at all.
    ///
    /// This is the condition behind
    /// [`TurnEndReason::ReasoningOnly`](crate::TurnEndReason::ReasoningOnly) —
    /// the model "answered" into a channel the user never sees. Distinct from
    /// an empty message, which has neither reasoning nor visible content.
    #[must_use]
    pub fn is_reasoning_only(&self) -> bool {
        !self.has_visible_content()
            && self
                .content
                .iter()
                .any(|block| matches!(block, ContentBlock::Thinking { .. }))
    }
}

/// Returns a message whose `provider` and `model_id` are **empty strings**.
///
/// This is convenient as a builder base in tests, but it is not a valid
/// provider response on its own — pricing and telemetry keyed on those
/// identifiers will not resolve. Construct real messages with
/// [`AssistantMessage::new`], which requires both identifiers.
impl Default for AssistantMessage {
    fn default() -> Self {
        Self::new(Vec::new(), String::new(), String::new())
    }
}

/// The result of a tool execution, sent back to the LLM.
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ToolResultMessage {
    pub tool_call_id: String,
    pub content: Vec<ContentBlock>,
    pub is_error: bool,
    pub timestamp: u64,
    /// Structured data for display — not sent to the LLM.
    #[serde(default)]
    pub details: serde_json::Value,
    /// Provider-agnostic cache hint for this message.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_hint: Option<crate::context_cache::CacheHint>,
}

impl ToolResultMessage {
    /// Create a new tool result message.
    ///
    /// `is_error` defaults to `false`, `timestamp` defaults to now,
    /// `details` defaults to `Value::Null`, and `cache_hint` defaults to `None`.
    #[must_use]
    pub fn new(tool_call_id: impl Into<String>, content: Vec<ContentBlock>) -> Self {
        Self {
            tool_call_id: tool_call_id.into(),
            content,
            is_error: false,
            timestamp: crate::util::now_timestamp(),
            details: serde_json::Value::Null,
            cache_hint: None,
        }
    }

    #[must_use]
    pub const fn with_is_error(mut self, is_error: bool) -> Self {
        self.is_error = is_error;
        self
    }

    #[must_use]
    pub fn with_details(mut self, details: serde_json::Value) -> Self {
        self.details = details;
        self
    }

    #[must_use]
    pub const fn with_timestamp(mut self, timestamp: u64) -> Self {
        self.timestamp = timestamp;
        self
    }

    #[must_use]
    pub fn with_cache_hint(mut self, cache_hint: crate::context_cache::CacheHint) -> Self {
        self.cache_hint = Some(cache_hint);
        self
    }
}

/// A discriminated union of the three LLM message roles.
#[non_exhaustive]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "role", rename_all = "snake_case")]
pub enum LlmMessage {
    User(UserMessage),
    Assistant(AssistantMessage),
    ToolResult(ToolResultMessage),
}

// ─── Usage & Cost ───────────────────────────────────────────────────────────

/// Token usage counters for an LLM response.
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Usage {
    pub input: u64,
    pub output: u64,
    pub cache_read: u64,
    pub cache_write: u64,
    pub total: u64,
    /// Provider-specific extra metrics (reasoning tokens, search tokens, etc.).
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub extra: HashMap<String, u64>,
}

impl Usage {
    /// Merge another `Usage` into this one by summing all fields.
    pub fn merge(&mut self, other: &Self) {
        *self += other.clone();
    }

    #[must_use]
    pub const fn with_input(mut self, input: u64) -> Self {
        self.input = input;
        self
    }

    #[must_use]
    pub const fn with_output(mut self, output: u64) -> Self {
        self.output = output;
        self
    }

    #[must_use]
    pub const fn with_cache_read(mut self, cache_read: u64) -> Self {
        self.cache_read = cache_read;
        self
    }

    #[must_use]
    pub const fn with_cache_write(mut self, cache_write: u64) -> Self {
        self.cache_write = cache_write;
        self
    }

    #[must_use]
    pub const fn with_total(mut self, total: u64) -> Self {
        self.total = total;
        self
    }

    #[must_use]
    pub fn with_extra(mut self, extra: HashMap<String, u64>) -> Self {
        self.extra = extra;
        self
    }
}

impl Add for Usage {
    type Output = Self;

    fn add(mut self, rhs: Self) -> Self::Output {
        self += rhs;
        self
    }
}

impl AddAssign for Usage {
    fn add_assign(&mut self, rhs: Self) {
        self.input += rhs.input;
        self.output += rhs.output;
        self.cache_read += rhs.cache_read;
        self.cache_write += rhs.cache_write;
        self.total += rhs.total;
        for (k, v) in rhs.extra {
            *self.extra.entry(k).or_insert(0) += v;
        }
    }
}

/// Per-category and total cost breakdown (floating-point currency values).
#[non_exhaustive]
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Cost {
    pub input: f64,
    pub output: f64,
    pub cache_read: f64,
    pub cache_write: f64,
    pub total: f64,
    /// Provider-specific extra cost categories.
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub extra: HashMap<String, f64>,
}

impl Cost {
    /// Returns `true` when every cost category — including [`Cost::extra`] — is zero.
    ///
    /// Used to detect an adapter that did not price its own response, so the
    /// agent loop can fall back to catalog pricing via
    /// [`price_assistant_message`](crate::price_assistant_message).
    #[must_use]
    pub fn is_zero(&self) -> bool {
        self.input == 0.0
            && self.output == 0.0
            && self.cache_read == 0.0
            && self.cache_write == 0.0
            && self.total == 0.0
            && self.extra.values().all(|v| *v == 0.0)
    }

    #[must_use]
    pub const fn with_input(mut self, input: f64) -> Self {
        self.input = input;
        self
    }

    #[must_use]
    pub const fn with_output(mut self, output: f64) -> Self {
        self.output = output;
        self
    }

    #[must_use]
    pub const fn with_cache_read(mut self, cache_read: f64) -> Self {
        self.cache_read = cache_read;
        self
    }

    #[must_use]
    pub const fn with_cache_write(mut self, cache_write: f64) -> Self {
        self.cache_write = cache_write;
        self
    }

    #[must_use]
    pub const fn with_total(mut self, total: f64) -> Self {
        self.total = total;
        self
    }

    #[must_use]
    pub fn with_extra(mut self, extra: HashMap<String, f64>) -> Self {
        self.extra = extra;
        self
    }
}

impl Add for Cost {
    type Output = Self;

    fn add(mut self, rhs: Self) -> Self::Output {
        self += rhs;
        self
    }
}

impl AddAssign for Cost {
    fn add_assign(&mut self, rhs: Self) {
        self.input += rhs.input;
        self.output += rhs.output;
        self.cache_read += rhs.cache_read;
        self.cache_write += rhs.cache_write;
        self.total += rhs.total;
        for (k, v) in rhs.extra {
            *self.extra.entry(k).or_insert(0.0) += v;
        }
    }
}

// ─── Stop Reason ────────────────────────────────────────────────────────────

/// Indicates why assistant generation ended.
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StopReason {
    /// Natural end of generation.
    Stop,
    /// Output token limit reached.
    Length,
    /// Model requested a tool call.
    ToolUse,
    /// Cancelled by the caller.
    Aborted,
    /// An error occurred during generation.
    Error,
    /// Agent loop terminated due to a transfer signal.
    Transfer,
}

// ─── Agent Result ───────────────────────────────────────────────────────────

/// The value returned by non-streaming invocations.
#[non_exhaustive]
pub struct AgentResult {
    /// All new messages produced during the run.
    pub messages: Vec<AgentMessage>,
    /// The final stop reason from the last assistant message.
    pub stop_reason: StopReason,
    /// Aggregated token usage across all turns in the run.
    pub usage: Usage,
    /// Aggregated cost across all turns in the run.
    pub cost: Cost,
    /// Optional error string if the run ended in an error state.
    pub error: Option<String>,
    /// Optional transfer signal when the run ended with `StopReason::Transfer`.
    pub transfer_signal: Option<crate::transfer::TransferSignal>,
}

impl AgentResult {
    /// Create a new agent result from the produced messages and final stop reason.
    ///
    /// `usage`/`cost` default to zero, and `error`/`transfer_signal` default
    /// to `None`.
    #[must_use]
    pub fn new(messages: Vec<AgentMessage>, stop_reason: StopReason) -> Self {
        Self {
            messages,
            stop_reason,
            usage: Usage::default(),
            cost: Cost::default(),
            error: None,
            transfer_signal: None,
        }
    }

    #[must_use]
    pub fn with_usage(mut self, usage: Usage) -> Self {
        self.usage = usage;
        self
    }

    #[must_use]
    pub fn with_cost(mut self, cost: Cost) -> Self {
        self.cost = cost;
        self
    }

    #[must_use]
    pub fn with_error(mut self, error: impl Into<String>) -> Self {
        self.error = Some(error.into());
        self
    }

    #[must_use]
    pub fn with_transfer_signal(
        mut self,
        transfer_signal: crate::transfer::TransferSignal,
    ) -> Self {
        self.transfer_signal = Some(transfer_signal);
        self
    }

    /// Extract the text content from the last assistant message, if any.
    ///
    /// Iterates messages in reverse order, finds the first `Assistant` message,
    /// and returns its concatenated text blocks. Returns an empty string if no
    /// assistant message is found or if the assistant message contains no text.
    pub fn assistant_text(&self) -> String {
        self.messages
            .iter()
            .rev()
            .find_map(|msg| match msg {
                AgentMessage::Llm(LlmMessage::Assistant(a)) => Some(a),
                _ => None,
            })
            .map(|a| ContentBlock::extract_text(&a.content))
            .unwrap_or_default()
    }
}

impl fmt::Debug for AgentResult {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AgentResult")
            .field("messages", &self.messages)
            .field("stop_reason", &self.stop_reason)
            .field("usage", &self.usage)
            .field("cost", &self.cost)
            .field("error", &self.error)
            .field("transfer_signal", &self.transfer_signal)
            .finish()
    }
}

// ─── Agent Context ──────────────────────────────────────────────────────────

/// The immutable snapshot passed into each loop turn.
///
/// Contains the system prompt, current message history, and the list of
/// available tools. The loop never mutates a context in place — each turn
/// produces a new snapshot.
#[non_exhaustive]
pub struct AgentContext {
    pub system_prompt: String,
    pub messages: Vec<AgentMessage>,
    /// The tools available during this turn.
    pub tools: Vec<Arc<dyn crate::tool::AgentTool>>,
}

impl AgentContext {
    /// Create a new agent context from the system prompt, message history,
    /// and available tools.
    #[must_use]
    pub fn new(
        system_prompt: impl Into<String>,
        messages: Vec<AgentMessage>,
        tools: Vec<Arc<dyn crate::tool::AgentTool>>,
    ) -> Self {
        Self {
            system_prompt: system_prompt.into(),
            messages,
            tools,
        }
    }

    /// Attempt to clone this context without losing any message.
    ///
    /// Returns `None` if any message fails [`AgentMessage::try_clone`] —
    /// all-or-nothing, so callers never silently truncate history. Tools are
    /// shared via `Arc`.
    ///
    /// `StreamFn` decorators that need an owned context (to modify options
    /// and delegate from a spawned task) should prefer this over hand-rolled
    /// per-variant clones; for a best-effort snapshot that drops
    /// non-serializable custom messages instead of failing, use
    /// [`clone_for_send`](Self::clone_for_send).
    #[must_use]
    pub fn try_clone(&self) -> Option<Self> {
        let messages = self
            .messages
            .iter()
            .map(AgentMessage::try_clone)
            .collect::<Option<Vec<_>>>()?;
        Some(Self {
            system_prompt: self.system_prompt.clone(),
            messages,
            tools: self.tools.clone(),
        })
    }

    /// Snapshot this context into fully owned values, best-effort.
    ///
    /// `Llm` messages clone directly; `Custom` messages are
    /// snapshot-serialized via
    /// [`clone_messages_for_send`](crate::types::clone_messages_for_send),
    /// which silently drops custom messages that don't support
    /// serialization. Provider adapters never see custom messages, so this
    /// is safe for building request snapshots; use
    /// [`try_clone`](Self::try_clone) when every message must survive.
    #[must_use]
    pub fn clone_for_send(&self) -> Self {
        Self {
            system_prompt: self.system_prompt.clone(),
            messages: clone_messages_for_send(&self.messages),
            tools: self.tools.clone(),
        }
    }
}

impl fmt::Debug for AgentContext {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AgentContext")
            .field("system_prompt", &self.system_prompt)
            .field("messages", &self.messages)
            .field("tools", &format_args!("[{} tool(s)]", self.tools.len()))
            .finish()
    }
}

// ─── Serde Helpers ──────────────────────────────────────────────────────

fn serialize_arc_vec<S, T>(value: &Arc<Vec<T>>, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
    T: Serialize,
{
    value.as_ref().serialize(serializer)
}

fn deserialize_arc_vec<'de, D, T>(deserializer: D) -> Result<Arc<Vec<T>>, D::Error>
where
    D: serde::Deserializer<'de>,
    T: Deserialize<'de>,
{
    let v = Vec::<T>::deserialize(deserializer)?;
    Ok(Arc::new(v))
}

// ─── Turn Snapshot ──────────────────────────────────────────────────────

/// A point-in-time snapshot of agent state at a turn boundary.
///
/// Emitted as part of `TurnEnd` events to support external replay, auditing,
/// and debugging. Contains the full context at the moment the turn completed.
#[non_exhaustive]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TurnSnapshot {
    /// Zero-based index of this turn within the current agent loop run.
    pub turn_index: usize,
    /// The LLM messages present in the context at the turn boundary.
    ///
    /// Each message is wrapped in an `Arc` shared with the loop's internal
    /// history and with neighbouring turn snapshots, so building a snapshot
    /// costs pointer bumps for the unchanged history prefix instead of a
    /// deep copy of every message on every turn. The outer `Arc` keeps
    /// forwarding the snapshot to multiple subscribers cheap. Serialization
    /// is transparent: the JSON shape is a plain array of messages.
    #[serde(
        serialize_with = "serialize_arc_vec",
        deserialize_with = "deserialize_arc_vec"
    )]
    pub messages: Arc<Vec<Arc<LlmMessage>>>,
    /// Accumulated token usage up to and including this turn.
    pub usage: Usage,
    /// Accumulated cost up to and including this turn.
    pub cost: Cost,
    /// Stop reason from the assistant message that ended this turn.
    pub stop_reason: StopReason,
    /// Session state changes during this turn, if any.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub state_delta: Option<crate::StateDelta>,
}

impl TurnSnapshot {
    /// Create a new turn snapshot from the turn index, message history, and
    /// stop reason.
    ///
    /// `usage`/`cost` default to zero and `state_delta` defaults to `None`.
    #[must_use]
    pub fn new(
        turn_index: usize,
        messages: Arc<Vec<Arc<LlmMessage>>>,
        stop_reason: StopReason,
    ) -> Self {
        Self {
            turn_index,
            messages,
            usage: Usage::default(),
            cost: Cost::default(),
            stop_reason,
            state_delta: None,
        }
    }

    #[must_use]
    pub fn with_usage(mut self, usage: Usage) -> Self {
        self.usage = usage;
        self
    }

    #[must_use]
    pub fn with_cost(mut self, cost: Cost) -> Self {
        self.cost = cost;
        self
    }

    #[must_use]
    pub fn with_state_delta(mut self, state_delta: crate::StateDelta) -> Self {
        self.state_delta = Some(state_delta);
        self
    }
}

// ─── Compile-time Send + Sync assertions ────────────────────────────────────

const _: () = {
    const fn assert_send_sync<T: Send + Sync>() {}

    assert_send_sync::<ContentBlock>();
    assert_send_sync::<ImageSource>();
    assert_send_sync::<UserMessage>();
    assert_send_sync::<AssistantMessage>();
    assert_send_sync::<ToolResultMessage>();
    assert_send_sync::<LlmMessage>();
    assert_send_sync::<AgentMessage>();
    assert_send_sync::<Usage>();
    assert_send_sync::<Cost>();
    assert_send_sync::<StopReason>();
    assert_send_sync::<ThinkingLevel>();
    assert_send_sync::<ThinkingLevelSet>();
    assert_send_sync::<ThinkingBudgets>();
    assert_send_sync::<ModelCapabilities>();
    assert_send_sync::<ModelSpec>();
    assert_send_sync::<AgentResult>();
    assert_send_sync::<AgentContext>();
    assert_send_sync::<TurnSnapshot>();
    assert_send_sync::<CustomMessageRegistry>();
    assert_send_sync::<crate::error::DowncastError>();
};

#[cfg(test)]
#[path = "tests.rs"]
mod tests;