Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

codex: send the session identity on every request; reused sockets honor each request's abort (#3751)

kte2229869b719
diff --git a/crates/pa-agent/src/agent.rs b/crates/pa-agent/src/agent.rs
index eb859b3f04..9aab1587a1 100644
--- a/crates/pa-agent/src/agent.rs
+++ b/crates/pa-agent/src/agent.rs
@@ -101,6 +101,8 @@ pub struct AgentOptions {
pub steering_mode: Option<QueueMode>,
pub follow_up_mode: Option<QueueMode>,
pub session_id: Option<String>,
+ /// The transport every request of this agent asks for (TS `AgentOptions.transport`).
+ pub transport: Option<crate::types::Transport>,
pub tool_execution: Option<ToolExecutionMode>,
/// Heartbeat cadence for in-flight tool calls; `None` keeps the 60s
/// default tick.
@@ -347,6 +349,7 @@ struct AgentInner {
/// await.
model_override: Mutex<Option<AgentModelOverride>>,
session_id: Option<String>,
+ transport: Option<crate::types::Transport>,
tool_execution: ToolExecutionMode,
tool_progress: ToolProgressCadence,
}
@@ -563,6 +566,7 @@ impl AgentInner {
config.max_tokens = None;
config.reasoning = reasoning;
config.session_id.clone_from(&self.session_id);
+ config.transport = self.transport;
config.transform_context.clone_from(&self.transform_context);
config.get_api_key.clone_from(&self.get_api_key);
config.should_stop_after_turn = should_stop_after_turn;
@@ -800,6 +804,7 @@ impl Agent {
message_end_transform: Mutex::new(None),
model_override: Mutex::new(None),
session_id: options.session_id,
+ transport: options.transport,
tool_execution: options
.tool_execution
.unwrap_or(ToolExecutionMode::Parallel),
@@ -843,6 +848,12 @@ impl Agent {
.retain(|(listener_id, _)| *listener_id != id);
}
+ /// The session identity every request of this agent carries.
+ #[must_use]
+ pub fn session_id(&self) -> Option<&str> {
+ self.inner.session_id.as_deref()
+ }
+
pub async fn state(&self) -> AgentStateSnapshot {
let shared = self.inner.shared.lock().await;
AgentStateSnapshot {
diff --git a/crates/pa-agent/src/agent_loop/mod.rs b/crates/pa-agent/src/agent_loop/mod.rs
index a503a73eb6..221da3885d 100644
--- a/crates/pa-agent/src/agent_loop/mod.rs
+++ b/crates/pa-agent/src/agent_loop/mod.rs
@@ -96,6 +96,8 @@ pub struct AgentLoopConfig {
pub max_tokens: Option<u64>,
pub reasoning: ThinkingLevel,
pub session_id: Option<String>,
+ /// The requested provider transport; `None` leaves it to the provider.
+ pub transport: Option<crate::types::Transport>,
/// The requested service tier rides the loop config into every stream
/// request; `None` until a host supplies one.
pub service_tier: Option<crate::types::ServiceTier>,
@@ -127,6 +129,7 @@ impl AgentLoopConfig {
max_tokens: None,
reasoning: ThinkingLevel::Off,
session_id: None,
+ transport: None,
service_tier: None,
convert_to_llm,
transform_context: None,
diff --git a/crates/pa-agent/src/agent_loop/response.rs b/crates/pa-agent/src/agent_loop/response.rs
index a54352a440..25345d1286 100644
--- a/crates/pa-agent/src/agent_loop/response.rs
+++ b/crates/pa-agent/src/agent_loop/response.rs
@@ -135,6 +135,7 @@ async fn stream_assistant_response_inner(
max_tokens: config.max_tokens,
reasoning: config.reasoning,
session_id: config.session_id.clone(),
+ transport: config.transport,
service_tier: config.service_tier,
api_key: resolved_api_key,
signal: signal.cloned().unwrap_or_default(),
diff --git a/crates/pa-agent/src/stream.rs b/crates/pa-agent/src/stream.rs
index b87c54b1c7..c995d9b026 100644
--- a/crates/pa-agent/src/stream.rs
+++ b/crates/pa-agent/src/stream.rs
@@ -138,6 +138,8 @@ pub struct StreamRequestOptions {
pub max_tokens: Option<u64>,
pub reasoning: ThinkingLevel,
pub session_id: Option<String>,
+ /// The requested provider transport; `None` leaves it to the provider.
+ pub transport: Option<crate::types::Transport>,
/// The requested provider service tier; `None` means no tier request.
pub service_tier: Option<crate::types::ServiceTier>,
pub api_key: Option<String>,
@@ -156,6 +158,7 @@ impl std::fmt::Debug for StreamRequestOptions {
.field("max_tokens", &self.max_tokens)
.field("reasoning", &self.reasoning)
.field("session_id", &self.session_id)
+ .field("transport", &self.transport)
.field("service_tier", &self.service_tier)
.field("api_key", &self.api_key.as_ref().map(|_| "<set>"))
.field("signal", &self.signal)
@@ -173,6 +176,7 @@ impl Default for StreamRequestOptions {
max_tokens: None,
reasoning: ThinkingLevel::Off,
session_id: None,
+ transport: None,
service_tier: None,
api_key: None,
signal: crate::abort::AbortSignal::never(),
diff --git a/crates/pa-agent/src/types.rs b/crates/pa-agent/src/types.rs
index f05acc84b7..b90bcc4c0c 100644
--- a/crates/pa-agent/src/types.rs
+++ b/crates/pa-agent/src/types.rs
@@ -35,6 +35,17 @@ pub enum ServiceTier {
Priority,
}
+/// The requested provider transport (wire names match the shared AI
+/// package's). `None` leaves the choice to the provider.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum Transport {
+ Sse,
+ Websocket,
+ WebsocketCached,
+ Auto,
+}
+
/// How tool calls from one assistant message are executed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ToolExecutionMode {
diff --git a/crates/pa-ai/src/providers/openai_codex_responses/mod.rs b/crates/pa-ai/src/providers/openai_codex_responses/mod.rs
index 712bab1827..84c91f6e39 100644
--- a/crates/pa-ai/src/providers/openai_codex_responses/mod.rs
+++ b/crates/pa-ai/src/providers/openai_codex_responses/mod.rs
@@ -1536,4 +1536,64 @@ mod tests {
"the retry sends the full context: {bodies:?}"
);
}
+
+ /// A reused session WebSocket serves each request under that request's own abort signal
+ /// (#3618). The first request's token fires when its stream is dropped; the follow-up turn on
+ /// the same connection must still complete, chain onto the first response, and carry the same
+ /// session cache key.
+ #[tokio::test]
+ async fn reused_connection_follow_up_ignores_the_first_requests_cancelled_signal() {
+ let server = spawn_scripted_codex_server(vec![vec![
+ codex_response_events("resp_1", "msg_1", "Hello"),
+ codex_response_events("resp_2", "msg_2", "Done"),
+ ]])
+ .await;
+ let model = codex_test_model(server.port);
+ let session_id = format!("session-reuse-own-signal-{}", std::process::id());
+ let first_signal = tokio_util::sync::CancellationToken::new();
+ let mut first_options = codex_test_options(&server, &session_id);
+ first_options.base.signal = Some(first_signal.clone());
+ let first = stream_openai_codex_responses(
+ &model,
+ &codex_test_context("Say hello"),
+ Some(&first_options),
+ )
+ .result()
+ .await;
+ assert_eq!(codex_message_text(&first).as_deref(), Some("Hello"));
+ // The session layer cancels a finished request's token when its stream is dropped.
+ first_signal.cancel();
+
+ let mut second_options = codex_test_options(&server, &session_id);
+ second_options.base.signal = Some(tokio_util::sync::CancellationToken::new());
+ let second = stream_openai_codex_responses(
+ &model,
+ &codex_followup_context(&first, "Now finish"),
+ Some(&second_options),
+ )
+ .result()
+ .await;
+ assert_eq!(
+ (second.stop_reason, codex_message_text(&second).as_deref()),
+ (StopReason::Stop, Some("Done")),
+ "the follow-up completes: {:?}",
+ second.error_message
+ );
+
+ let bodies = server.sent_bodies.lock().expect("bodies").clone();
+ assert_eq!(
+ bodies.len(),
+ 2,
+ "both requests ride one connection: {bodies:?}"
+ );
+ assert_eq!(
+ bodies[1].get("previous_response_id"),
+ Some(&json!("resp_1"))
+ );
+ let cache_keys: Vec<_> = bodies
+ .iter()
+ .map(|body| body.get("prompt_cache_key").cloned())
+ .collect();
+ assert_eq!(cache_keys, vec![Some(json!(session_id)); 2]);
+ }
}
diff --git a/crates/pa-ai/src/providers/openai_codex_responses/websocket.rs b/crates/pa-ai/src/providers/openai_codex_responses/websocket.rs
index a1b8ff2937..1496ab9070 100644
--- a/crates/pa-ai/src/providers/openai_codex_responses/websocket.rs
+++ b/crates/pa-ai/src/providers/openai_codex_responses/websocket.rs
@@ -43,6 +43,10 @@ pub(crate) enum WorkerCommand {
Send {
body: String,
events: mpsc::Sender<WorkerEvent>,
+ /// This request's own abort signal. A reused connection outlives the request that opened
+ /// it, so the worker races each read against the current request's token, never the
+ /// opener's (which fires when that first request's stream is dropped).
+ signal: Option<CancellationToken>,
},
Close,
}
@@ -218,16 +222,12 @@ async fn spawn_connection_worker(
let connection_id = next_connection_id();
let (command_tx, command_rx) = mpsc::channel::<WorkerCommand>(4);
- tokio::spawn(connection_worker(stream, command_rx, signal));
+ tokio::spawn(connection_worker(stream, command_rx));
Ok((command_tx, connection_id))
}
/// The worker parks between requests so a session can reuse one connection.
-async fn connection_worker(
- stream: WsStream,
- mut commands: mpsc::Receiver<WorkerCommand>,
- signal: Option<CancellationToken>,
-) {
+async fn connection_worker(stream: WsStream, mut commands: mpsc::Receiver<WorkerCommand>) {
let (mut sink, mut stream) = stream.split();
loop {
let Some(command) = commands.recv().await else {
@@ -238,7 +238,11 @@ async fn connection_worker(
let _ = sink.close().await;
return;
}
- WorkerCommand::Send { body, events } => {
+ WorkerCommand::Send {
+ body,
+ events,
+ signal,
+ } => {
if sink.send(Message::Text(body.into())).await.is_err() {
// A dead socket surfaces through its close event (the TS runtime's send on a
// closed socket is a silent no-op; the close event carries the failure).
@@ -398,6 +402,7 @@ impl AcquiredConnection {
.send(WorkerCommand::Send {
body: request.to_string(),
events: event_tx,
+ signal,
})
.await
.map_err(|_| {
diff --git a/crates/pa-cli/src/print_goal.rs b/crates/pa-cli/src/print_goal.rs
index b8457aa319..649f9e7196 100644
--- a/crates/pa-cli/src/print_goal.rs
+++ b/crates/pa-cli/src/print_goal.rs
@@ -1264,16 +1264,16 @@ mod tests {
#[tokio::test]
async fn threshold_hold_mints_before_the_compaction_and_runs_after() {
let _guard = FAUX_TEST_LOCK.lock().await;
- // A small output budget keeps the 20k window's combined input+output
- // ceiling satisfiable (threshold 13_904 = window - 2_000 budget - 4_096
- // estimate floor).
+ // Include faux cache-write usage in the threshold: the resumed history
+ // crosses the 25_904 ceiling (32k - 2_000 output - 4_096 headroom),
+ // while the compacted continuation stays below it.
let mut model_script = script(
&json!([
"crossing reply",
"the compaction summary",
"continuation reply",
]),
- 20_000,
+ 32_000,
);
model_script["maxTokens"] = json!(2_000);
let bed = goal_bed_with_resumed_goal(
diff --git a/crates/pa-cli/tests/print_runtime_e2e.rs b/crates/pa-cli/tests/print_runtime_e2e.rs
index c71ad9e0b5..748474873e 100644
--- a/crates/pa-cli/tests/print_runtime_e2e.rs
+++ b/crates/pa-cli/tests/print_runtime_e2e.rs
@@ -807,11 +807,11 @@ fn print_mode_json_streams_the_threshold_compaction_pair() {
"compaction": { "enabled": true, "reserveTokens": 1, "keepRecentTokens": 10 }
}),
);
- // A small context window: the ~8.1k seed turn stays below the 15_808
- // ceiling (24k - 4_096 output - 4_096 headroom), and the ~12k-token
- // crossing turn pushes past it.
+ // The session-scoped faux cache counts the ~8.1k seed prompt as input
+ // plus cache-write tokens. It stays below the 23_808 ceiling (32k -
+ // 4_096 output - 4_096 headroom); the crossing turn exceeds it.
let script = serde_json::json!({
- "contextWindow": 24000,
+ "contextWindow": 32000,
"responses": [
{"text": "seed reply"},
{"text": "crossing reply"},
diff --git a/crates/pa-core/src/session_engine/engine.rs b/crates/pa-core/src/session_engine/engine.rs
index bdaf9ba6e8..783f1532e4 100644
--- a/crates/pa-core/src/session_engine/engine.rs
+++ b/crates/pa-core/src/session_engine/engine.rs
@@ -495,7 +495,7 @@ pub async fn create_session(mut config: SessionEngineConfig) -> anyhow::Result<S
let cell_timeout_ms =
super::runtime_wiring::arm_cell_timeout_ms(config.daemonless, python_cell_timeout_ms);
let provisioner = super::runtime_wiring::kernel_provisioner(
- session_id,
+ session_id.clone(),
handlers,
python_skills.clone(),
cwd.clone(),
@@ -697,6 +697,10 @@ pub async fn create_session(mut config: SessionEngineConfig) -> anyhow::Result<S
None => timing_stream_fn,
};
let agent = Agent::new(AgentOptions {
+ // Every request in the session carries this identity: providers key prompt caching
+ // (`prompt_cache_key`), session headers, and WebSocket/`previous_response_id` reuse on it
+ // (TS `sdk.ts` passes `sessionManager.getSessionId()`).
+ session_id: Some(session_id),
initial_state: AgentInitialState {
system_prompt: Some(system_prompt.clone()),
model: Some(model),
@@ -1023,7 +1027,13 @@ impl SessionEngine {
/// Tear the kernel down now with a final namespace snapshot, for a host that
/// ends the session but keeps the engine alive; dropping the engine tears the kernel down too.
+ /// The session's cached Codex WebSocket closes with it (TS `cleanupSessionResources` on
+ /// dispose), so a worker that replaces its session does not hold the old socket until the
+ /// idle expiry.
pub async fn dispose_kernel(&self) {
+ if let Some(session_id) = self.session.agent().session_id() {
+ pa_ai::codex_debug::close_websocket_sessions(Some(session_id));
+ }
self.provisioner.dispose(None).await;
}
diff --git a/crates/pa-core/src/session_engine/engine/tests.rs b/crates/pa-core/src/session_engine/engine/tests.rs
index a69e042525..462944fbfc 100644
--- a/crates/pa-core/src/session_engine/engine/tests.rs
+++ b/crates/pa-core/src/session_engine/engine/tests.rs
@@ -54,6 +54,15 @@ async fn engine_runs_tool_loop_and_persists() {
let tmp = tempfile::tempdir().unwrap();
let cwd = tmp.path().join("project");
std::fs::create_dir_all(&cwd).unwrap();
+ // Every request of the session carries the session's identity (#3618: the
+ // Codex prompt cache key, session headers, and WebSocket reuse key on it).
+ let observed_ids: Arc<std::sync::Mutex<Vec<Option<String>>>> = Arc::default();
+ let capture_ids = Arc::clone(&observed_ids);
+ let inner_stream = provider.stream_fn();
+ let stream: pa_agent::stream::StreamFn = Arc::new(move |model, context, options| {
+ capture_ids.lock().unwrap().push(options.session_id.clone());
+ inner_stream(model, context, options)
+ });
let engine = create_session(SessionEngineConfig {
on_late_sent_agent_message: None,
semantic_edges: None,
@@ -68,7 +77,7 @@ async fn engine_runs_tool_loop_and_persists() {
mcp_manager: None,
model: Some(model),
thinking_level: None,
- stream_fn: Some(provider.stream_fn()),
+ stream_fn: Some(stream),
tools: vec![bridge_tool(echo_definition())],
custom_system_prompt: None,
prompt_guidelines: vec![],
@@ -109,6 +118,11 @@ async fn engine_runs_tool_loop_and_persists() {
assert_eq!(outcome, PromptOutcome::Prompt);
engine.session.agent().wait_for_idle().await;
+ let expected_session_id = engine.session.session_id().await;
+ assert_eq!(
+ *observed_ids.lock().unwrap(),
+ vec![Some(expected_session_id); 2]
+ );
let state = engine.session.agent().state().await;
assert!(state.messages.iter().any(|message| match message {
pa_agent::types::AgentMessage::Standard(pa_agent::types::Message::ToolResult(result)) => {
diff --git a/crates/pa-core/src/session_engine/provider_adapter.rs b/crates/pa-core/src/session_engine/provider_adapter.rs
index d867365d4f..a73a643715 100644
--- a/crates/pa-core/src/session_engine/provider_adapter.rs
+++ b/crates/pa-core/src/session_engine/provider_adapter.rs
@@ -154,7 +154,9 @@ pub fn stream_once(
max_tokens: options.max_tokens,
signal: Some(cancel.clone()),
api_key,
- transport: None,
+ // A request that pins its transport (side questions ride SSE so they stay off the
+ // session's Codex socket and its continuation) carries it through.
+ transport: options.transport.as_ref().and_then(json_round_trip),
service_tier,
cache_retention: None,
session_id: options.session_id.clone(),
@@ -432,6 +434,49 @@ mod tests {
registration.unregister();
}
+ #[tokio::test]
+ async fn requested_transport_reaches_the_provider() {
+ let registration =
+ pa_ai::faux::register_faux_provider(pa_ai::faux::RegisterFauxProviderOptions {
+ api: Some("requested-transport-test".to_owned()),
+ ..Default::default()
+ });
+ let received = Arc::new(std::sync::Mutex::new(Vec::new()));
+ let captured = received.clone();
+ let factory = pa_ai::faux::FauxResponseStep::Factory(Arc::new(move |_, options, _, _| {
+ captured
+ .lock()
+ .unwrap()
+ .push(options.and_then(|options| options.transport));
+ Ok(pa_ai::faux::faux_assistant_text_message(
+ "ok",
+ pa_ai::faux::FauxAssistantMessageOptions::default(),
+ ))
+ }));
+ registration.set_responses(vec![factory.clone(), factory]);
+ let model = registration.get_model();
+ for transport in [Some(pa_agent::types::Transport::Sse), None] {
+ let mut stream = stream_once(
+ &model,
+ None,
+ None,
+ None,
+ LlmContext::default(),
+ StreamRequestOptions {
+ transport,
+ ..Default::default()
+ },
+ )
+ .unwrap();
+ stream.result().await.unwrap();
+ }
+ assert_eq!(
+ *received.lock().unwrap(),
+ vec![Some(pa_types::ai::Transport::Sse), None]
+ );
+ registration.unregister();
+ }
+
#[test]
fn prompt_text_message_round_trips() {
let message = pa_agent::types::AgentMessage::Standard(pa_agent::types::Message::User(
diff --git a/crates/pa-core/src/session_engine/side_question.rs b/crates/pa-core/src/session_engine/side_question.rs
index e95edcc58e..379ec6ccc5 100644
--- a/crates/pa-core/src/session_engine/side_question.rs
+++ b/crates/pa-core/src/session_engine/side_question.rs
@@ -193,6 +193,11 @@ pub async fn run_side_question(
stream_fn: Some(stream_fn),
before_tool_call: Some(before_tool_call),
should_stop_after_turn: Some(should_stop_after_turn),
+ // TS `side-question.ts`: the side call keeps the parent's identity so it reads the main
+ // conversation's prompt cache, and rides SSE so it never takes the session's Codex
+ // socket or its continuation.
+ session_id: parent.session_id().map(str::to_string),
+ transport: Some(pa_agent::types::Transport::Sse),
..Default::default()
}));
@@ -606,6 +611,49 @@ mod tests {
assert_eq!(parent.state().await.messages.len(), 2);
}
+ #[tokio::test]
+ async fn side_calls_keep_the_parent_identity_on_sse() {
+ let provider = Arc::new(ScriptedProvider::new(test_model()));
+ provider.push_text_turn("the side answer");
+ let parent = Arc::new(Agent::new(AgentOptions {
+ initial_state: AgentInitialState {
+ model: Some(test_model()),
+ ..Default::default()
+ },
+ session_id: Some("parent-session".to_string()),
+ ..Default::default()
+ }));
+ let observed = Arc::new(std::sync::Mutex::new(Vec::new()));
+ let capture = Arc::clone(&observed);
+ let inner = provider.stream_fn();
+ let stream_fn: pa_agent::stream::StreamFn = Arc::new(move |model, context, options| {
+ capture
+ .lock()
+ .unwrap()
+ .push((options.session_id.clone(), options.transport));
+ inner(model, context, options)
+ });
+ let sink: SideQuestionSink = Arc::new(|_| true);
+ let result = run_side_question(
+ &parent,
+ stream_fn,
+ "what is the answer?",
+ &[],
+ &fast_retry_policy(),
+ &AbortSignal::never(),
+ &sink,
+ )
+ .await;
+ assert_eq!(result.status, SideQuestionStatus::Complete);
+ assert_eq!(
+ *observed.lock().unwrap(),
+ vec![(
+ Some("parent-session".to_string()),
+ Some(pa_agent::types::Transport::Sse)
+ )]
+ );
+ }
+
#[tokio::test]
async fn previous_turns_replay_after_the_clone() {
let provider = Arc::new(ScriptedProvider::new(test_model()));
diff --git a/crates/pa-daemon/src/agent_engine/lifecycle.rs b/crates/pa-daemon/src/agent_engine/lifecycle.rs
index 9cfef0d8f5..a268a3ceb7 100644
--- a/crates/pa-daemon/src/agent_engine/lifecycle.rs
+++ b/crates/pa-daemon/src/agent_engine/lifecycle.rs
@@ -1054,7 +1054,7 @@ impl AgentSessionEngine {
// The engine session stays non-persisted (the worker owns the
// durable file); the configured session dir leads, the file's
// parent is the fallback.
- let session_manager = match self
+ let mut session_manager = match self
.config
.session_dir
.as_deref()
@@ -1068,6 +1068,19 @@ impl AgentSessionEngine {
}
None => pa_core::session::manager::SessionManager::in_memory(&cwd),
};
+ // The in-memory manager takes the durable file's header id, as TS's engine opened the
+ // durable file: provider requests key prompt caching, Codex socket reuse, and session
+ // headers on it, so it must survive a resume in a new worker, a replacement build, and
+ // a daemon restart. A pathless session keeps the manager's own id.
+ if let Some(header) = session_file
+ .as_deref()
+ .and_then(pa_core::session::manager::read_session_header)
+ {
+ session_manager.new_session(&pa_core::session::manager::NewSessionOptions {
+ id: Some(header.id),
+ ..Default::default()
+ });
+ }
if let Some(children) = &self.children {
children.set_model(format!("{}/{}", model.provider, model.id));
}
diff --git a/crates/pa-daemon/src/agent_engine/tests/session.rs b/crates/pa-daemon/src/agent_engine/tests/session.rs
index e74aae2ffd..4d451b7967 100644
--- a/crates/pa-daemon/src/agent_engine/tests/session.rs
+++ b/crates/pa-daemon/src/agent_engine/tests/session.rs
@@ -87,6 +87,61 @@ async fn get_commands_enumerates_skills_before_the_first_prompt() {
}
}
+/// The built engine carries the durable file's header id, not the in-memory
+/// manager's fresh one, and keeps it across a replacement build (#3618). The
+/// faux registry is process-global, so the whole test holds `FAUX_TEST_LOCK`
+/// and drives the async seams on the engine's own runtime.
+#[test]
+fn the_built_session_carries_the_durable_header_id_across_rebuilds() {
+ let _faux = FAUX_TEST_LOCK
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ let dir = tempfile::TempDir::new().unwrap();
+ let mut store =
+ crate::session_store::SessionFile::create(dir.path().to_str().unwrap_or("/tmp"), None, 0);
+ let durable_id = store.session_id().to_string();
+ let path = dir
+ .path()
+ .join(crate::session_store::session_file_name(&durable_id));
+ store.set_path(path.clone());
+ store.rewrite().unwrap();
+ let engine = AgentSessionEngine::new(AgentEngineConfig {
+ cwd: dir.path().to_path_buf(),
+ agent_dir: dir.path().join("agent"),
+ provider: None,
+ model: None,
+ api_key: None,
+ thinking: None,
+ session_dir: None,
+ session_file: Some(path),
+ faux_script: Some(json!({ "engine": "faux", "responses": [{ "text": "ok" }] }).to_string()),
+ supervisor_link: None,
+ telemetry_disabled: Some(true),
+ cron_store: None,
+ queued_steering_probe: None,
+ })
+ .unwrap();
+ let model = engine.resolve_model().expect("faux model");
+ for _ in 0..2 {
+ engine.runtime.block_on(async {
+ engine
+ .ensure_core_session_async(&model)
+ .await
+ .expect("build");
+ {
+ let session = engine.session.lock().await;
+ let built = session.as_deref().expect("built session");
+ assert_eq!(built.session.session_id().await, durable_id);
+ assert_eq!(
+ built.session.agent().session_id(),
+ Some(durable_id.as_str())
+ );
+ }
+ engine.retire_session_runtime().await;
+ });
+ }
+}
+
#[tokio::test]
async fn replacement_teardown_retires_the_session_and_the_funnel_adopts_the_branch() {
let engine = {