stynx-code-bridge 3.3.2

Bridge layer for external integrations and data encoding
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

use async_trait::async_trait;
use stynx_code_errors::AppResult;
use crate::domain::bridge_types::{BridgeError, BridgeMessage, BridgeMethod};

#[async_trait]
pub trait BridgeMessageHandler: Send + Sync {
    async fn handle_message(&self, msg: BridgeMessage) -> AppResult<BridgeMessage>;
}

pub struct DefaultBridgeHandler;

#[async_trait]
impl BridgeMessageHandler for DefaultBridgeHandler {
    async fn handle_message(&self, msg: BridgeMessage) -> AppResult<BridgeMessage> {
        match msg {
            BridgeMessage::Request { id, method, params } => {
                tracing::debug!(?method, "handling bridge request");
                let result = match method {
                    BridgeMethod::Execute => {
                        tracing::info!("execute request received");
                        serde_json::json!({ "status": "accepted", "params": params })
                    }
                    BridgeMethod::Cancel => {
                        tracing::info!("cancel request received");
                        serde_json::json!({ "status": "cancelled" })
                    }
                    BridgeMethod::GetStatus => {
                        serde_json::json!({ "status": "running" })
                    }
                    BridgeMethod::PermissionPrompt => {
                        serde_json::json!({ "approved": true })
                    }
                    BridgeMethod::ToolResult => {
                        serde_json::json!({ "status": "received" })
                    }
                    BridgeMethod::SetContext => {
                        serde_json::json!({ "status": "ok" })
                    }
                };
                Ok(BridgeMessage::Response {
                    id,
                    result: Some(result),
                    error: None,
                })
            }
            BridgeMessage::Notification { method, .. } => {
                tracing::debug!(method, "received notification (no response)");
                Ok(BridgeMessage::Response {
                    id: String::new(),
                    result: None,
                    error: None,
                })
            }
            BridgeMessage::Response { id, .. } => {
                tracing::warn!(id, "received unexpected response message");
                Ok(BridgeMessage::Response {
                    id,
                    result: None,
                    error: Some(BridgeError {
                        code: -32600,
                        message: "unexpected response message".into(),
                    }),
                })
            }
        }
    }
}