llm-worker 0.2.1

//! Timeline層のイベント型
//!
//! Timelineが受け取り、各Handlerへディスパッチするイベント表現。

use serde::{Deserialize, Serialize};

// =============================================================================
// Core Event Types (from llm_client layer)
// =============================================================================

/// LLMからのストリーミングイベント
///
/// 各LLMプロバイダからのレスポンスは、この`Event`のストリームとして
/// 統一的に処理されます。
///
/// # イベントの種類
///
/// - **メタイベント**: `Ping`, `Usage`, `Status`, `Error`
/// - **ブロックイベント**: `BlockStart`, `BlockDelta`, `BlockStop`, `BlockAbort`
///
/// # ブロックのライフサイクル
///
/// テキストやツール呼び出しは、`BlockStart` → `BlockDelta`(複数) → `BlockStop`
/// の順序でイベントが発生します。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Event {
    /// ハートビート
    Ping(PingEvent),
    /// トークン使用量
    Usage(UsageEvent),
    /// ストリームのステータス変化
    Status(StatusEvent),
    /// エラー発生
    Error(ErrorEvent),

    /// ブロック開始（テキスト、ツール使用等）
    BlockStart(BlockStart),
    /// ブロックの差分データ
    BlockDelta(BlockDelta),
    /// ブロック正常終了
    BlockStop(BlockStop),
    /// ブロック中断
    BlockAbort(BlockAbort),
}

// =============================================================================
// Meta Events
// =============================================================================

/// Pingイベント（ハートビート）
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct PingEvent {
    pub timestamp: Option<u64>,
}

/// 使用量イベント
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UsageEvent {
    /// 入力トークン数
    pub input_tokens: Option<u64>,
    /// 出力トークン数
    pub output_tokens: Option<u64>,
    /// 合計トークン数
    pub total_tokens: Option<u64>,
    /// キャッシュ読み込みトークン数
    pub cache_read_input_tokens: Option<u64>,
    /// キャッシュ作成トークン数
    pub cache_creation_input_tokens: Option<u64>,
}

/// ステータスイベント
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StatusEvent {
    pub status: ResponseStatus,
}

/// レスポンスステータス
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ResponseStatus {
    /// ストリーム開始
    Started,
    /// 正常完了
    Completed,
    /// キャンセルされた
    Cancelled,
    /// エラー発生
    Failed,
}

/// エラーイベント
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ErrorEvent {
    pub code: Option<String>,
    pub message: String,
}

// =============================================================================
// Block Types
// =============================================================================

/// ブロックの種別
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BlockType {
    /// テキスト生成
    Text,
    /// 思考 (Claude Extended Thinking等)
    Thinking,
    /// ツール呼び出し
    ToolUse,
    /// ツール結果
    ToolResult,
}

/// ブロック開始イベント
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockStart {
    /// ブロックのインデックス
    pub index: usize,
    /// ブロックの種別
    pub block_type: BlockType,
    /// ブロック固有のメタデータ
    pub metadata: BlockMetadata,
}

impl BlockStart {
    pub fn block_type(&self) -> BlockType {
        self.block_type
    }
}

/// ブロックのメタデータ
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum BlockMetadata {
    Text,
    Thinking,
    ToolUse { id: String, name: String },
    ToolResult { tool_use_id: String },
}

/// ブロックデルタイベント
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockDelta {
    /// ブロックのインデックス
    pub index: usize,
    /// デルタの内容
    pub delta: DeltaContent,
}

/// デルタの内容
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum DeltaContent {
    /// テキストデルタ
    Text(String),
    /// 思考デルタ
    Thinking(String),
    /// ツール引数のJSON部分文字列
    InputJson(String),
}

impl DeltaContent {
    /// デルタのブロック種別を取得
    pub fn block_type(&self) -> BlockType {
        match self {
            DeltaContent::Text(_) => BlockType::Text,
            DeltaContent::Thinking(_) => BlockType::Thinking,
            DeltaContent::InputJson(_) => BlockType::ToolUse,
        }
    }
}

/// ブロック停止イベント
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockStop {
    /// ブロックのインデックス
    pub index: usize,
    /// ブロックの種別
    pub block_type: BlockType,
    /// 停止理由
    pub stop_reason: Option<StopReason>,
}

impl BlockStop {
    pub fn block_type(&self) -> BlockType {
        self.block_type
    }
}

/// ブロック中断イベント
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockAbort {
    /// ブロックのインデックス
    pub index: usize,
    /// ブロックの種別
    pub block_type: BlockType,
    /// 中断理由
    pub reason: String,
}

impl BlockAbort {
    pub fn block_type(&self) -> BlockType {
        self.block_type
    }
}

/// 停止理由
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum StopReason {
    /// 自然終了
    EndTurn,
    /// 最大トークン数到達
    MaxTokens,
    /// ストップシーケンス到達
    StopSequence,
    /// ツール使用
    ToolUse,
}

// =============================================================================
// Builder / Factory helpers
// =============================================================================

impl Event {
    /// テキストブロック開始イベントを作成
    pub fn text_block_start(index: usize) -> Self {
        Event::BlockStart(BlockStart {
            index,
            block_type: BlockType::Text,
            metadata: BlockMetadata::Text,
        })
    }

    /// テキストデルタイベントを作成
    pub fn text_delta(index: usize, text: impl Into<String>) -> Self {
        Event::BlockDelta(BlockDelta {
            index,
            delta: DeltaContent::Text(text.into()),
        })
    }

    /// テキストブロック停止イベントを作成
    pub fn text_block_stop(index: usize, stop_reason: Option<StopReason>) -> Self {
        Event::BlockStop(BlockStop {
            index,
            block_type: BlockType::Text,
            stop_reason,
        })
    }

    /// ツール使用ブロック開始イベントを作成
    pub fn tool_use_start(index: usize, id: impl Into<String>, name: impl Into<String>) -> Self {
        Event::BlockStart(BlockStart {
            index,
            block_type: BlockType::ToolUse,
            metadata: BlockMetadata::ToolUse {
                id: id.into(),
                name: name.into(),
            },
        })
    }

    /// ツール引数デルタイベントを作成
    pub fn tool_input_delta(index: usize, json: impl Into<String>) -> Self {
        Event::BlockDelta(BlockDelta {
            index,
            delta: DeltaContent::InputJson(json.into()),
        })
    }

    /// ツール使用ブロック停止イベントを作成
    pub fn tool_use_stop(index: usize) -> Self {
        Event::BlockStop(BlockStop {
            index,
            block_type: BlockType::ToolUse,
            stop_reason: Some(StopReason::ToolUse),
        })
    }

    /// 使用量イベントを作成
    pub fn usage(input_tokens: u64, output_tokens: u64) -> Self {
        Event::Usage(UsageEvent {
            input_tokens: Some(input_tokens),
            output_tokens: Some(output_tokens),
            total_tokens: Some(input_tokens + output_tokens),
            cache_read_input_tokens: None,
            cache_creation_input_tokens: None,
        })
    }

    /// Pingイベントを作成
    pub fn ping() -> Self {
        Event::Ping(PingEvent { timestamp: None })
    }
}

// =============================================================================
// Conversions: llm_client::event -> timeline::event
// =============================================================================

impl From<crate::llm_client::event::ResponseStatus> for ResponseStatus {
    fn from(value: crate::llm_client::event::ResponseStatus) -> Self {
        match value {
            crate::llm_client::event::ResponseStatus::Started => ResponseStatus::Started,
            crate::llm_client::event::ResponseStatus::Completed => ResponseStatus::Completed,
            crate::llm_client::event::ResponseStatus::Cancelled => ResponseStatus::Cancelled,
            crate::llm_client::event::ResponseStatus::Failed => ResponseStatus::Failed,
        }
    }
}

impl From<crate::llm_client::event::BlockType> for BlockType {
    fn from(value: crate::llm_client::event::BlockType) -> Self {
        match value {
            crate::llm_client::event::BlockType::Text => BlockType::Text,
            crate::llm_client::event::BlockType::Thinking => BlockType::Thinking,
            crate::llm_client::event::BlockType::ToolUse => BlockType::ToolUse,
            crate::llm_client::event::BlockType::ToolResult => BlockType::ToolResult,
        }
    }
}

impl From<crate::llm_client::event::BlockMetadata> for BlockMetadata {
    fn from(value: crate::llm_client::event::BlockMetadata) -> Self {
        match value {
            crate::llm_client::event::BlockMetadata::Text => BlockMetadata::Text,
            crate::llm_client::event::BlockMetadata::Thinking => BlockMetadata::Thinking,
            crate::llm_client::event::BlockMetadata::ToolUse { id, name } => {
                BlockMetadata::ToolUse { id, name }
            }
            crate::llm_client::event::BlockMetadata::ToolResult { tool_use_id } => {
                BlockMetadata::ToolResult { tool_use_id }
            }
        }
    }
}

impl From<crate::llm_client::event::DeltaContent> for DeltaContent {
    fn from(value: crate::llm_client::event::DeltaContent) -> Self {
        match value {
            crate::llm_client::event::DeltaContent::Text(text) => DeltaContent::Text(text),
            crate::llm_client::event::DeltaContent::Thinking(text) => DeltaContent::Thinking(text),
            crate::llm_client::event::DeltaContent::InputJson(json) => {
                DeltaContent::InputJson(json)
            }
        }
    }
}

impl From<crate::llm_client::event::StopReason> for StopReason {
    fn from(value: crate::llm_client::event::StopReason) -> Self {
        match value {
            crate::llm_client::event::StopReason::EndTurn => StopReason::EndTurn,
            crate::llm_client::event::StopReason::MaxTokens => StopReason::MaxTokens,
            crate::llm_client::event::StopReason::StopSequence => StopReason::StopSequence,
            crate::llm_client::event::StopReason::ToolUse => StopReason::ToolUse,
        }
    }
}

impl From<crate::llm_client::event::PingEvent> for PingEvent {
    fn from(value: crate::llm_client::event::PingEvent) -> Self {
        PingEvent {
            timestamp: value.timestamp,
        }
    }
}

impl From<crate::llm_client::event::UsageEvent> for UsageEvent {
    fn from(value: crate::llm_client::event::UsageEvent) -> Self {
        UsageEvent {
            input_tokens: value.input_tokens,
            output_tokens: value.output_tokens,
            total_tokens: value.total_tokens,
            cache_read_input_tokens: value.cache_read_input_tokens,
            cache_creation_input_tokens: value.cache_creation_input_tokens,
        }
    }
}

impl From<crate::llm_client::event::StatusEvent> for StatusEvent {
    fn from(value: crate::llm_client::event::StatusEvent) -> Self {
        StatusEvent {
            status: value.status.into(),
        }
    }
}

impl From<crate::llm_client::event::ErrorEvent> for ErrorEvent {
    fn from(value: crate::llm_client::event::ErrorEvent) -> Self {
        ErrorEvent {
            code: value.code,
            message: value.message,
        }
    }
}

impl From<crate::llm_client::event::BlockStart> for BlockStart {
    fn from(value: crate::llm_client::event::BlockStart) -> Self {
        BlockStart {
            index: value.index,
            block_type: value.block_type.into(),
            metadata: value.metadata.into(),
        }
    }
}

impl From<crate::llm_client::event::BlockDelta> for BlockDelta {
    fn from(value: crate::llm_client::event::BlockDelta) -> Self {
        BlockDelta {
            index: value.index,
            delta: value.delta.into(),
        }
    }
}

impl From<crate::llm_client::event::BlockStop> for BlockStop {
    fn from(value: crate::llm_client::event::BlockStop) -> Self {
        BlockStop {
            index: value.index,
            block_type: value.block_type.into(),
            stop_reason: value.stop_reason.map(Into::into),
        }
    }
}

impl From<crate::llm_client::event::BlockAbort> for BlockAbort {
    fn from(value: crate::llm_client::event::BlockAbort) -> Self {
        BlockAbort {
            index: value.index,
            block_type: value.block_type.into(),
            reason: value.reason,
        }
    }
}

impl From<crate::llm_client::event::Event> for Event {
    fn from(value: crate::llm_client::event::Event) -> Self {
        match value {
            crate::llm_client::event::Event::Ping(p) => Event::Ping(p.into()),
            crate::llm_client::event::Event::Usage(u) => Event::Usage(u.into()),
            crate::llm_client::event::Event::Status(s) => Event::Status(s.into()),
            crate::llm_client::event::Event::Error(e) => Event::Error(e.into()),
            crate::llm_client::event::Event::BlockStart(s) => Event::BlockStart(s.into()),
            crate::llm_client::event::Event::BlockDelta(d) => Event::BlockDelta(d.into()),
            crate::llm_client::event::Event::BlockStop(s) => Event::BlockStop(s.into()),
            crate::llm_client::event::Event::BlockAbort(a) => Event::BlockAbort(a.into()),
        }
    }
}