llmwire 0.1.0

Bidirectional, stateless, transport-neutral LLM wire protocol conversion kernel
Documentation
use serde::de::Error as DeError;
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::value::RawValue;

#[derive(Debug, Deserialize)]
pub(crate) struct MessagesRequestIn {
    #[serde(default)]
    pub messages: Vec<MessageIn>,
    pub system: Option<TextOrBlocks>,
    pub tools: Option<Vec<ToolIn>>,
    pub tool_choice: Option<Box<RawValue>>,
    pub max_tokens: Option<u32>,
    pub temperature: Option<f32>,
    pub top_p: Option<f32>,
    pub top_k: Option<u32>,
    pub stop_sequences: Option<Vec<String>>,
    pub thinking: Option<ThinkingConfigIn>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct MessageIn {
    pub role: String,
    pub content: Option<TextOrBlocks>,
}

#[derive(Debug)]
pub(crate) enum TextOrBlocks {
    Text(String),
    Blocks(Vec<Box<RawValue>>),
}

impl<'de> Deserialize<'de> for TextOrBlocks {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let raw = Box::<RawValue>::deserialize(deserializer)?;
        let source = raw.get().trim_start();
        if source.starts_with('"') {
            serde_json::from_str(source)
                .map(Self::Text)
                .map_err(DeError::custom)
        } else if source.starts_with('[') {
            serde_json::from_str(source)
                .map(Self::Blocks)
                .map_err(DeError::custom)
        } else {
            Err(DeError::custom("messages content must be string or array"))
        }
    }
}

#[derive(Debug, Deserialize)]
pub(crate) struct ThinkingConfigIn {
    #[serde(rename = "type")]
    pub kind: Option<String>,
    pub budget_tokens: Option<u64>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ToolIn {
    pub name: String,
    pub description: Option<String>,
    pub input_schema: Option<Box<RawValue>>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct BlockMetaIn {
    #[serde(rename = "type")]
    pub kind: String,
    pub cache_control: Option<Box<RawValue>>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct TextBlockIn {
    pub text: String,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ImageBlockIn {
    pub source: ImageSourceIn,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ImageSourceIn {
    #[serde(rename = "type")]
    pub kind: String,
    pub media_type: Option<String>,
    pub data: Option<String>,
    pub url: Option<String>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ToolUseBlockIn {
    pub id: String,
    pub name: String,
    pub input: Box<RawValue>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ToolResultBlockIn {
    pub tool_use_id: String,
    pub content: Option<ToolResultContentIn>,
}

#[derive(Debug)]
pub(crate) enum ToolResultContentIn {
    Text(String),
    Blocks(Vec<Box<RawValue>>),
    Other(Box<RawValue>),
}

impl<'de> Deserialize<'de> for ToolResultContentIn {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let raw = Box::<RawValue>::deserialize(deserializer)?;
        let source = raw.get().trim_start();
        if source.starts_with('"') {
            serde_json::from_str(source)
                .map(Self::Text)
                .map_err(DeError::custom)
        } else if source.starts_with('[') {
            serde_json::from_str(source)
                .map(Self::Blocks)
                .map_err(DeError::custom)
        } else {
            Ok(Self::Other(raw))
        }
    }
}

#[derive(Debug, Deserialize)]
pub(crate) struct ThinkingBlockIn {
    pub thinking: String,
    pub signature: Option<String>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct RedactedThinkingBlockIn {
    pub data: String,
}

#[derive(Debug, Serialize)]
pub(crate) struct MessagesRequestOut {
    pub model: &'static str,
    pub max_tokens: u32,
    pub messages: Vec<MessageOut>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system: Option<TextOrBlocksOut>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<ToolOut>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_choice: Option<Box<RawValue>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_k: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop_sequences: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thinking: Option<ThinkingConfigOut>,
}

#[derive(Debug, Serialize)]
pub(crate) struct MessageOut {
    pub role: &'static str,
    pub content: TextOrBlocksOut,
}

#[derive(Debug, Serialize)]
#[serde(untagged)]
pub(crate) enum TextOrBlocksOut {
    Text(String),
    Blocks(Vec<Box<RawValue>>),
}

#[derive(Debug, Serialize)]
pub(crate) struct ThinkingConfigOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub budget_tokens: u64,
}

#[derive(Debug, Serialize)]
pub(crate) struct ToolOut {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub input_schema: Box<RawValue>,
}

#[derive(Debug, Serialize)]
pub(crate) struct TextBlockOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub text: String,
}

#[derive(Debug, Serialize)]
pub(crate) struct ImageBlockOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub source: ImageSourceOut,
}

#[derive(Debug, Serialize)]
pub(crate) struct ImageSourceOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Debug, Serialize)]
pub(crate) struct ToolUseBlockOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub id: String,
    pub name: String,
    pub input: Box<RawValue>,
}

#[derive(Debug, Serialize)]
pub(crate) struct ToolResultBlockOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub tool_use_id: String,
    pub content: TextOrBlocksOut,
}

#[derive(Debug, Serialize)]
pub(crate) struct ThinkingBlockOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub thinking: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
}

#[derive(Debug, Serialize)]
pub(crate) struct RedactedThinkingBlockOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub data: String,
}

#[derive(Debug, Deserialize)]
pub(crate) struct MessagesResponseIn {
    pub id: Option<String>,
    pub model: Option<String>,
    #[serde(default)]
    pub content: Vec<Box<RawValue>>,
    pub stop_reason: Option<String>,
    pub stop_sequence: Option<String>,
    pub usage: Option<UsageIn>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct UsageIn {
    pub input_tokens: Option<u64>,
    pub output_tokens: Option<u64>,
    pub cache_read_input_tokens: Option<u64>,
    pub cache_creation_input_tokens: Option<u64>,
}

#[derive(Debug, Serialize)]
pub(crate) struct MessagesResponseOut {
    pub id: String,
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub role: &'static str,
    pub content: Vec<Box<RawValue>>,
    pub model: String,
    pub stop_reason: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop_sequence: Option<String>,
    pub usage: UsageOut,
}

#[derive(Debug, Serialize)]
pub(crate) struct UsageOut {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_tokens: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_tokens: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_read_input_tokens: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_creation_input_tokens: Option<u64>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct MessageStartIn {
    pub message: MessageStartBodyIn,
}

#[derive(Debug, Deserialize)]
pub(crate) struct MessageStartBodyIn {
    pub id: String,
    pub model: Option<String>,
    pub usage: Option<UsageIn>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ContentBlockStartIn {
    pub index: usize,
    pub content_block: ContentBlockStartBodyIn,
}

#[derive(Debug, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub(crate) enum ContentBlockStartBodyIn {
    Text {
        #[serde(default)]
        text: String,
    },
    ToolUse {
        id: String,
        name: String,
        input: Option<serde_json::Value>,
    },
    Thinking {
        #[serde(default)]
        thinking: String,
        signature: Option<String>,
    },
    RedactedThinking {
        #[serde(default)]
        data: String,
    },
    #[serde(other)]
    Unknown,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ContentBlockDeltaIn {
    pub index: usize,
    pub delta: ContentBlockDeltaBodyIn,
}

#[derive(Debug, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub(crate) enum ContentBlockDeltaBodyIn {
    TextDelta {
        text: String,
    },
    ThinkingDelta {
        thinking: String,
    },
    InputJsonDelta {
        partial_json: String,
    },
    SignatureDelta {
        signature: String,
    },
    #[serde(other)]
    Unknown,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ContentBlockStopIn {
    pub index: usize,
}

#[derive(Debug, Deserialize)]
pub(crate) struct MessageDeltaIn {
    pub delta: MessageDeltaBodyIn,
    pub usage: Option<UsageIn>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct MessageDeltaBodyIn {
    pub stop_reason: Option<String>,
    pub stop_sequence: Option<String>,
}