test(replay): add fixture-driven session replay harness

Adds a tiny OpenAI-compatible fixture server and a replay test that drives a full AgentRuntime session through a tool call.

Author: rexleimo

crates/rexos/tests/fixtures/replay/session_write_file.json

@@ -0,0 +1,37 @@
+[
+  {
+    "choices": [
+      {
+        "index": 0,
+        "message": {
+          "role": "assistant",
+          "content": null,
+          "tool_calls": [
+            {
+              "id": "call_1",
+              "type": "function",
+              "function": {
+                "name": "fs_write",
+                "arguments": "{\"path\":\"hello.txt\",\"content\":\"hello\"}"
+              }
+            }
+          ]
+        },
+        "finish_reason": "tool_calls"
+      }
+    ]
+  },
+  {
+    "choices": [
+      {
+        "index": 0,
+        "message": {
+          "role": "assistant",
+          "content": "done"
+        },
+        "finish_reason": "stop"
+      }
+    ]
+  }
+]
+

crates/rexos/tests/session_replay.rs

@@ -0,0 +1,96 @@
+use std::collections::BTreeMap;
+
+use rexos::config::{ProviderConfig, ProviderKind, RexosConfig, RouteConfig, RouterConfig};
+use rexos::paths::RexosPaths;
+use rexos::router::TaskKind;
+use rexos::security::SecurityConfig;
+
+mod support;
+
+#[tokio::test]
+async fn replay_fixture_drives_session_and_tool_calls() {
+    let fixture = support::openai_compat_fixture::load_json_array(include_str!(
+        "fixtures/replay/session_write_file.json"
+    ));
+    let server = support::openai_compat_fixture::FixtureServer::spawn(fixture).await;
+
+    let tmp = tempfile::tempdir().unwrap();
+    let paths = RexosPaths {
+        base_dir: tmp.path().join(".loopforge"),
+    };
+    paths.ensure_dirs().unwrap();
+
+    let workspace_root = tmp.path().join("workspace");
+    std::fs::create_dir_all(&workspace_root).unwrap();
+
+    let mut providers = BTreeMap::new();
+    providers.insert(
+        "fixture".to_string(),
+        ProviderConfig {
+            kind: ProviderKind::OpenAiCompatible,
+            base_url: server.base_url.clone(),
+            api_key_env: String::new(),
+            default_model: "fixture-model".to_string(),
+            aws_bedrock: None,
+        },
+    );
+
+    let security = SecurityConfig::default();
+    let cfg = RexosConfig {
+        llm: Default::default(),
+        providers,
+        router: RouterConfig {
+            planning: RouteConfig {
+                provider: "fixture".to_string(),
+                model: "fixture-model".to_string(),
+            },
+            coding: RouteConfig {
+                provider: "fixture".to_string(),
+                model: "fixture-model".to_string(),
+            },
+            summary: RouteConfig {
+                provider: "fixture".to_string(),
+                model: "fixture-model".to_string(),
+            },
+        },
+        security: security.clone(),
+    };
+
+    let llms = rexos::llm::registry::LlmRegistry::from_config(&cfg).unwrap();
+    let router = rexos::router::ModelRouter::new(cfg.router);
+    let memory = rexos::memory::MemoryStore::open_or_create(&paths).unwrap();
+    let agent =
+        rexos::agent::AgentRuntime::new_with_security_config(memory, llms, router, security);
+
+    let session_id = "s-replay";
+    agent
+        .set_session_allowed_tools(session_id, vec!["fs_write".to_string()])
+        .unwrap();
+
+    let out = agent
+        .run_session(
+            workspace_root.clone(),
+            session_id,
+            None,
+            "write hello.txt",
+            TaskKind::Coding,
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(out, "done");
+    assert_eq!(
+        std::fs::read_to_string(workspace_root.join("hello.txt")).unwrap(),
+        "hello"
+    );
+
+    let requests = server.requests.lock().unwrap().clone();
+    assert_eq!(requests.len(), 2, "expected two chat completions calls");
+    assert_eq!(requests[0]["messages"][0]["role"], "user");
+    assert_eq!(requests[1]["messages"][2]["role"], "tool");
+    assert_eq!(requests[1]["messages"][2]["name"], "fs_write");
+    assert_eq!(requests[1]["messages"][2]["tool_call_id"], "call_1");
+    assert_eq!(requests[1]["messages"][2]["content"], "ok");
+
+    server.abort();
+}

crates/rexos/tests/support/mod.rs

@@ -0,0 +1 @@
+pub mod openai_compat_fixture;

crates/rexos/tests/support/openai_compat_fixture.rs

@@ -0,0 +1,70 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+use axum::extract::State;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::routing::post;
+use axum::{Json, Router};
+use serde_json::{json, Value};
+
+#[derive(Clone)]
+struct FixtureState {
+    responses: Arc<Mutex<VecDeque<Value>>>,
+    requests: Arc<Mutex<Vec<Value>>>,
+}
+
+pub struct FixtureServer {
+    pub base_url: String,
+    pub requests: Arc<Mutex<Vec<Value>>>,
+    handle: tokio::task::JoinHandle<()>,
+}
+
+impl FixtureServer {
+    pub async fn spawn(responses: Vec<Value>) -> Self {
+        async fn handler(
+            State(state): State<FixtureState>,
+            Json(payload): Json<Value>,
+        ) -> impl IntoResponse {
+            state.requests.lock().unwrap().push(payload);
+            let next = state.responses.lock().unwrap().pop_front();
+            match next {
+                Some(value) => (StatusCode::OK, Json(value)).into_response(),
+                None => (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({ "error": "fixture exhausted" })),
+                )
+                    .into_response(),
+            }
+        }
+
+        let state = FixtureState {
+            responses: Arc::new(Mutex::new(responses.into())),
+            requests: Arc::new(Mutex::new(Vec::new())),
+        };
+
+        let app = Router::new()
+            .route("/v1/chat/completions", post(handler))
+            .with_state(state.clone());
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let handle = tokio::spawn(async move {
+            axum::serve(listener, app).await.unwrap();
+        });
+
+        Self {
+            base_url: format!("http://{addr}/v1"),
+            requests: state.requests,
+            handle,
+        }
+    }
+
+    pub fn abort(self) {
+        self.handle.abort();
+    }
+}
+
+pub fn load_json_array(raw: &str) -> Vec<Value> {
+    serde_json::from_str(raw).expect("fixture JSON array")
+}