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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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<Slet 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<SNone => 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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 = {