symbi-runtime 1.0.0

Agent Runtime System for the Symbi platform
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

//! HTTP Input configuration types
//!
//! This module defines configuration structures for HTTP input sources that invoke Symbiont agents.

#[cfg(feature = "http-input")]
use serde::{Deserialize, Serialize};

#[cfg(feature = "http-input")]
use crate::types::AgentId;

/// Configuration for HTTP input source that invokes Symbiont agents
#[cfg(feature = "http-input")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HttpInputConfig {
    /// Address to bind the HTTP server (e.g., "0.0.0.0" or "127.0.0.1")
    pub bind_address: String,

    /// Port number to listen on (e.g., 8081)
    pub port: u16,

    /// HTTP path to listen on (e.g., "/webhook", "/ingest")
    pub path: String,

    /// Default agent to invoke for all requests (can be overridden by routing rules)
    pub agent: AgentId,

    /// Optional static token for bearer authorization
    pub auth_header: Option<String>,

    /// Optional JWT public key path for JWT-based auth
    pub jwt_public_key_path: Option<String>,

    /// Maximum size of incoming request body in bytes
    pub max_body_bytes: usize,

    /// Max number of concurrent request-handling tasks
    pub concurrency: usize,

    /// Optional routing rules to determine agent by path or request content
    pub routing_rules: Option<Vec<AgentRoutingRule>>,

    /// Optional custom response formatters (agent → HTTP status + body)
    pub response_control: Option<ResponseControlConfig>,

    /// Optional headers to inject into agent input context
    pub forward_headers: Vec<String>,

    /// Optional CORS support for browser-facing apps
    pub cors_enabled: bool,

    /// Enable structured audit logging of all received events
    pub audit_enabled: bool,
}

#[cfg(feature = "http-input")]
impl Default for HttpInputConfig {
    fn default() -> Self {
        Self {
            bind_address: "0.0.0.0".to_string(),
            port: 8081,
            path: "/webhook".to_string(),
            agent: AgentId::new(),
            auth_header: None,
            jwt_public_key_path: None,
            max_body_bytes: 65536, // 64 KB
            concurrency: 10,
            routing_rules: None,
            response_control: None,
            forward_headers: vec![],
            cors_enabled: false,
            audit_enabled: true,
        }
    }
}

/// Rule to route an HTTP request to a specific agent based on path, header, or body field
#[cfg(feature = "http-input")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentRoutingRule {
    pub condition: RouteMatch,
    pub agent: AgentId,
}

/// Conditions for routing HTTP requests to specific agents
#[cfg(feature = "http-input")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RouteMatch {
    /// Match by URL path prefix (e.g., "/api/github")
    PathPrefix(String),
    /// Match by header name and value (e.g., ("X-Source", "slack"))
    HeaderEquals(String, String),
    /// Match by JSON field name and value (e.g., ("source", "twilio"))
    JsonFieldEquals(String, String),
}

/// Control what the HTTP response should return after agent execution
#[cfg(feature = "http-input")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponseControlConfig {
    /// Default HTTP status code for successful responses
    pub default_status: u16,
    /// Whether to include agent output as JSON in response body
    pub agent_output_to_json: bool,
    /// HTTP status code for error responses
    pub error_status: u16,
    /// Whether to echo the input request body on error
    pub echo_input_on_error: bool,
}

#[cfg(feature = "http-input")]
impl Default for ResponseControlConfig {
    fn default() -> Self {
        Self {
            default_status: 200,
            agent_output_to_json: true,
            error_status: 500,
            echo_input_on_error: false,
        }
    }
}