hehe-core 0.0.1

Core types, traits and utilities for hehe AI Agent framework
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use bytes::Bytes;
use camino::Utf8PathBuf;
use serde::{Deserialize, Serialize};
use url::Url;

use crate::error::Result;

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ResourceRef {
    #[serde(skip)]
    Inline(Bytes),
    Base64 { data: String },
    File { path: Utf8PathBuf },
    Url { url: Url },
    ContentAddress { hash: String },
}

impl ResourceRef {
    pub fn inline(data: impl Into<Bytes>) -> Self {
        Self::Inline(data.into())
    }

    pub fn base64(data: impl Into<String>) -> Self {
        Self::Base64 { data: data.into() }
    }

    pub fn file(path: impl Into<Utf8PathBuf>) -> Self {
        Self::File { path: path.into() }
    }

    pub fn url(url: Url) -> Self {
        Self::Url { url }
    }

    pub fn content_address(hash: impl Into<String>) -> Self {
        Self::ContentAddress { hash: hash.into() }
    }

    pub fn is_inline(&self) -> bool {
        matches!(self, Self::Inline(_) | Self::Base64 { .. })
    }

    pub fn is_remote(&self) -> bool {
        matches!(self, Self::Url { .. })
    }

    pub fn is_local(&self) -> bool {
        matches!(self, Self::File { .. })
    }
}

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct ResourceMeta {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filename: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub checksum: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding: Option<String>,
}

impl ResourceMeta {
    pub fn new() -> Self {
        Self::default()
    }

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

    pub fn with_size(mut self, size: u64) -> Self {
        self.size = Some(size);
        self
    }

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

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

#[derive(Clone, Debug)]
pub struct Resource {
    pub reference: ResourceRef,
    pub meta: ResourceMeta,
}

impl Resource {
    pub fn new(reference: ResourceRef) -> Self {
        Self {
            reference,
            meta: ResourceMeta::default(),
        }
    }

    pub fn with_meta(mut self, meta: ResourceMeta) -> Self {
        self.meta = meta;
        self
    }

    pub fn inline(data: impl Into<Bytes>) -> Self {
        Self::new(ResourceRef::inline(data))
    }

    pub fn from_base64(data: impl Into<String>) -> Self {
        Self::new(ResourceRef::base64(data))
    }

    pub fn from_file(path: impl Into<Utf8PathBuf>) -> Self {
        Self::new(ResourceRef::file(path))
    }

    pub fn from_url(url: Url) -> Self {
        Self::new(ResourceRef::url(url))
    }
}

#[async_trait::async_trait]
pub trait ResourceResolver: Send + Sync {
    async fn resolve(&self, resource: &ResourceRef) -> Result<Bytes>;
    async fn resolve_base64(&self, resource: &ResourceRef) -> Result<String>;
    async fn metadata(&self, resource: &ResourceRef) -> Result<ResourceMeta>;
}

#[async_trait::async_trait]
pub trait ResourceStore: Send + Sync {
    async fn store(&self, data: Bytes, meta: ResourceMeta) -> Result<String>;
    async fn get(&self, content_address: &str) -> Result<Option<Bytes>>;
    async fn exists(&self, content_address: &str) -> Result<bool>;
    async fn delete(&self, content_address: &str) -> Result<bool>;
}