agent-runtime-definition-builder 0.1.1

Internal immutable Agent definition builder
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

use async_trait::async_trait;
use runtime_extension_api::{
    ContextEvent, ContextHook, ContextPatch, ContextResource, ContextSensitivity, ContextSlot,
    ExtensionContext, ExtensionError,
};
use sha2::{Digest, Sha256};

use crate::DefinitionBuildError;

/// An immutable, always-active Skill backed by UTF-8 instructions.
///
/// Use `StaticSkill` when Skill content is known while the Definition is built.
/// Selectable or execution-mutating Skills should implement `ContextHook`
/// directly and keep their state keyed by `ExecutionId`.
pub struct StaticSkill {
    id: String,
    content: String,
    version: String,
    required: bool,
    sensitivity: ContextSensitivity,
    digest: String,
}

impl StaticSkill {
    pub fn new(
        id: impl Into<String>,
        content: impl Into<String>,
    ) -> Result<Self, DefinitionBuildError> {
        let id = id.into();
        let content = content.into();
        if id.trim().is_empty() || content.trim().is_empty() {
            return Err(DefinitionBuildError::InvalidSkill(
                "id and content must not be empty".into(),
            ));
        }
        let digest = format!("sha256:{:x}", Sha256::digest(content.as_bytes()));
        Ok(Self {
            id,
            content,
            version: "1".into(),
            required: false,
            sensitivity: ContextSensitivity::Internal,
            digest,
        })
    }

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

    pub fn required(mut self, value: bool) -> Self {
        self.required = value;
        self
    }

    pub fn sensitivity(mut self, value: ContextSensitivity) -> Self {
        self.sensitivity = value;
        self
    }
}

#[async_trait]
impl ContextHook for StaticSkill {
    fn name(&self) -> &str {
        &self.id
    }

    fn definition_fingerprint(&self) -> String {
        format!(
            "static-skill:{}:{}:{}:{:?}",
            self.version, self.digest, self.required, self.sensitivity
        )
    }

    async fn apply(
        &self,
        _: &ExtensionContext,
        _: &ContextEvent,
        _: &runtime_extension_api::ContextFrame,
    ) -> Result<ContextPatch, ExtensionError> {
        Ok(ContextPatch {
            resources: vec![ContextResource {
                id: self.id.clone(),
                slot: ContextSlot::Skills,
                source: format!("definition:skill:{}", self.id),
                content: self.content.clone(),
                required: self.required,
                sensitivity: self.sensitivity,
                version: self.version.clone(),
                digest: self.digest.clone(),
                estimated_tokens: self.content.len().div_ceil(4) as u64,
            }],
            ..ContextPatch::default()
        })
    }
}