llmwire 0.1.0

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

#[derive(Debug, Deserialize)]
pub(crate) struct ResponsesRequestIn {
    pub instructions: Option<String>,
    pub input: Option<ResponsesInputIn>,
    pub tools: Option<Vec<ResponsesToolIn>>,
    pub tool_choice: Option<Box<RawValue>>,
    pub reasoning: Option<ResponsesReasoningIn>,
    pub max_output_tokens: Option<u32>,
    pub temperature: Option<f32>,
    pub top_p: Option<f32>,
    pub store: Option<bool>,
    pub previous_response_id: Option<String>,
}

#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub(crate) enum ResponsesInputIn {
    Text(String),
    Items(Vec<serde_json::Value>),
}

#[derive(Debug, Deserialize)]
pub(crate) struct ResponsesToolIn {
    #[serde(rename = "type")]
    pub kind: Option<String>,
    pub name: String,
    pub description: Option<String>,
    pub parameters: Option<Box<RawValue>>,
    pub strict: Option<bool>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ResponsesReasoningIn {
    pub effort: Option<String>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ResponsesResponseIn {
    pub id: Option<String>,
    pub model: Option<String>,
    pub status: String,
    pub incomplete_details: Option<ResponsesIncompleteDetailsIn>,
    #[serde(default)]
    pub output: Vec<serde_json::Value>,
    pub usage: Option<ResponsesUsageIn>,
    pub error: Option<ResponsesErrorIn>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ResponsesIncompleteDetailsIn {
    pub reason: Option<String>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ResponsesErrorIn {
    pub message: Option<String>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ItemMetaIn {
    #[serde(rename = "type")]
    pub kind: String,
}

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

#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub(crate) enum MessageContentIn {
    Text(String),
    Parts(Vec<serde_json::Value>),
}

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

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

#[derive(Debug, Deserialize)]
pub(crate) struct ImagePartIn {
    pub image_url: Option<ImageUrlIn>,
    pub file_id: Option<String>,
    pub detail: Option<String>,
}

#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub(crate) enum ImageUrlIn {
    Url(String),
    Object { url: String, detail: Option<String> },
}

#[derive(Debug, Deserialize)]
pub(crate) struct FunctionCallItemIn {
    pub call_id: String,
    pub name: String,
    pub arguments: String,
}

#[derive(Debug, Deserialize)]
pub(crate) struct FunctionCallOutputItemIn {
    pub call_id: String,
    pub output: serde_json::Value,
}

#[derive(Debug, Deserialize)]
pub(crate) struct ReasoningItemIn {
    pub encrypted_content: Option<String>,
    pub summary: Option<Vec<ReasoningSummaryPartIn>>,
}

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

#[derive(Debug, Deserialize)]
pub(crate) struct ResponsesUsageIn {
    pub input_tokens: Option<u64>,
    pub output_tokens: Option<u64>,
    pub input_tokens_details: Option<InputTokensDetailsIn>,
    pub output_tokens_details: Option<OutputTokensDetailsIn>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct InputTokensDetailsIn {
    pub cached_tokens: Option<u64>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct OutputTokensDetailsIn {
    pub reasoning_tokens: Option<u64>,
}

#[derive(Debug, Serialize)]
pub(crate) struct ResponsesRequestOut {
    pub model: &'static str,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    pub input: Vec<Box<RawValue>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<ResponsesToolOut>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_choice: Option<Box<RawValue>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reasoning: Option<ResponsesReasoningOut>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_output_tokens: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f32>,
}

#[derive(Debug, Serialize)]
pub(crate) struct ResponsesToolOut {
    #[serde(rename = "type")]
    pub kind: &'static str,
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub parameters: Box<RawValue>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub strict: Option<bool>,
}

#[derive(Debug, Serialize)]
pub(crate) struct ResponsesReasoningOut {
    pub effort: String,
}

#[derive(Debug, Serialize)]
pub(crate) struct ResponsesResponseOut {
    pub id: String,
    pub object: &'static str,
    pub created_at: u64,
    pub status: String,
    pub model: String,
    pub output: Vec<Box<RawValue>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub incomplete_details: Option<ResponsesIncompleteDetailsOut>,
    pub usage: ResponsesUsageOut,
}

#[derive(Debug, Serialize)]
pub(crate) struct ResponsesIncompleteDetailsOut {
    pub reason: String,
}

#[derive(Debug, Serialize)]
pub(crate) struct ResponsesUsageOut {
    #[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 total_tokens: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_tokens_details: Option<InputTokensDetailsOut>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_tokens_details: Option<OutputTokensDetailsOut>,
}

#[derive(Debug, Serialize)]
pub(crate) struct InputTokensDetailsOut {
    pub cached_tokens: u64,
}

#[derive(Debug, Serialize)]
pub(crate) struct OutputTokensDetailsOut {
    pub reasoning_tokens: u64,
}