behest 0.2.1

A Rust-native cloud agent runtime with typed tools, pluggable memory, queues, and observability.
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

//! Shared gRPC server state.

use std::sync::Arc;
use std::time::Instant;

use tokio::sync::RwLock;

use super::run::RunTaskRegistry;
use crate::agent::AgentRegistry;
#[cfg(any(feature = "openai", feature = "anthropic"))]
use crate::config::ProviderType;
use crate::config::{AgentConfig, ProviderConfig};
use crate::provider::{ModelName, ProviderId};
use crate::runtime::AgentRuntime;

/// JSON encodable model catalog entry.
#[derive(Debug, Clone)]
pub struct ModelCatalogEntry {
    /// Provider this model belongs to.
    pub provider: ProviderId,
    /// Model name.
    pub model: ModelName,
    /// Whether the model supports streaming.
    pub streaming: bool,
    /// Whether the model supports tool calling.
    pub tool_calling: bool,
}

/// Shared state for all gRPC services.
pub struct GrpcState {
    /// Agent runtime kernel.
    pub runtime: Arc<AgentRuntime>,
    /// Agent configuration (provider configs, store config, etc.).
    pub config: Arc<AgentConfig>,
    /// Server start time for uptime metrics.
    pub started_at: Instant,
    /// Active run task registry for cancellation and metrics.
    pub run_tasks: Arc<RunTaskRegistry>,
    /// Maximum number of concurrent runs (None = unlimited).
    pub max_concurrent_runs: Option<usize>,
    /// Agent registry for dynamic agent management.
    pub agent_registry: Arc<RwLock<AgentRegistry>>,
}

impl GrpcState {
    /// Creates a new gRPC state.
    #[must_use]
    pub fn new(
        runtime: Arc<AgentRuntime>,
        config: Arc<AgentConfig>,
        run_tasks: Arc<RunTaskRegistry>,
        max_concurrent_runs: Option<usize>,
    ) -> Self {
        Self {
            runtime,
            config,
            started_at: Instant::now(),
            run_tasks,
            max_concurrent_runs,
            agent_registry: Arc::new(RwLock::new(AgentRegistry::new())),
        }
    }

    /// Returns a provider config by string identifier.
    #[must_use]
    pub fn provider_config(&self, id: &str) -> Option<&ProviderConfig> {
        self.config
            .providers
            .iter()
            .find_map(|(k, v)| if k.as_str() == id { Some(v) } else { None })
    }

    /// Builds the model catalog from provider configs.
    #[must_use]
    pub fn model_catalog(&self) -> Vec<ModelCatalogEntry> {
        build_model_catalog(&self.config.providers)
    }
}

/// Builds a model catalog from provider configurations.
pub(crate) fn build_model_catalog(
    providers: &std::collections::HashMap<ProviderId, ProviderConfig>,
) -> Vec<ModelCatalogEntry> {
    let mut catalog = Vec::new();

    for (provider_id, cfg) in providers {
        let has_chat = match cfg.provider_type {
            #[cfg(feature = "openai")]
            Some(ProviderType::OpenAi) => true,
            #[cfg(feature = "anthropic")]
            Some(ProviderType::Anthropic) => true,
            None => false,
            #[allow(unreachable_patterns)]
            _ => false,
        };

        if let Some(ref default_model) = cfg.model {
            catalog.push(ModelCatalogEntry {
                provider: provider_id.clone(),
                model: default_model.clone(),
                streaming: has_chat,
                tool_calling: has_chat,
            });
        }

        for model in &cfg.models {
            catalog.push(ModelCatalogEntry {
                provider: provider_id.clone(),
                model: model.clone(),
                streaming: has_chat,
                tool_calling: has_chat,
            });
        }
    }

    catalog
}