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
//! Core agent traits and the default [`SessionAgent`] implementation.
//!
//! Most users do not implement an agent from scratch. The usual path is:
//!
//! 1. build a [`SessionAgent`] for your input/output types
//! 2. wrap it in your own struct
//! 3. derive [`Agent`](agents_proc_macros::Agent) to delegate the trait
//!
//! # String-in, string-out agent
//!
//! ```rust,no_run
//! use std::sync::Arc;
//!
//! use agents::{LlmRunner, SessionAgent};
//!
//! async fn make_agent(
//! llm: Arc<LlmRunner>,
//! ) -> anyhow::Result<SessionAgent<String, (), (), String>> {
//! Ok(SessionAgent::builder().with_llm_runner(llm).build()?)
//! }
//! ```
//!
//! # Wrapped typed agent
//!
//! ```rust,no_run
//! use std::sync::Arc;
//!
//! use agents::{Agent as AgentTrait, InputItem, LlmRunner, SessionAgent};
//! use schemars::JsonSchema;
//! use serde::{Deserialize, Serialize};
//!
//! #[derive(Clone, Serialize, Deserialize)]
//! struct EchoRequest {
//! text: String,
//! }
//!
//! impl From<EchoRequest> for InputItem {
//! fn from(value: EchoRequest) -> Self {
//! InputItem::user_text(value.text)
//! }
//! }
//!
//! #[derive(Clone, Serialize, Deserialize, JsonSchema)]
//! struct EchoResponse {
//! text: String,
//! }
//!
//! #[derive(agents::Agent)]
//! struct EchoAgent {
//! #[agent]
//! inner: SessionAgent<EchoRequest, (), (), EchoResponse>,
//! }
//!
//! impl EchoAgent {
//! async fn new(llm: Arc<LlmRunner>) -> anyhow::Result<Self> {
//! Ok(Self {
//! inner: SessionAgent::builder()
//! .with_llm_runner(llm)
//! .with_message_type::<EchoRequest>()
//! .with_response_type::<EchoResponse>()
//! .build()?,
//! })
//! }
//! }
//! ```
//pub use agents_proc_macros::Agent;
pub use ;
pub use ;
pub use ;
pub use ;
pub use ;