Skip to main content

arabica_server/
lib.rs

1//! HTTP + SSE binding for the canonical Structure protocol.
2
3use std::collections::BTreeMap;
4use std::convert::Infallible;
5use std::path::PathBuf;
6use std::sync::Arc;
7
8use arabica_protocol::{CommandEnvelope, CommandFailure, EventEnvelope, protocol_schema};
9use arabica_provider::{
10    ApiProviderConfig, ApiType, BlendProvider, EchoModel, ModelProvider, ModelRunRequest,
11    ModelRunResult, ProviderError,
12};
13use arabica_runner::LocalRunner;
14use arabica_runtime::{
15    BlendRoutingPolicy, CoreRuntime, RuntimeArchiveStore, RuntimeCompactionStrategy,
16    ShortMemoryPolicy,
17};
18use arabica_session::{DispatchControl, SessionEventObserver, SessionManager};
19
20mod persistence;
21use axum::extract::State;
22use axum::http::StatusCode;
23use axum::response::sse::{Event as SseEvent, KeepAlive, Sse};
24use axum::routing::{get, post};
25use axum::{Json, Router};
26use futures_util::StreamExt;
27use persistence::Persistence;
28use serde::Deserialize;
29use tokio::sync::{Mutex, broadcast};
30use tokio_stream::wrappers::BroadcastStream;
31
32#[derive(Debug)]
33enum ServerModel {
34    Echo(EchoModel),
35    Blend(BlendProvider),
36}
37
38impl ModelProvider for ServerModel {
39    fn model_id(&self) -> Option<&str> {
40        match self {
41            Self::Echo(model) => model.model_id(),
42            Self::Blend(model) => model.model_id(),
43        }
44    }
45
46    fn model_registry_snapshot(&self) -> String {
47        match self {
48            Self::Blend(model) => model.model_registry_snapshot(),
49            Self::Echo(model) => model.model_registry_snapshot(),
50        }
51    }
52
53    fn supports_model_alias(&self, alias: &str) -> bool {
54        match self {
55            Self::Blend(model) => model.supports_model_alias(alias),
56            Self::Echo(model) => model.supports_model_alias(alias),
57        }
58    }
59
60    async fn complete(
61        &mut self,
62        request: ModelRunRequest,
63    ) -> Result<ModelRunResult, ProviderError> {
64        match self {
65            Self::Echo(model) => model.complete(request).await,
66            Self::Blend(model) => model.complete(request).await,
67        }
68    }
69
70    async fn complete_with_model(
71        &mut self,
72        request: ModelRunRequest,
73        model_alias: &str,
74    ) -> Result<ModelRunResult, ProviderError> {
75        match self {
76            Self::Blend(model) => model.complete_with_model(request, model_alias).await,
77            Self::Echo(model) => model.complete_with_model(request, model_alias).await,
78        }
79    }
80
81    async fn cancel(&mut self, run_id: &arabica_protocol::RunId) -> Result<bool, ProviderError> {
82        match self {
83            Self::Echo(model) => model.cancel(run_id).await,
84            Self::Blend(model) => model.cancel(run_id).await,
85        }
86    }
87}
88
89type LocalSessionManager = SessionManager<CoreRuntime<ServerModel, LocalRunner>>;
90
91const DEFAULT_ARCHIVE_ROOT: &str = "target/arabica-runtime-memory";
92
93fn local_file_archive_store() -> RuntimeArchiveStore {
94    let root = std::env::var("ARABICA__ARCHIVE_ROOT")
95        .map(PathBuf::from)
96        .unwrap_or_else(|_| PathBuf::from(DEFAULT_ARCHIVE_ROOT));
97    RuntimeArchiveStore::File { root }
98}
99
100#[derive(Debug, Deserialize)]
101#[serde(deny_unknown_fields)]
102struct EnvProviderConfig {
103    api_type: Option<String>,
104    base_url: String,
105    api_key_env: Option<String>,
106    max_tokens: Option<u32>,
107    thinking: Option<String>,
108    reasoning_effort: Option<String>,
109    request_timeout_secs: Option<u64>,
110    anthropic_cache_static_prefix: Option<bool>,
111}
112
113#[derive(Debug, Deserialize)]
114#[serde(deny_unknown_fields)]
115struct EnvModelConfig {
116    provider: String,
117    model_id: String,
118}
119
120fn provider_key_env(name: &str) -> String {
121    let suffix = name
122        .chars()
123        .map(|character| {
124            if character.is_ascii_alphanumeric() {
125                character.to_ascii_uppercase()
126            } else {
127                '_'
128            }
129        })
130        .collect::<String>();
131    format!("ARABICA_PROVIDER_{suffix}_API_KEY")
132}
133
134fn blend_from_json(
135    providers_json: &str,
136    models_json: &str,
137    default_alias: Option<String>,
138    lookup: impl Fn(&str) -> Option<String>,
139) -> Result<(BlendProvider, String), ProviderError> {
140    let providers = serde_json::from_str::<BTreeMap<String, EnvProviderConfig>>(providers_json)
141        .map_err(|_| ProviderError::new("invalid ARABICA__PROVIDERS_JSON"))?;
142    let models = serde_json::from_str::<BTreeMap<String, EnvModelConfig>>(models_json)
143        .map_err(|_| ProviderError::new("invalid ARABICA__BLEND_MODELS_JSON"))?;
144    if providers.is_empty() || models.is_empty() {
145        return Err(ProviderError::new(
146            "ARABICA__PROVIDERS_JSON and ARABICA__BLEND_MODELS_JSON must not be empty",
147        ));
148    }
149    let default_alias = default_alias
150        .unwrap_or_else(|| models.keys().next().expect("models are non-empty").clone());
151    let mut configs = BTreeMap::new();
152    for (alias, model) in models {
153        if alias.trim().is_empty()
154            || model.provider.trim().is_empty()
155            || model.model_id.trim().is_empty()
156        {
157            return Err(ProviderError::new(
158                "model alias, provider, and model_id must not be empty",
159            ));
160        }
161        let provider = providers.get(&model.provider).ok_or_else(|| {
162            ProviderError::new(format!(
163                "model alias {alias:?} references unknown provider {:?}",
164                model.provider
165            ))
166        })?;
167        if provider.base_url.trim().is_empty() {
168            return Err(ProviderError::new(format!(
169                "base_url is required for provider {:?}",
170                model.provider
171            )));
172        }
173        let api_type = provider
174            .api_type
175            .as_deref()
176            .unwrap_or("open_ai_chat_completions")
177            .parse::<ApiType>()?;
178        if provider.max_tokens == Some(0) || provider.request_timeout_secs == Some(0) {
179            return Err(ProviderError::new(format!(
180                "max_tokens and request_timeout_secs must be positive for provider {:?}",
181                model.provider
182            )));
183        }
184        if provider.reasoning_effort.is_some() && provider.thinking.is_some() {
185            return Err(ProviderError::new(format!(
186                "configure only one of thinking or reasoning_effort for provider {:?}",
187                model.provider
188            )));
189        }
190        if provider.anthropic_cache_static_prefix == Some(true)
191            && api_type != ApiType::AnthropicMessages
192        {
193            return Err(ProviderError::new(format!(
194                "anthropic_cache_static_prefix is only supported for Anthropic provider {:?}",
195                model.provider
196            )));
197        }
198        let key_env = provider
199            .api_key_env
200            .clone()
201            .unwrap_or_else(|| provider_key_env(&model.provider));
202        if key_env.trim().is_empty() {
203            return Err(ProviderError::new(format!(
204                "api_key_env must not be empty for provider {:?}",
205                model.provider
206            )));
207        }
208        let api_key = lookup(&key_env)
209            .filter(|key| !key.trim().is_empty())
210            .ok_or_else(|| {
211                ProviderError::new(format!(
212                    "API key is required for provider {:?}; set {key_env}",
213                    model.provider
214                ))
215            })?;
216        let mut config =
217            ApiProviderConfig::new(api_type, api_key, &provider.base_url, model.model_id);
218        config.max_tokens = provider.max_tokens;
219        config.request_timeout_secs = provider.request_timeout_secs.unwrap_or(300);
220        config.anthropic_cache_static_prefix =
221            provider.anthropic_cache_static_prefix.unwrap_or(false);
222        if let Some(effort) = provider.reasoning_effort.as_deref() {
223            match (api_type, effort) {
224                (ApiType::OpenAiResponses, level @ ("low" | "medium" | "high")) => {
225                    config.thinking_enabled = true;
226                    config.reasoning_effort = Some(level.to_owned());
227                }
228                _ => {
229                    return Err(ProviderError::new(format!(
230                        "unsupported reasoning_effort {effort:?} for {api_type}"
231                    )));
232                }
233            }
234        }
235        if let Some(thinking) = provider.thinking.as_deref() {
236            match (api_type, thinking) {
237                (_, "off") => {}
238                (ApiType::OpenAiChatCompletions, "on") => config.thinking_enabled = true,
239                (ApiType::OpenAiResponses, level @ ("low" | "medium" | "high")) => {
240                    config.thinking_enabled = true;
241                    config.reasoning_effort = Some(level.to_owned());
242                }
243                _ => {
244                    return Err(ProviderError::new(format!(
245                        "unsupported thinking level {thinking:?} for {api_type}"
246                    )));
247                }
248            }
249        }
250        configs.insert(alias, config);
251    }
252    let provider = BlendProvider::from_configs(default_alias.clone(), configs)?;
253    Ok((provider, default_alias))
254}
255
256#[derive(Clone)]
257pub struct AppState {
258    sessions: Arc<Mutex<LocalSessionManager>>,
259    events: broadcast::Sender<EventEnvelope>,
260    persistence: Option<Arc<Persistence>>,
261    evaluation_home: Option<PathBuf>,
262}
263
264impl Default for AppState {
265    fn default() -> Self {
266        let (events, _) = broadcast::channel(512);
267        let mut runtime = CoreRuntime::with_memory_configuration(
268            ServerModel::Echo(EchoModel::default()),
269            LocalRunner::new("."),
270            ShortMemoryPolicy::default(),
271            false,
272            local_file_archive_store(),
273        );
274        runtime.set_compaction_strategy(RuntimeCompactionStrategy::FileBackedGc);
275        runtime.set_async_file_backed_gc(true);
276        Self {
277            sessions: Arc::new(Mutex::new(SessionManager::with_ids(
278                runtime,
279                Box::new(persistence::UuidIds),
280            ))),
281            events,
282            persistence: None,
283            evaluation_home: None,
284        }
285    }
286}
287
288impl AppState {
289    /// Attach a persistence repository and restore sessions for this tool root.
290    /// The default echo state stays ephemeral so tests and embedders can opt in.
291    pub fn with_session_store(
292        mut self,
293        repository: Arc<dyn arabica_session::SessionStore>,
294        cwd: PathBuf,
295    ) -> Result<Self, ProviderError> {
296        let cwd =
297            std::fs::canonicalize(cwd).map_err(|error| ProviderError::new(error.to_string()))?;
298        let persistence = Arc::new(Persistence {
299            repository,
300            cwd,
301            stores: Default::default(),
302            failure: Default::default(),
303        });
304        let mut manager = self
305            .sessions
306            .try_lock()
307            .map_err(|error| ProviderError::new(error.to_string()))?;
308        // Persistence spans processes and tool roots, so counters are insufficient.
309        let listings = persistence
310            .repository
311            .list(None)
312            .map_err(|error| ProviderError::new(error.to_string()))?;
313        for listing in listings {
314            if std::path::Path::new(&listing.header.cwd) != persistence.cwd {
315                continue;
316            }
317            let store = persistence
318                .repository
319                .open(&listing.header.workspace_id, &listing.header.id)
320                .map_err(|error| ProviderError::new(error.to_string()))?;
321            let snapshot = persistence
322                .repository
323                .read(&listing.header.workspace_id, &listing.header.id)
324                .map_err(|error| ProviderError::new(error.to_string()))?
325                .into_snapshot();
326            manager
327                .restore_session(
328                    snapshot,
329                    arabica_protocol::CommandId::new(format!(
330                        "server-restore-{}",
331                        listing.header.id
332                    )),
333                    Some(store.as_ref()),
334                )
335                .map_err(|error| ProviderError::new(error.to_string()))?;
336            persistence
337                .stores
338                .lock()
339                .expect("store registry poisoned")
340                .insert(listing.header.id, store);
341        }
342        drop(manager);
343        self.persistence = Some(persistence);
344        Ok(self)
345    }
346
347    /// Explicitly opt in to reading a local host's persisted evaluations.
348    pub fn with_evaluation_home(mut self, home: PathBuf) -> Self {
349        self.evaluation_home = Some(home);
350        self
351    }
352    pub fn from_api_env() -> Result<Self, ProviderError> {
353        let tool_root = std::env::var("ARABICA__TOOL_ROOT").unwrap_or_else(|_| ".".to_owned());
354        let persistence_cwd = std::fs::canonicalize(&tool_root)
355            .map_err(|error| ProviderError::new(error.to_string()))?;
356        let providers_json = std::env::var("ARABICA__PROVIDERS_JSON")
357            .map_err(|_| ProviderError::new("ARABICA__PROVIDERS_JSON is required"))?;
358        let models_json = std::env::var("ARABICA__BLEND_MODELS_JSON")
359            .map_err(|_| ProviderError::new("ARABICA__BLEND_MODELS_JSON is required"))?;
360        let (provider, default_alias) = blend_from_json(
361            &providers_json,
362            &models_json,
363            std::env::var("ARABICA__BLEND_DEFAULT").ok(),
364            |name| std::env::var(name).ok(),
365        )?;
366        let recovery_after_no_progress_steps =
367            std::env::var("ARABICA__BLEND_RECOVERY_AFTER_NO_PROGRESS_STEPS")
368                .unwrap_or_else(|_| "2".to_owned())
369                .parse::<usize>()
370                .map_err(|error| {
371                    ProviderError::new(format!(
372                        "invalid ARABICA__BLEND_RECOVERY_AFTER_NO_PROGRESS_STEPS: {error}"
373                    ))
374                })?;
375        let policy = BlendRoutingPolicy {
376            policy_id: std::env::var("ARABICA__BLEND_POLICY_ID")
377                .unwrap_or_else(|_| "env-rules".to_owned()),
378            version: std::env::var("ARABICA__BLEND_POLICY_VERSION")
379                .unwrap_or_else(|_| "1".to_owned())
380                .parse::<u64>()
381                .map_err(|error| {
382                    ProviderError::new(format!("invalid ARABICA__BLEND_POLICY_VERSION: {error}"))
383                })?,
384            default_model: default_alias,
385            after_tool_success: std::env::var("ARABICA__BLEND_AFTER_TOOL_SUCCESS").ok(),
386            after_tool_error: std::env::var("ARABICA__BLEND_AFTER_TOOL_ERROR").ok(),
387            recovery_model: std::env::var("ARABICA__BLEND_RECOVERY_MODEL").ok(),
388            planning_model: None,
389            tool_routes: Vec::new(),
390            recovery_after_no_progress_steps,
391            minimum_model_dwell_steps: std::env::var("ARABICA__BLEND_MINIMUM_MODEL_DWELL_STEPS")
392                .unwrap_or_else(|_| "1".to_owned())
393                .parse::<usize>()
394                .map_err(|error| {
395                    ProviderError::new(format!(
396                        "invalid ARABICA__BLEND_MINIMUM_MODEL_DWELL_STEPS: {error}"
397                    ))
398                })?,
399            tool_call_capable_models: std::env::var("ARABICA__BLEND_TOOL_CALL_MODELS")
400                .unwrap_or_default()
401                .split(',')
402                .map(str::trim)
403                .filter(|alias| !alias.is_empty())
404                .map(str::to_owned)
405                .collect(),
406            typed_completion_capable_models: std::env::var(
407                "ARABICA__BLEND_TYPED_COMPLETION_MODELS",
408            )
409            .unwrap_or_default()
410            .split(',')
411            .map(str::trim)
412            .filter(|alias| !alias.is_empty())
413            .map(str::to_owned)
414            .collect(),
415        };
416        let (model, blend_policy) = (ServerModel::Blend(provider), Some(policy));
417        let compaction_strategy = match std::env::var("ARABICA__COMPACTION_STRATEGY")
418            .unwrap_or_else(|_| "file_backed_gc".to_owned())
419            .to_ascii_lowercase()
420            .as_str()
421        {
422            "disabled" => RuntimeCompactionStrategy::Disabled,
423            "pointer_gc" => RuntimeCompactionStrategy::PointerGc,
424            "file_backed_gc" | "fbgc" => RuntimeCompactionStrategy::FileBackedGc,
425            value => {
426                return Err(ProviderError::new(format!(
427                    "invalid ARABICA__COMPACTION_STRATEGY {value}; expected disabled, pointer_gc, or file_backed_gc"
428                )));
429            }
430        };
431        let pgc_effort = std::env::var("COMPACTION_EFFORT")
432            .or_else(|_| std::env::var("PGC_EFFORT"))
433            .unwrap_or_else(|_| "1".to_owned())
434            .parse::<usize>()
435            .map_err(|error| ProviderError::new(format!("invalid COMPACTION_EFFORT: {error}")))?;
436        if pgc_effort == 0 {
437            return Err(ProviderError::new("COMPACTION_EFFORT must be positive"));
438        }
439        let pgc_continuation_probability_bps = std::env::var("PGC_CONTINUATION_PROBABILITY_BPS")
440            .unwrap_or_else(|_| "7500".to_owned())
441            .parse::<u32>()
442            .map_err(|error| {
443                ProviderError::new(format!("invalid PGC_CONTINUATION_PROBABILITY_BPS: {error}"))
444            })?;
445        if pgc_continuation_probability_bps > 10_000 {
446            return Err(ProviderError::new(
447                "PGC_CONTINUATION_PROBABILITY_BPS must be between 0 and 10000",
448            ));
449        }
450        let mut runtime = CoreRuntime::with_memory_configuration(
451            model,
452            LocalRunner::new(tool_root),
453            ShortMemoryPolicy::default(),
454            false,
455            local_file_archive_store(),
456        );
457        if let Some(policy) = blend_policy {
458            runtime
459                .set_blend_policy(Some(policy))
460                .map_err(|error| ProviderError::new(error.to_string()))?;
461        }
462        runtime.set_compaction_strategy(compaction_strategy);
463        runtime.set_async_file_backed_gc(true);
464        runtime.set_pointer_gc_effort(pgc_effort);
465        runtime.set_pointer_gc_continuation_probability_bps(pgc_continuation_probability_bps);
466        let (events, _) = broadcast::channel(512);
467        let state = Self {
468            sessions: Arc::new(Mutex::new(SessionManager::with_ids(
469                runtime,
470                Box::new(persistence::UuidIds),
471            ))),
472            events,
473            persistence: None,
474            evaluation_home: std::env::var_os("ARABICA__EVALUATION_HOME").map(PathBuf::from),
475        };
476        let home = arabica_adapters::default_arabica_home()
477            .map_err(|error| ProviderError::new(error.to_string()))?;
478        state.with_session_store(
479            Arc::new(arabica_adapters::SqliteSessionRepository::new(home)),
480            persistence_cwd,
481        )
482    }
483}
484
485pub fn app(state: AppState) -> Router {
486    Router::new()
487        .route("/health", get(health))
488        .route("/v1/schema", get(schema))
489        .route("/v1/evaluations", get(query_evaluation))
490        .route("/v1/commands", post(submit_command))
491        .route("/v1/events", get(subscribe_events))
492        .with_state(state)
493}
494
495#[derive(serde::Deserialize)]
496#[serde(deny_unknown_fields)]
497struct EvaluationQuery {
498    workspace_id: arabica_protocol::WorkspaceId,
499    session_id: arabica_protocol::SessionId,
500}
501
502#[derive(serde::Serialize)]
503struct EvaluationQueryError {
504    code: &'static str,
505}
506
507async fn query_evaluation(
508    State(state): State<AppState>,
509    axum::extract::Query(query): axum::extract::Query<EvaluationQuery>,
510) -> Result<Json<arabica_adapters::EvaluationView>, (StatusCode, Json<EvaluationQueryError>)> {
511    let Some(home) = state.evaluation_home else {
512        return Err((
513            StatusCode::NOT_FOUND,
514            Json(EvaluationQueryError {
515                code: "evaluation_disabled",
516            }),
517        ));
518    };
519    tokio::task::spawn_blocking(move || {
520        let report = arabica_adapters::SqliteEvaluationStore::read_latest(
521            &home.join("evaluation.sqlite3"),
522            &query.workspace_id,
523            &query.session_id,
524        )
525        .map_err(|_| {
526            (
527                StatusCode::SERVICE_UNAVAILABLE,
528                Json(EvaluationQueryError {
529                    code: "evaluation_unavailable",
530                }),
531            )
532        })?;
533        Ok(Json(arabica_adapters::EvaluationView {
534            schema_version: 1,
535            workspace_id: query.workspace_id,
536            session_id: query.session_id,
537            worker_status: None,
538            refresh_accepted: None,
539            report,
540            policies: Vec::new(),
541        }))
542    })
543    .await
544    .map_err(|_| {
545        (
546            StatusCode::SERVICE_UNAVAILABLE,
547            Json(EvaluationQueryError {
548                code: "evaluation_unavailable",
549            }),
550        )
551    })?
552}
553
554async fn health() -> &'static str {
555    "ok"
556}
557
558async fn schema() -> Json<serde_json::Value> {
559    Json(serde_json::to_value(protocol_schema()).expect("protocol schema serializes"))
560}
561
562async fn submit_command(
563    State(state): State<AppState>,
564    Json(command): Json<CommandEnvelope>,
565) -> Result<Json<Vec<EventEnvelope>>, (StatusCode, Json<CommandFailure>)> {
566    let command_id = command.command_id.clone();
567    let events = state
568        .sessions
569        .lock()
570        .await
571        .dispatch(
572            command,
573            DispatchControl {
574                observer: state
575                    .persistence
576                    .as_ref()
577                    .map(|store| Arc::clone(store) as Arc<dyn SessionEventObserver>),
578                ..DispatchControl::default()
579            },
580        )
581        .await
582        .map_err(|error| {
583            (
584                StatusCode::UNPROCESSABLE_ENTITY,
585                Json(CommandFailure::new(
586                    command_id.clone(),
587                    error.code,
588                    error.message,
589                )),
590            )
591        })?;
592
593    if let Some(persistence) = &state.persistence
594        && let Some(message) = persistence
595            .failure
596            .lock()
597            .expect("persistence failure lock poisoned")
598            .as_ref()
599    {
600        return Err((
601            StatusCode::INTERNAL_SERVER_ERROR,
602            Json(CommandFailure::new(
603                command_id,
604                arabica_protocol::ErrorCode::RuntimeFailure,
605                format!("session persistence failed: {message}"),
606            )),
607        ));
608    }
609
610    for event in &events {
611        let _ = state.events.send(event.clone());
612    }
613    Ok(Json(events))
614}
615
616async fn subscribe_events(
617    State(state): State<AppState>,
618) -> Sse<impl futures_util::Stream<Item = Result<SseEvent, Infallible>>> {
619    let stream = BroadcastStream::new(state.events.subscribe()).filter_map(|message| async move {
620        match message {
621            Ok(event) => serde_json::to_string(&event)
622                .ok()
623                .map(|data| Ok(SseEvent::default().event("structure.event").data(data))),
624            Err(_) => None,
625        }
626    });
627    Sse::new(stream).keep_alive(KeepAlive::default())
628}
629
630#[cfg(test)]
631mod tests {
632    use super::*;
633    use arabica_protocol::{Command, CommandId, Event, WorkspaceId};
634    use axum::body::{Body, to_bytes};
635    use axum::http::Request;
636    use tower::ServiceExt;
637
638    #[test]
639    fn json_blend_config_builds_different_provider_dialects() {
640        let providers = r#"{
641            "openai": {"api_type":"open_ai_responses","base_url":"https://openai.example/v1","api_key_env":"OPENAI_KEY","max_tokens":2048,"thinking":"high"},
642            "anthropic": {"api_type":"anthropic_messages","base_url":"https://anthropic.example/v1","request_timeout_secs":90,"anthropic_cache_static_prefix":true}
643        }"#;
644        let models = r#"{
645            "fast": {"provider":"openai","model_id":"gpt-mini"},
646            "strong": {"provider":"anthropic","model_id":"claude-opus"}
647        }"#;
648        let (blend, default) = blend_from_json(
649            providers,
650            models,
651            Some("strong".to_owned()),
652            |name| match name {
653                "OPENAI_KEY" => Some("openai-env-key".to_owned()),
654                "ARABICA_PROVIDER_ANTHROPIC_API_KEY" => Some("anthropic-env-key".to_owned()),
655                _ => None,
656            },
657        )
658        .unwrap();
659
660        assert_eq!(default, "strong");
661        assert_eq!(blend.model_id(), Some("claude-opus"));
662        assert!(blend.supports_model_alias("fast"));
663        assert!(blend.supports_model_alias("strong"));
664        let snapshot = blend.model_registry_snapshot();
665        assert!(!snapshot.contains("env-key"));
666        assert!(!snapshot.contains("example"));
667    }
668
669    #[test]
670    fn json_blend_config_rejects_missing_credentials_and_provider_references() {
671        let providers = r#"{"p":{"base_url":"https://provider.example/v1"}}"#;
672        let models = r#"{"default":{"provider":"p","model_id":"model"}}"#;
673        let missing_key = blend_from_json(providers, models, None, |_| None).unwrap_err();
674        assert!(
675            missing_key
676                .to_string()
677                .contains("ARABICA_PROVIDER_P_API_KEY")
678        );
679
680        let unknown_provider = blend_from_json(
681            providers,
682            r#"{"default":{"provider":"missing","model_id":"model"}}"#,
683            None,
684            |_| Some("key".to_owned()),
685        )
686        .unwrap_err();
687        assert!(unknown_provider.to_string().contains("unknown provider"));
688    }
689
690    #[tokio::test]
691    async fn sqlite_sessions_survive_server_restart_and_ids_do_not_collide() {
692        let home = std::env::temp_dir().join(format!(
693            "arabica-server-sqlite-{}-{}",
694            std::process::id(),
695            std::time::SystemTime::now()
696                .duration_since(std::time::UNIX_EPOCH)
697                .unwrap()
698                .as_nanos()
699        ));
700        let cwd = std::fs::canonicalize(".").unwrap();
701        let state = AppState::default()
702            .with_session_store(
703                Arc::new(arabica_adapters::SqliteSessionRepository::new(home.clone())),
704                cwd.clone(),
705            )
706            .unwrap();
707        let created = submit_command(
708            State(state.clone()),
709            Json(CommandEnvelope::new(
710                CommandId::new("create"),
711                None,
712                Command::SessionCreate {
713                    workspace_id: WorkspaceId::new("server-test"),
714                },
715            )),
716        )
717        .await
718        .unwrap()
719        .0;
720        let session_id = created[0].session_id.clone();
721        let _ = submit_command(
722            State(state.clone()),
723            Json(CommandEnvelope::new(
724                CommandId::new("message"),
725                Some(session_id.clone()),
726                Command::MessageSend {
727                    images: Vec::new(),
728                    content: "Persistent title".to_owned(),
729                },
730            )),
731        )
732        .await
733        .unwrap();
734        drop(state);
735        let state = AppState::default()
736            .with_session_store(
737                Arc::new(arabica_adapters::SqliteSessionRepository::new(home.clone())),
738                cwd,
739            )
740            .unwrap();
741        assert!(state.sessions.lock().await.session(&session_id).is_some());
742        let created = submit_command(
743            State(state.clone()),
744            Json(CommandEnvelope::new(
745                CommandId::new("create-next"),
746                None,
747                Command::SessionCreate {
748                    workspace_id: WorkspaceId::new("server-test"),
749                },
750            )),
751        )
752        .await
753        .unwrap()
754        .0;
755        assert_ne!(created[0].session_id, session_id);
756        let stored = arabica_adapters::SqliteSessionStore::read_session(
757            &home,
758            &WorkspaceId::new("server-test"),
759            &session_id,
760        )
761        .unwrap();
762        assert_eq!(stored.header.title.as_deref(), Some("Persistent title"));
763        assert!(
764            stored
765                .events
766                .iter()
767                .any(|event| matches!(event.event, Event::RunCompleted { .. }))
768        );
769        drop(state);
770        std::fs::remove_dir_all(home).unwrap();
771    }
772
773    #[tokio::test]
774    async fn desktop_evaluation_query_does_not_lock_agent_or_create_database() {
775        use tower::ServiceExt;
776        let home =
777            std::env::temp_dir().join(format!("arabica-desktop-evaluation-{}", std::process::id()));
778        let state = AppState::default().with_evaluation_home(home.clone());
779        let _guard = state.sessions.lock().await;
780        let response = tokio::time::timeout(
781            std::time::Duration::from_secs(1),
782            app(state.clone()).oneshot(
783                axum::http::Request::builder()
784                    .uri("/v1/evaluations?workspace_id=workspace&session_id=session")
785                    .body(axum::body::Body::empty())
786                    .unwrap(),
787            ),
788        )
789        .await
790        .expect("evaluation query blocked on Agent session")
791        .unwrap();
792        assert_eq!(response.status(), StatusCode::OK);
793        let body = axum::body::to_bytes(response.into_body(), 1024 * 1024)
794            .await
795            .unwrap();
796        let view: serde_json::Value = serde_json::from_slice(&body).unwrap();
797        assert_eq!(view["schema_version"], 1);
798        assert!(view["report"].is_null());
799        assert!(!home.join("evaluation.sqlite3").exists());
800        let disabled = app(AppState::default())
801            .oneshot(
802                axum::http::Request::builder()
803                    .uri("/v1/evaluations?workspace_id=w&session_id=s")
804                    .body(axum::body::Body::empty())
805                    .unwrap(),
806            )
807            .await
808            .unwrap();
809        assert_eq!(disabled.status(), StatusCode::NOT_FOUND);
810    }
811
812    #[tokio::test]
813    async fn server_uses_the_local_file_archive_adapter() {
814        let state = AppState::default();
815        let sessions = state.sessions.lock().await;
816        assert!(matches!(
817            sessions.runtime().archive_store(),
818            RuntimeArchiveStore::File { .. }
819        ));
820    }
821
822    #[tokio::test]
823    async fn command_endpoint_returns_canonical_events() {
824        let command = CommandEnvelope::new(
825            CommandId::new("command-1"),
826            None,
827            Command::SessionCreate {
828                workspace_id: WorkspaceId::new("workspace-1"),
829            },
830        );
831        let response = app(AppState::default())
832            .oneshot(
833                Request::post("/v1/commands")
834                    .header("content-type", "application/json")
835                    .body(Body::from(
836                        serde_json::to_vec(&command).expect("command serializes"),
837                    ))
838                    .expect("request builds"),
839            )
840            .await
841            .expect("request succeeds");
842
843        assert_eq!(response.status(), StatusCode::OK);
844        let body = to_bytes(response.into_body(), 1024 * 1024)
845            .await
846            .expect("body is readable");
847        let events: Vec<EventEnvelope> = serde_json::from_slice(&body).expect("events deserialize");
848        assert!(matches!(events[0].event, Event::SessionCreated { .. }));
849        assert_eq!(events[0].sequence, 1);
850    }
851
852    #[tokio::test]
853    async fn invalid_protocol_version_returns_a_protocol_failure() {
854        let mut command = CommandEnvelope::new(
855            CommandId::new("command-1"),
856            None,
857            Command::SessionCreate {
858                workspace_id: WorkspaceId::new("workspace-1"),
859            },
860        );
861        command.protocol_version = "99".to_owned();
862        let response = app(AppState::default())
863            .oneshot(
864                Request::post("/v1/commands")
865                    .header("content-type", "application/json")
866                    .body(Body::from(
867                        serde_json::to_vec(&command).expect("command serializes"),
868                    ))
869                    .expect("request builds"),
870            )
871            .await
872            .expect("request succeeds");
873
874        assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
875        let body = to_bytes(response.into_body(), 1024 * 1024)
876            .await
877            .expect("body is readable");
878        let failure: CommandFailure = serde_json::from_slice(&body).expect("failure deserializes");
879        assert_eq!(failure.command_id, CommandId::new("command-1"));
880    }
881
882    #[tokio::test]
883    async fn schema_endpoint_exports_the_protocol_source_of_truth() {
884        let response = app(AppState::default())
885            .oneshot(
886                Request::get("/v1/schema")
887                    .body(Body::empty())
888                    .expect("request builds"),
889            )
890            .await
891            .expect("request succeeds");
892
893        assert_eq!(response.status(), StatusCode::OK);
894        let body = to_bytes(response.into_body(), 1024 * 1024)
895            .await
896            .expect("body is readable");
897        let schema: serde_json::Value = serde_json::from_slice(&body).expect("schema deserializes");
898        assert_eq!(schema["title"], "ProtocolSchemaDocument");
899        assert!(schema["$defs"]["CommandEnvelope"].is_object());
900        assert!(schema["$defs"]["EventEnvelope"].is_object());
901    }
902}