claude-agent 0.2.25

Rust SDK for building AI agents with Anthropic's Claude - Direct API, no CLI dependency
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Session message types.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

use super::ids::MessageId;
use crate::session::types::EnvironmentContext;
use crate::types::{ContentBlock, Message, Role, TokenUsage};

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct MessageMetadata {
    pub model: Option<String>,
    pub request_id: Option<String>,
    pub tool_results: Option<Vec<ToolResultMeta>>,
    pub thinking: Option<ThinkingMetadata>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ToolResultMeta {
    pub tool_use_id: String,
    pub tool_name: String,
    pub is_error: bool,
    pub duration_ms: Option<u64>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ThinkingMetadata {
    pub level: String,
    pub disabled: bool,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SessionMessage {
    pub id: MessageId,
    pub parent_id: Option<MessageId>,
    pub role: Role,
    pub content: Vec<ContentBlock>,
    #[serde(default)]
    pub is_sidechain: bool,
    #[serde(default)]
    pub is_compact_summary: bool,
    pub usage: Option<TokenUsage>,
    pub timestamp: DateTime<Utc>,
    #[serde(default)]
    pub metadata: MessageMetadata,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub environment: Option<EnvironmentContext>,
}

impl SessionMessage {
    pub fn user(content: Vec<ContentBlock>) -> Self {
        Self {
            id: MessageId::new(),
            parent_id: None,
            role: Role::User,
            content,
            is_sidechain: false,
            is_compact_summary: false,
            usage: None,
            timestamp: Utc::now(),
            metadata: MessageMetadata::default(),
            environment: None,
        }
    }

    pub fn assistant(content: Vec<ContentBlock>) -> Self {
        Self {
            id: MessageId::new(),
            parent_id: None,
            role: Role::Assistant,
            content,
            is_sidechain: false,
            is_compact_summary: false,
            usage: None,
            timestamp: Utc::now(),
            metadata: MessageMetadata::default(),
            environment: None,
        }
    }

    pub fn parent(mut self, parent_id: MessageId) -> Self {
        self.parent_id = Some(parent_id);
        self
    }

    pub fn usage(mut self, usage: TokenUsage) -> Self {
        self.usage = Some(usage);
        self
    }

    pub fn as_sidechain(mut self) -> Self {
        self.is_sidechain = true;
        self
    }

    pub fn as_compact_summary(mut self) -> Self {
        self.is_compact_summary = true;
        self
    }

    pub fn environment(mut self, env: EnvironmentContext) -> Self {
        self.environment = Some(env);
        self
    }

    pub fn model(mut self, model: impl Into<String>) -> Self {
        self.metadata.model = Some(model.into());
        self
    }

    pub fn request_id(mut self, request_id: impl Into<String>) -> Self {
        self.metadata.request_id = Some(request_id.into());
        self
    }

    pub fn to_api_message(&self) -> Message {
        Message {
            role: self.role,
            content: self.content.clone(),
        }
    }
}