molo-core 0.4.0

Core protocol types and traits for molo
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

//! Step-wise agent action protocol shared by runtimes and harnesses.

use crate::effect::{EffectObservation, EffectRequest};
use crate::provider::{ChatRequest, ChatResponse};
use crate::run::{RunMetadata, RunOutput};

/// Provider request emitted by a step-wise agent kernel.
#[derive(Debug, Clone, PartialEq)]
pub struct ModelRequest {
    /// Model request id, unique within the run or agent implementation.
    pub id: String,
    /// Provider chat request to execute.
    pub chat: ChatRequest,
    /// Framework/application metadata.
    pub metadata: RunMetadata,
}

impl ModelRequest {
    /// Constructs a model request.
    pub fn new(id: impl Into<String>, chat: ChatRequest) -> Self {
        Self {
            id: id.into(),
            chat,
            metadata: RunMetadata::new(),
        }
    }

    /// Sets framework/application metadata.
    pub fn with_metadata(mut self, metadata: RunMetadata) -> Self {
        self.metadata = metadata;
        self
    }
}

/// Successful provider response observed by a step-wise agent kernel.
#[derive(Debug, Clone, PartialEq)]
pub struct ModelObservation {
    /// Model request id matching [`ModelRequest::id`].
    pub request_id: String,
    /// Provider response.
    pub response: ChatResponse,
    /// Framework/application metadata.
    pub metadata: RunMetadata,
}

impl ModelObservation {
    /// Constructs a model observation.
    pub fn new(request_id: impl Into<String>, response: ChatResponse) -> Self {
        Self {
            request_id: request_id.into(),
            response,
            metadata: RunMetadata::new(),
        }
    }

    /// Sets framework/application metadata.
    pub fn with_metadata(mut self, metadata: RunMetadata) -> Self {
        self.metadata = metadata;
        self
    }
}

/// Observation fed back to a step-wise agent kernel.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum Observation {
    /// Successful model response.
    Model(ModelObservation),
    /// Effect observation produced by an outer harness.
    Effect(EffectObservation),
    /// Batch effect observations produced by an outer harness.
    ///
    /// This is the companion to [`AgentAction::RequestEffects`]. The outer
    /// runtime may execute the requests sequentially or in parallel, then
    /// feeds the completed set back to the kernel as one step.
    Effects(Vec<EffectObservation>),
}

/// Next action requested by a step-wise agent kernel.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum AgentAction {
    /// The run is complete.
    Respond {
        /// Final structured run output.
        output: RunOutput,
    },
    /// The outer runtime should execute a provider request and feed back
    /// [`Observation::Model`].
    RequestModel {
        /// Provider request.
        request: ModelRequest,
    },
    /// The outer runtime should govern and execute an effect request, then
    /// feed back [`Observation::Effect`].
    RequestEffect {
        /// Effect request.
        request: EffectRequest,
    },
    /// The outer runtime should govern and execute multiple effect requests,
    /// then feed back [`Observation::Effects`].
    RequestEffects {
        /// Effect requests.
        requests: Vec<EffectRequest>,
    },
}