gsm-core 0.4.12

Core types and platform abstractions for the Greentic messaging runtime.
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
143
144
145

use std::{collections::HashMap, sync::Arc};

use anyhow::Result;
use async_trait::async_trait;
use greentic_types::TenantCtx;
use time::OffsetDateTime;
use tokio::sync::RwLock;

/// In-memory representation of the WebChat conversation session.
#[derive(Clone, Debug)]
pub struct WebchatSession {
    pub conversation_id: String,
    pub tenant_ctx: TenantCtx,
    pub bearer_token: String,
    pub watermark: Option<String>,
    pub last_seen_at: OffsetDateTime,
    pub proactive_ok: bool,
}

impl WebchatSession {
    pub fn new(conversation_id: String, tenant_ctx: TenantCtx, bearer_token: String) -> Self {
        Self {
            conversation_id,
            tenant_ctx,
            bearer_token,
            watermark: None,
            last_seen_at: OffsetDateTime::now_utc(),
            proactive_ok: true,
        }
    }
}

#[async_trait]
pub trait WebchatSessionStore: Send + Sync {
    async fn get(&self, conversation_id: &str) -> Result<Option<WebchatSession>>;
    async fn upsert(&self, session: WebchatSession) -> Result<()>;
    async fn update_watermark(
        &self,
        conversation_id: &str,
        watermark: Option<String>,
    ) -> Result<()>;
    async fn update_bearer_token(&self, conversation_id: &str, token: String) -> Result<()>;
    async fn set_proactive(&self, conversation_id: &str, proactive_ok: bool) -> Result<()>;
    async fn list_by_tenant(
        &self,
        env: &str,
        tenant: &str,
        team: Option<&str>,
    ) -> Result<Vec<WebchatSession>>;
}

/// Simple in-memory session store used by the standalone server.
#[derive(Default)]
pub struct MemorySessionStore {
    inner: RwLock<HashMap<String, WebchatSession>>,
}

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

#[async_trait]
impl WebchatSessionStore for MemorySessionStore {
    async fn get(&self, conversation_id: &str) -> Result<Option<WebchatSession>> {
        let guard = self.inner.read().await;
        Ok(guard.get(conversation_id).cloned())
    }

    async fn upsert(&self, session: WebchatSession) -> Result<()> {
        let mut guard = self.inner.write().await;
        guard.insert(session.conversation_id.clone(), session);
        Ok(())
    }

    async fn update_watermark(
        &self,
        conversation_id: &str,
        watermark: Option<String>,
    ) -> Result<()> {
        let mut guard = self.inner.write().await;
        if let Some(existing) = guard.get_mut(conversation_id) {
            existing.watermark = watermark;
            existing.last_seen_at = OffsetDateTime::now_utc();
        }
        Ok(())
    }

    async fn update_bearer_token(&self, conversation_id: &str, token: String) -> Result<()> {
        let mut guard = self.inner.write().await;
        if let Some(existing) = guard.get_mut(conversation_id) {
            existing.bearer_token = token;
            existing.last_seen_at = OffsetDateTime::now_utc();
        }
        Ok(())
    }

    async fn set_proactive(&self, conversation_id: &str, proactive_ok: bool) -> Result<()> {
        let mut guard = self.inner.write().await;
        if let Some(existing) = guard.get_mut(conversation_id) {
            existing.proactive_ok = proactive_ok;
            existing.last_seen_at = OffsetDateTime::now_utc();
        }
        Ok(())
    }

    async fn list_by_tenant(
        &self,
        env: &str,
        tenant: &str,
        team: Option<&str>,
    ) -> Result<Vec<WebchatSession>> {
        let env_lower = env.to_ascii_lowercase();
        let tenant_lower = tenant.to_ascii_lowercase();
        let team_lower = team.map(|value| value.to_ascii_lowercase());

        let guard = self.inner.read().await;
        Ok(guard
            .values()
            .filter(|session| {
                session
                    .tenant_ctx
                    .env
                    .as_ref()
                    .eq_ignore_ascii_case(&env_lower)
                    && session
                        .tenant_ctx
                        .tenant
                        .as_ref()
                        .eq_ignore_ascii_case(&tenant_lower)
                    && match (&team_lower, session.tenant_ctx.team.as_ref()) {
                        (Some(expected), Some(actual)) => {
                            actual.as_ref().eq_ignore_ascii_case(expected)
                        }
                        (Some(_), None) => false,
                        (None, _) => true,
                    }
            })
            .cloned()
            .collect())
    }
}

pub type SharedSessionStore = Arc<dyn WebchatSessionStore>;