1use 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 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 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 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}