diff --git a/crates/pa-core/src/mcp/manager_catalog/tests.rs b/crates/pa-core/src/mcp/manager_catalog/tests.rs
index afa080c9b..d338a8ec7 100644
--- a/crates/pa-core/src/mcp/manager_catalog/tests.rs
+++ b/crates/pa-core/src/mcp/manager_catalog/tests.rs
@@ -764,7 +764,7 @@ fn api_key_credential_views_see_a_cross_instance_write_after_the_reload() {
"the cached copy does not see the other instance's write"
);
// The view open's reload picks the stored key up.
- manager.reload_auth_storage();
+ manager.reload_auth_storage().expect("the reload applies");
assert!(
manager
.api_key_credential_views()
diff --git a/crates/pa-core/src/mcp/mod.rs b/crates/pa-core/src/mcp/mod.rs
index a38107e9e..18529b006 100644
--- a/crates/pa-core/src/mcp/mod.rs
+++ b/crates/pa-core/src/mcp/mod.rs
@@ -357,11 +357,24 @@ impl McpManager {
/// runtime): a credential another process wrote — the interactive
/// client's `/mcp` key flow stores through its own storage instance —
/// becomes visible to the next view read, like the settings re-read
- /// above.
- pub fn reload_auth_storage(&mut self) {
+ /// above. The reload's failure surfaces to the caller: a malformed
+ /// document or a lock that could not be acquired leaves the manager
+ /// serving its previous credentials, and a successful reload must
+ /// not be reported over that.
+ ///
+ /// # Errors
+ ///
+ /// Returns the storage reload's error when the document cannot be
+ /// read or parsed (a malformed `auth.json`, an unacquirable lock):
+ /// the manager keeps its previous credentials in that case.
+ pub fn reload_auth_storage(&mut self) -> Result<(), String> {
let storage = self.auth_storage.clone();
let mut handle = storage.blocking_lock();
handle.reload();
+ match handle.load_error() {
+ Some(error) => Err(error.to_string()),
+ None => Ok(()),
+ }
}
/// The resolved integrations (login resolution and status displays).
diff --git a/crates/pa-daemon/src/agent_engine.rs b/crates/pa-daemon/src/agent_engine.rs
index 02f366ddd..3d60c705f 100644
--- a/crates/pa-daemon/src/agent_engine.rs
+++ b/crates/pa-daemon/src/agent_engine.rs
@@ -71,6 +71,7 @@ pub(crate) use config::CreateSessionResources;
pub use config::SupervisorLinkConfig;
use config::{GoalRuntimeHandles, ProducerUsageSink, RestoredSessionModel, StartupScope};
+mod reload;
mod session_engine_impl;
mod turn;
@@ -285,6 +286,13 @@ pub struct AgentSessionEngine {
/// every model-turn attempt so retries keep serving it; cleared when the
/// episode settles.
pub(crate) image_route: std::sync::Mutex>,
+ /// Serializes `/reload`'s whole live-input refresh: overlapping reloads
+ /// resolve the store at their own read times, so an earlier reload's
+ /// already-resolved key/header pair must never land over a later
+ /// reload's fresher pair (the last reload to run leaves the target
+ /// serving the newest store).
+ pub(crate) reload_lock: std::sync::Mutex<()>,
+
/// Turn-boundary runs register their controller here;
/// [`SessionEngine::abort_auto_compaction`] aborts whatever holds it.
pub(crate) auto_compaction_abort: std::sync::Mutex >>,
diff --git a/crates/pa-daemon/src/agent_engine/lifecycle.rs b/crates/pa-daemon/src/agent_engine/lifecycle.rs
index 7f434b551..7c75a2acb 100644
--- a/crates/pa-daemon/src/agent_engine/lifecycle.rs
+++ b/crates/pa-daemon/src/agent_engine/lifecycle.rs
@@ -164,6 +164,7 @@ impl AgentSessionEngine {
pending_branch: std::sync::Mutex::new(None),
provider_target: std::sync::Arc::new(std::sync::RwLock::new(None)),
image_route: std::sync::Mutex::new(None),
+ reload_lock: std::sync::Mutex::new(()),
own_summary: std::sync::Arc::new(std::sync::Mutex::new(None)),
create_resources: std::sync::RwLock::default(),
autonomous: std::sync::Arc::new(tokio::sync::Mutex::new(
@@ -875,6 +876,30 @@ impl AgentSessionEngine {
// rebuild.
let stream_fn = switchable_stream_fn(std::sync::Arc::clone(&self.provider_target));
{
+ // The build's resolve-and-install serializes with `/reload`'s
+ // live-input refresh (the other slot writers' fence): a reload
+ // landing between this resolution and the slot write must not
+ // be clobbered by the build's older pair. The lock is
+ // acquired by yielding, never by blocking this worker: a
+ // reload holds the lock across auth-file I/O and a possible
+ // OAuth refresh, so a blocking acquire on an async path
+ // would stall the executor for that span.
+ let _reload_serialized = loop {
+ match self.reload_lock.try_lock() {
+ Ok(guard) => break guard,
+ Err(std::sync::TryLockError::WouldBlock) => {}
+ // The poisoned error CARRIES the acquired guard (the
+ // panicking holder is gone, the lock is free): recover
+ // it — a fresh .lock() here would wait on the guard
+ // this match's scrutinee still holds.
+ Err(std::sync::TryLockError::Poisoned(poison)) => break poison.into_inner(),
+ }
+ // Park, never hot-spin: a reload holds the lock across
+ // auth-file I/O and a possible OAuth refresh, and
+ // yield_now would leave this task immediately runnable
+ // through all of it.
+ tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+ };
let (api_key, headers) = self.resolve_request_key_and_headers(model);
let mut target = self.provider_target.write().expect("provider target lock");
*target = Some(ProviderTarget {
diff --git a/crates/pa-daemon/src/agent_engine/model.rs b/crates/pa-daemon/src/agent_engine/model.rs
index 2977f5fc2..c980cf037 100644
--- a/crates/pa-daemon/src/agent_engine/model.rs
+++ b/crates/pa-daemon/src/agent_engine/model.rs
@@ -371,18 +371,53 @@ impl AgentSessionEngine {
) -> (
Option,
Option>,
+ ) {
+ let (api_key, headers, _store_healthy) =
+ self.resolve_request_key_and_headers_and_store_health(model);
+ (api_key, headers)
+ }
+
+ /// [`Self::resolve_request_key_and_headers`] plus whether the
+ /// resolution serves a live credential for the model's provider on a
+ /// healthy read — stored, or the ambient environment/runtime override
+ /// (a logout that empties the store leaves the session on the env
+ /// key, exactly like a fresh resolution). `false` means the resolved
+ /// key is the configured `models.json` fallback — served when the
+ /// store is unreadable OR resolves no credential from any live
+ /// source — which is not a credential and must never replace a
+ /// serving pair (the create-config override is source-independent;
+ /// callers apply it themselves).
+ pub(crate) fn resolve_request_key_and_headers_and_store_health(
+ &self,
+ model: &Model,
+ ) -> (
+ Option,
+ Option>,
+ bool,
) {
let auth = pa_core::auth::AuthStorage::create(&self.config.agent_dir);
+ let store_healthy = auth.load_error().is_none();
let mut registry =
pa_core::models::ModelRegistry::create(auth, self.config.agent_dir.join("models.json"));
let resolved = registry.get_api_key_and_headers(model, model.headers.as_ref());
+ // The credential check runs AFTER the resolution: the registry's
+ // lookup may OAuth-refresh and store a fresh token, so a check
+ // before it would read the stale one and discard the fresh pair.
+ let stored_credential = registry
+ .auth
+ .get_api_key_with_source_token(&model.provider, false)
+ .api_key
+ .is_some();
+ let store_auth = store_healthy && stored_credential;
if let Some(api_key) = &self.current_selection().api_key {
// The create-config key override pins the key, never the headers:
// the registry's merged headers still ship, exactly like the TS
- // `getApiKeyAndHeaders` override path.
- return (Some(api_key.clone()), resolved.headers);
+ // `getApiKeyAndHeaders` override path. The flag stays the
+ // store's: a caller pairing the override key with headers
+ // keeps its last-good headers when the store cannot serve.
+ return (Some(api_key.clone()), resolved.headers, store_auth);
}
- (resolved.api_key, resolved.headers)
+ (resolved.api_key, resolved.headers, store_auth)
}
pub(crate) fn resolve_request_api_key(&self, model: &Model) -> Option {
@@ -396,6 +431,45 @@ impl AgentSessionEngine {
.get_api_key_and_headers(model, model.headers.as_ref())
.api_key
}
+
+ /// The primary target a failover episode restores: the captured model
+ /// with the request auth RE-RESOLVED from the store. The captured
+ /// pair only backs the restore when the store cannot serve a live
+ /// credential; the create-config key override stands in memory
+ /// regardless, keeping the captured headers off a failed read.
+ pub(crate) fn restored_primary_target(
+ &self,
+ primary: &Model,
+ captured_api_key: Option,
+ captured_headers: Option>,
+ ) -> pa_core::session_engine::provider_adapter::ProviderTarget {
+ let override_key = self.current_selection().api_key;
+ let (api_key, headers, store_auth) =
+ self.resolve_request_key_and_headers_and_store_health(primary);
+ // The capture backs the restore whenever the store cannot serve a
+ // live credential (a failed read, or a healthy store with nothing
+ // stored — both resolve the configured `models.json` fallback key,
+ // which is not a credential); a live stored credential REPLACES
+ // the pair, headers included.
+ let (api_key, headers) = if let Some(override_key) = override_key {
+ if store_auth {
+ (Some(override_key), headers)
+ } else {
+ (Some(override_key), captured_headers.or(headers))
+ }
+ } else {
+ match api_key {
+ Some(api_key) if store_auth => (Some(api_key), headers),
+ _ => (captured_api_key, captured_headers),
+ }
+ };
+ pa_core::session_engine::provider_adapter::ProviderTarget {
+ service_tier: *self.service_tier.read().expect("service tier lock"),
+ api_key,
+ model: primary.clone(),
+ headers,
+ }
+ }
}
/// The saved model context of a session file: the pinned `(provider,
diff --git a/crates/pa-daemon/src/agent_engine/reload.rs b/crates/pa-daemon/src/agent_engine/reload.rs
new file mode 100644
index 000000000..d10267cfa
--- /dev/null
+++ b/crates/pa-daemon/src/agent_engine/reload.rs
@@ -0,0 +1,121 @@
+//! The session's live-input reload (`/reload`'s daemon half): re-read the
+//! request auth from the credential store and the MCP manager's settings
+//! and auth state — the pieces another process (a `/login`, a `/mcp` key
+//! flow) can change under a running session.
+use super::AgentSessionEngine;
+use pa_core::session_engine::provider_adapter::ProviderTarget;
+
+impl AgentSessionEngine {
+ /// The stored request auth for the target's OWN model, applied in
+ /// place: only the key and headers change, and only when the
+ /// resolution serves a live credential for the model's provider —
+ /// stored, or the ambient environment/runtime override (a logout
+ /// that empties the store leaves the session on the env key, like a
+ /// fresh resolution). The configured `models.json` fallback key —
+ /// what the resolution serves when the store is unreadable OR
+ /// resolves no credential from any live source — is not a credential
+ /// and never replaces what the target already serves with. A
+ /// resolved credential REPLACES the pair: its headers land even when
+ /// it carries none, so a rotated credential without a team header
+ /// clears the previous credential's `X-Prime-Team-ID` instead of
+ /// serving it on the new key.
+ fn refresh_request_auth(&self, target: &mut ProviderTarget) {
+ let (api_key, headers, store_auth) =
+ self.resolve_request_key_and_headers_and_store_health(&target.model);
+ if store_auth {
+ if let Some(api_key) = api_key {
+ target.api_key = Some(api_key);
+ target.headers = headers;
+ }
+ }
+ }
+
+ /// `/reload`'s session half: re-read the live inputs another process
+ /// may have changed — the request auth from the credential store
+ /// (rebinding the live target and an armed image route's pair in
+ /// place: the model and service tier never change), and the MCP
+ /// manager's settings and auth state. A rebind lands only off live
+ /// STORE auth (stored, or the ambient environment/runtime override);
+ /// the configured `models.json` fallback key never replaces a
+ /// last-good pair. A failed auth-store read fails the reload before
+ /// any target is touched.
+ pub(crate) fn reload_live_inputs(&self) -> Result<(), String> {
+ // The whole refresh is serialized against every other
+ // resolve-and-install (the session's reload lock): overlapping
+ // writers resolve the store at their own read times, so the last
+ // writer to run must be the one leaving the newest store.
+ let _serialized = self
+ .reload_lock
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ // The auth store re-read gates the rebinds below: the settings
+ // re-read still applies on a failed reload.
+ {
+ let mut manager = self
+ .mcp
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ let auth_reload = manager.reload_auth_storage();
+ manager.refresh();
+ auth_reload?;
+ }
+ // The armed route refreshes FIRST, the live slot SECOND: the
+ // route lock fences the route's clone-and-install against this
+ // refresh order (an attempt either installs the refreshed route
+ // or lands before the slot refresh — never over it), and the
+ // route's saved session target is the fallback a later
+ // `clear_image_route` restores when resolution fails, so its auth
+ // re-binds from the same store read.
+ if let Some(route) = self
+ .image_route
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .as_mut()
+ {
+ self.refresh_request_auth(&mut route.target);
+ if let Some(saved) = route.session_target.as_mut() {
+ self.refresh_request_auth(saved);
+ }
+ }
+ let live_model = self
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .as_ref()
+ .map(|target| target.model.clone());
+ if let Some(model) = live_model {
+ let (api_key, headers, store_auth) =
+ self.resolve_request_key_and_headers_and_store_health(&model);
+ if store_auth {
+ let mut slot = self
+ .provider_target
+ .write()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ if let Some(target) = slot.as_mut() {
+ // The model may have moved under the store read: a
+ // switch or route swap installed a new target. The
+ // auth then re-resolves for whatever is live NOW,
+ // under the same gate; a cleared slot stays cleared.
+ let (api_key, headers) = if target.model == model {
+ (api_key, headers)
+ } else {
+ match self.resolve_request_key_and_headers_and_store_health(&target.model) {
+ (Some(key), headers, true) => (Some(key), headers),
+ // The moved-to model's provider has no live
+ // stored credential: the target keeps its
+ // last-good pair.
+ _ => (None, None),
+ }
+ };
+ // A resolved credential replaces the pair: headers
+ // clear when the fresh credential carries none.
+ if let Some(api_key) = api_key {
+ target.api_key = Some(api_key);
+ target.headers = headers;
+ }
+ }
+ }
+ }
+ Ok(())
+ }
+}
diff --git a/crates/pa-daemon/src/agent_engine/session_engine_impl.rs b/crates/pa-daemon/src/agent_engine/session_engine_impl.rs
index 53d238765..dd3a5a3f9 100644
--- a/crates/pa-daemon/src/agent_engine/session_engine_impl.rs
+++ b/crates/pa-daemon/src/agent_engine/session_engine_impl.rs
@@ -414,6 +414,14 @@ impl SessionEngine for AgentSessionEngine {
return false;
};
{
+ // The switch's resolve-and-install serializes with `/reload`'s
+ // live-input refresh (the failover callbacks' fence): a reload
+ // landing between this resolution and the slot write must not
+ // be clobbered by the switch's older pair.
+ let _reload_serialized = self
+ .reload_lock
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
let (api_key, headers) = self.resolve_request_key_and_headers(&model);
let mut target = self.provider_target.write().expect("provider target lock");
*target = Some(ProviderTarget {
diff --git a/crates/pa-daemon/src/agent_engine/tests.rs b/crates/pa-daemon/src/agent_engine/tests.rs
index eae8a650b..78ce6a5e7 100644
--- a/crates/pa-daemon/src/agent_engine/tests.rs
+++ b/crates/pa-daemon/src/agent_engine/tests.rs
@@ -13,6 +13,7 @@ mod compaction;
mod goal;
mod model_resolution;
mod quota_park;
+mod reload;
mod rlm_children;
mod saved_context;
mod session;
diff --git a/crates/pa-daemon/src/agent_engine/tests/reload.rs b/crates/pa-daemon/src/agent_engine/tests/reload.rs
new file mode 100644
index 000000000..55f6462b1
--- /dev/null
+++ b/crates/pa-daemon/src/agent_engine/tests/reload.rs
@@ -0,0 +1,729 @@
+//! `/reload`'s session half: the request auth rebinds from the credential
+//! store, the store a `/login` from another process writes.
+use super::*;
+use pa_core::session_engine::provider_adapter::ProviderTarget;
+
+/// A custom provider whose configured key is a placeholder: the stored
+/// credential wins over it, so the request auth follows the store (the
+/// re-login scenario the reload must cover).
+fn write_credential_backed_provider(agent_dir: &std::path::Path) {
+ std::fs::create_dir_all(agent_dir).unwrap();
+ std::fs::write(
+ agent_dir.join("models.json"),
+ serde_json::json!({
+ "providers": {
+ "battery": {
+ "api": "openai-completions",
+ "baseUrl": "http://127.0.0.1:9",
+ "apiKey": "sk-config-fallback",
+ "models": [
+ {
+ "id": "mock-1",
+ "name": "Mock 1",
+ "api": "openai-completions",
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ }
+ ]
+ }
+ }
+ })
+ .to_string(),
+ )
+ .unwrap();
+}
+
+/// One stored OAuth credential for the custom provider.
+fn write_oauth_credential(agent_dir: &std::path::Path, access: &str) {
+ std::fs::create_dir_all(agent_dir).unwrap();
+ std::fs::write(
+ agent_dir.join("auth.json"),
+ serde_json::json!({
+ "battery": {
+ "type": "oauth",
+ "access": access,
+ "refresh": "r",
+ "expires": 4_102_444_800_000i64,
+ }
+ })
+ .to_string(),
+ )
+ .unwrap();
+}
+
+fn credential_backed_engine_with_override(
+ dir: &std::path::Path,
+ api_key: Option<&str>,
+) -> AgentSessionEngine {
+ AgentSessionEngine::new(AgentEngineConfig {
+ cwd: dir.to_path_buf(),
+ agent_dir: dir.join("agent"),
+ provider: Some("battery".to_string()),
+ model: Some("mock-1".to_string()),
+ api_key: api_key.map(str::to_string),
+ thinking: None,
+ session_dir: None,
+ session_file: None,
+ faux_script: None,
+ supervisor_link: None,
+ telemetry_disabled: Some(true),
+ cron_store: None,
+ queued_steering_probe: None,
+ })
+ .expect("engine")
+}
+
+fn credential_backed_engine(dir: &std::path::Path) -> AgentSessionEngine {
+ AgentSessionEngine::new(AgentEngineConfig {
+ cwd: dir.to_path_buf(),
+ agent_dir: dir.join("agent"),
+ provider: Some("battery".to_string()),
+ model: Some("mock-1".to_string()),
+ api_key: None,
+ thinking: None,
+ session_dir: None,
+ session_file: None,
+ faux_script: None,
+ supervisor_link: None,
+ telemetry_disabled: Some(true),
+ cron_store: None,
+ queued_steering_probe: None,
+ })
+ .expect("engine")
+}
+
+/// A credential another process wrote (the `/login` scenario) reaches the
+/// running session through the reload: the provider target rebinds.
+#[test]
+fn reload_rebinds_the_request_auth_from_the_credential_store() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_credential_backed_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "stale-access");
+ let engine = credential_backed_engine(dir.path());
+ let model = engine.resolve_model().expect("the custom model resolves");
+ // The session's build-time target: the credential the engine saw.
+ *engine
+ .provider_target
+ .write()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(ProviderTarget {
+ service_tier: None,
+ api_key: Some("stale-access".to_string()),
+ model,
+ headers: None,
+ });
+ // A re-login from another process replaces the stored credential.
+ write_oauth_credential(&agent_dir, "fresh-access");
+ engine.reload_live_inputs().expect("the reload applies");
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the reload keeps the target set");
+ assert_eq!(
+ target.api_key.as_deref(),
+ Some("fresh-access"),
+ "the reload rebinds the request auth to the fresh stored credential"
+ );
+}
+
+/// With nothing stored for the live model the reload keeps the slot
+/// untouched (a models.json lost mid-session loses nothing) — the MCP
+/// re-read alone still runs.
+#[test]
+fn reload_with_nothing_stored_keeps_the_target() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ std::fs::create_dir_all(&agent_dir).unwrap();
+ let engine = credential_backed_engine(dir.path());
+ assert!(
+ engine.resolve_model().is_err(),
+ "no models.json: nothing resolves"
+ );
+ let model: pa_types::ai::Model =
+ pa_core::session_engine::provider_adapter::json_round_trip(&serde_json::json!({
+ "id": "mock-1",
+ "name": "Mock 1",
+ "api": "openai-completions",
+ "provider": "battery",
+ "baseUrl": "http://127.0.0.1:9",
+ "reasoning": false,
+ "input": ["text"],
+ "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ }))
+ .expect("the model converts");
+ *engine
+ .provider_target
+ .write()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(ProviderTarget {
+ service_tier: None,
+ api_key: Some("stale-access".to_string()),
+ model,
+ headers: None,
+ });
+ engine.reload_live_inputs().expect("the reload applies");
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the target stays");
+ assert_eq!(
+ target.api_key.as_deref(),
+ Some("stale-access"),
+ "an unresolvable model leaves the target untouched"
+ );
+}
+
+/// The two-model pair the retarget guard uses: the text model the
+/// selection pins and a second model standing in for a routed episode's
+/// serving target.
+fn write_two_model_provider(agent_dir: &std::path::Path) {
+ std::fs::create_dir_all(agent_dir).unwrap();
+ std::fs::write(
+ agent_dir.join("models.json"),
+ serde_json::json!({
+ "providers": {
+ "battery": {
+ "api": "openai-completions",
+ "baseUrl": "http://127.0.0.1:9",
+ "apiKey": "sk-config-fallback",
+ "models": [
+ {
+ "id": "mock-1",
+ "name": "Mock 1",
+ "api": "openai-completions",
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ },
+ {
+ "id": "mock-vision",
+ "name": "Mock Vision",
+ "api": "openai-completions",
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ }
+ ]
+ }
+ }
+ })
+ .to_string(),
+ )
+ .unwrap();
+}
+
+/// The live model never retargets through a reload: a routed image
+/// episode serves on its own target and an unflagged session must not
+/// follow a changed settings default — only the request auth rebinds.
+#[test]
+fn reload_keeps_the_live_model_and_rebinds_its_auth() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_two_model_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "fresh-access");
+ let engine = credential_backed_engine(dir.path());
+ // The selection pins mock-1; the slot holds a routed episode's target
+ // on a DIFFERENT model.
+ let session_model = engine.resolve_model().expect("the pinned model resolves");
+ assert_eq!(session_model.id, "mock-1");
+ let routed: pa_types::ai::Model =
+ pa_core::session_engine::provider_adapter::json_round_trip(&serde_json::json!({
+ "id": "mock-vision",
+ "name": "Mock Vision",
+ "api": "openai-completions",
+ "provider": "battery",
+ "baseUrl": "http://127.0.0.1:9",
+ "reasoning": false,
+ "input": ["text"],
+ "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ }))
+ .expect("the routed model converts");
+ *engine
+ .provider_target
+ .write()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(ProviderTarget {
+ service_tier: None,
+ api_key: Some("stale-access".to_string()),
+ model: routed,
+ headers: None,
+ });
+ engine.reload_live_inputs().expect("the reload applies");
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the reload keeps the target set");
+ assert_eq!(
+ target.model.id, "mock-vision",
+ "the reload never retargets the live model"
+ );
+ assert_eq!(
+ target.api_key.as_deref(),
+ Some("fresh-access"),
+ "the live model's request auth rebinds from the store"
+ );
+}
+
+/// Before the session's first build there is no live target to refresh:
+/// the reload installs nothing (the build binds its own target) — the MCP
+/// re-read alone runs.
+#[test]
+fn reload_without_a_live_target_installs_nothing() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_credential_backed_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "fresh-access");
+ let engine = credential_backed_engine(dir.path());
+ engine.reload_live_inputs().expect("the reload applies");
+ assert!(
+ engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .is_none(),
+ "the reload never installs a target"
+ );
+}
+
+/// A routed image episode re-applies its armed target on every model-turn
+/// attempt (overflow retries, failover restores): the reload must refresh
+/// the armed route's auth too, or the next attempt reinstalls the stale
+/// credentials a re-login just replaced.
+#[test]
+fn reload_refreshes_the_armed_image_route_target_auth() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_two_model_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "fresh-access");
+ let engine = credential_backed_engine(dir.path());
+ let session_model = engine.resolve_model().expect("the pinned model resolves");
+ let routed: pa_types::ai::Model =
+ pa_core::session_engine::provider_adapter::json_round_trip(&serde_json::json!({
+ "id": "mock-vision",
+ "name": "Mock Vision",
+ "api": "openai-completions",
+ "provider": "battery",
+ "baseUrl": "http://127.0.0.1:9",
+ "reasoning": false,
+ "input": ["text"],
+ "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ }))
+ .expect("the routed model converts");
+ let override_model: pa_agent::types::Model =
+ pa_core::session_engine::provider_adapter::json_round_trip(&routed)
+ .expect("the override model converts");
+ *engine
+ .image_route
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) =
+ Some(crate::image_route::ImageRoute {
+ target: ProviderTarget {
+ service_tier: None,
+ api_key: Some("stale-access".to_string()),
+ model: routed,
+ headers: None,
+ },
+ agent_override: pa_agent::agent::AgentModelOverride {
+ model: override_model,
+ thinking_level: pa_agent::types::ThinkingLevel::default(),
+ },
+ // The saved session target a failing route clear restores: it
+ // carries the pre-login key and must re-bind with the rest.
+ session_target: Some(ProviderTarget {
+ service_tier: None,
+ api_key: Some("stale-session-access".to_string()),
+ model: session_model,
+ headers: None,
+ }),
+ });
+ engine.reload_live_inputs().expect("the reload applies");
+ let armed = engine
+ .image_route
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .take()
+ .expect("the reload keeps the armed route");
+ assert_eq!(
+ armed.target.model.id, "mock-vision",
+ "the armed route keeps its routed model"
+ );
+ assert_eq!(
+ armed.target.api_key.as_deref(),
+ Some("fresh-access"),
+ "the armed route's request auth rebinds from the store"
+ );
+ let saved = armed
+ .session_target
+ .as_ref()
+ .expect("the saved session target stays");
+ assert_eq!(
+ saved.api_key.as_deref(),
+ Some("fresh-access"),
+ "the saved session target's request auth rebinds from the store"
+ );
+}
+
+/// A failover's primary restore re-resolves the request auth from the
+/// store: a credential rotated (and reloaded) during the failover serves
+/// from the store, never the pre-failover capture; the capture only backs
+/// a resolution that yields nothing.
+#[test]
+fn restored_primary_target_serves_the_store_auth() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_credential_backed_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "fresh-access");
+ let engine = credential_backed_engine(dir.path());
+ let primary = engine.resolve_model().expect("the primary resolves");
+ let restored =
+ engine.restored_primary_target(&primary, Some("stale-capture".to_string()), None);
+ assert_eq!(
+ restored.api_key.as_deref(),
+ Some("fresh-access"),
+ "the restored primary serves the stored credential"
+ );
+ assert_eq!(
+ restored.model.id, primary.id,
+ "the restore keeps the primary model"
+ );
+
+ // A provider with nothing configured anywhere: the capture backs the
+ // restore, not an empty key.
+ let ghost: pa_types::ai::Model =
+ pa_core::session_engine::provider_adapter::json_round_trip(&serde_json::json!({
+ "id": "ghost-1",
+ "name": "Ghost 1",
+ "api": "openai-completions",
+ "provider": "ghost",
+ "baseUrl": "http://127.0.0.1:9",
+ "reasoning": false,
+ "input": ["text"],
+ "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ }))
+ .expect("the ghost model converts");
+ let restored = engine.restored_primary_target(&ghost, Some("stale-capture".to_string()), None);
+ assert_eq!(
+ restored.api_key.as_deref(),
+ Some("stale-capture"),
+ "a resolution that yields nothing falls back to the capture"
+ );
+
+ // An unreadable store keeps the captured pair: the fresh resolution
+ // would serve the configured fallback key, which is not a credential
+ // — the same overwrite /reload's gate avoids.
+ std::fs::write(agent_dir.join("auth.json"), "not json").unwrap();
+ let restored = engine.restored_primary_target(
+ &primary,
+ Some("captured-key".to_string()),
+ Some(team_headers("captured-team")),
+ );
+ assert!(
+ restored.api_key.as_deref() == Some("captured-key"),
+ "a failed store read keeps the last-good captured key"
+ );
+ assert!(
+ restored.headers.as_ref() == Some(&team_headers("captured-team")),
+ "a failed store read keeps the last-good captured headers"
+ );
+}
+
+/// A custom `prime-inference` provider: the one provider whose stored
+/// credentials can carry request headers (the team header), so the
+/// reload's header replacement is observable against a real resolution.
+fn write_prime_inference_provider(agent_dir: &std::path::Path) {
+ std::fs::create_dir_all(agent_dir).unwrap();
+ std::fs::write(
+ agent_dir.join("models.json"),
+ serde_json::json!({
+ "providers": {
+ "prime-inference": {
+ "api": "openai-completions",
+ "baseUrl": "http://127.0.0.1:9",
+ "apiKey": "sk-config-fallback",
+ "models": [
+ {
+ "id": "mock-1",
+ "name": "Mock 1",
+ "api": "openai-completions",
+ "contextWindow": 128_000,
+ "maxTokens": 4096,
+ }
+ ]
+ }
+ }
+ })
+ .to_string(),
+ )
+ .unwrap();
+}
+
+/// One stored `prime-inference` API-key credential, with or without the
+/// team header `get_provider_headers` derives from `primeTeam`.
+fn write_prime_inference_credential(agent_dir: &std::path::Path, key: &str, team_id: Option<&str>) {
+ std::fs::create_dir_all(agent_dir).unwrap();
+ let mut credential = serde_json::json!({ "type": "api_key", "key": key });
+ if let Some(team_id) = team_id {
+ credential["primeTeam"] =
+ serde_json::json!({ "teamId": team_id, "name": format!("Team {team_id}") });
+ }
+ std::fs::write(
+ agent_dir.join("auth.json"),
+ serde_json::json!({ "prime-inference": credential }).to_string(),
+ )
+ .unwrap();
+}
+
+fn team_headers(team_id: &str) -> std::collections::BTreeMap {
+ [("X-Prime-Team-ID".to_string(), team_id.to_string())]
+ .into_iter()
+ .collect()
+}
+
+fn prime_inference_backed_engine(dir: &std::path::Path) -> AgentSessionEngine {
+ AgentSessionEngine::new(AgentEngineConfig {
+ cwd: dir.to_path_buf(),
+ agent_dir: dir.join("agent"),
+ provider: Some("prime-inference".to_string()),
+ model: Some("mock-1".to_string()),
+ api_key: None,
+ thinking: None,
+ session_dir: None,
+ session_file: None,
+ faux_script: None,
+ supervisor_link: None,
+ telemetry_disabled: Some(true),
+ cron_store: None,
+ queued_steering_probe: None,
+ })
+ .expect("engine")
+}
+
+/// A rotated credential REPLACES the request headers: a fresh key that
+/// carries no team header must clear the previous credential's
+/// `X-Prime-Team-ID`, never serve the stale team context on the new key.
+#[test]
+fn reload_clears_headers_when_the_fresh_credential_carries_none() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_prime_inference_provider(&agent_dir);
+ write_prime_inference_credential(&agent_dir, "team-key", Some("team-1"));
+ let engine = prime_inference_backed_engine(dir.path());
+ let model = engine.resolve_model().expect("the custom model resolves");
+ // The session's build-time target: the team credential the engine saw.
+ *engine
+ .provider_target
+ .write()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(ProviderTarget {
+ service_tier: None,
+ api_key: Some("team-key".to_string()),
+ model,
+ headers: Some(team_headers("team-1")),
+ });
+ // A re-login without the team replaces the stored credential.
+ write_prime_inference_credential(&agent_dir, "solo-key", None);
+ engine.reload_live_inputs().expect("the reload applies");
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the reload keeps the target set");
+ // The resolved credential never formats into a failure message: an
+ // api key is sensitive data (CodeQL's cleartext-logging rule), so the
+ // assertion compares without the assert_eq! formatting sink.
+ assert!(
+ target.api_key.as_deref() == Some("solo-key"),
+ "the reload rebinds the request auth to the fresh stored credential"
+ );
+ assert!(
+ target.headers.is_none(),
+ "the fresh credential clears the stale team header"
+ );
+}
+
+/// A failover's primary restore serves the resolved pair, never the
+/// resolved key paired with the captured headers: a credential rotated
+/// during the failover carries its own (empty) headers, clearing the
+/// captured `X-Prime-Team-ID` the pre-failover credential pinned.
+#[test]
+fn restored_primary_target_serves_the_resolved_header_pair() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_prime_inference_provider(&agent_dir);
+ write_prime_inference_credential(&agent_dir, "solo-key", None);
+ let engine = prime_inference_backed_engine(dir.path());
+ let primary = engine.resolve_model().expect("the primary resolves");
+ let restored = engine.restored_primary_target(
+ &primary,
+ Some("captured-key".to_string()),
+ Some(team_headers("old-team")),
+ );
+ // The resolved credential never formats into a failure message: an
+ // api key is sensitive data (CodeQL's cleartext-logging rule), so the
+ // assertion compares without the assert_eq! formatting sink.
+ assert!(
+ restored.api_key.as_deref() == Some("solo-key"),
+ "the restored primary serves the stored credential"
+ );
+ assert!(
+ restored.headers.is_none(),
+ "the resolved pair replaces the captured headers"
+ );
+}
+
+/// A reload over a malformed auth store reports the failure: the store
+/// cannot be parsed, so the MCP manager keeps its previous credentials
+/// and the reload answers with the storage error instead of a success
+/// the session did not apply.
+#[test]
+fn reload_reports_the_auth_store_failure() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_credential_backed_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "stale-access");
+ let engine = credential_backed_engine(dir.path());
+ let model = engine.resolve_model().expect("the custom model resolves");
+ *engine
+ .provider_target
+ .write()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(ProviderTarget {
+ service_tier: None,
+ api_key: Some("stale-access".to_string()),
+ model,
+ headers: None,
+ });
+ // Another process corrupts the store: the reload's re-read fails.
+ std::fs::write(agent_dir.join("auth.json"), "not json").unwrap();
+ let error = engine
+ .reload_live_inputs()
+ .expect_err("the malformed store fails the reload");
+ assert!(!error.is_empty(), "the reload surfaces the storage error");
+ // The failed reload never touched the target: the store gate ran
+ // before any rebind, so the session keeps its last-good request auth
+ // instead of falling to the provider's configured fallback key.
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the failed reload keeps the target set");
+ assert!(
+ target.api_key.as_deref() == Some("stale-access"),
+ "a failed reload preserves the last-good request auth"
+ );
+ // A repaired store reloads cleanly again.
+ write_oauth_credential(&agent_dir, "fresh-access");
+ engine
+ .reload_live_inputs()
+ .expect("the repaired store reloads");
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the reload keeps the target set");
+ assert!(
+ target.api_key.as_deref() == Some("fresh-access"),
+ "the repaired store rebinds the request auth"
+ );
+}
+
+/// A create-config key override stands in memory regardless of the store:
+/// when the store read fails, the restore keeps the override key and the
+/// captured headers (the last-good team context), never the header-less
+/// resolution the broken store produced.
+#[test]
+fn restored_primary_target_keeps_the_override_key_and_captured_headers_off_a_failed_store() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_credential_backed_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "stored-key");
+ let engine = credential_backed_engine_with_override(dir.path(), Some("override-key"));
+ let primary = engine.resolve_model().expect("the primary resolves");
+ // The store becomes unreadable mid-failover.
+ std::fs::write(agent_dir.join("auth.json"), "not json").unwrap();
+ let restored = engine.restored_primary_target(
+ &primary,
+ Some("override-key".to_string()),
+ Some(team_headers("team-1")),
+ );
+ assert!(
+ restored.api_key.as_deref() == Some("override-key"),
+ "the override key stands in memory off a failed store"
+ );
+ assert!(
+ restored.headers.as_ref() == Some(&team_headers("team-1")),
+ "a failed store read keeps the captured headers"
+ );
+ // A healthy store still resolves the override pair fresh.
+ write_oauth_credential(&agent_dir, "stored-key");
+ let restored = engine.restored_primary_target(
+ &primary,
+ Some("override-key".to_string()),
+ Some(team_headers("team-1")),
+ );
+ assert!(
+ restored.api_key.as_deref() == Some("override-key"),
+ "the healthy restore keeps the override key"
+ );
+}
+
+/// A healthy store that no longer holds the provider's credential
+/// leaves the target untouched: the resolution would serve the
+/// configured models.json fallback key, which is not a stored
+/// credential — the same never-clears contract a broken store keeps.
+#[test]
+fn reload_keeps_the_target_when_the_credential_leaves_the_store() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_credential_backed_provider(&agent_dir);
+ write_oauth_credential(&agent_dir, "live-access");
+ let engine = credential_backed_engine(dir.path());
+ let model = engine.resolve_model().expect("the custom model resolves");
+ *engine
+ .provider_target
+ .write()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(ProviderTarget {
+ service_tier: None,
+ api_key: Some("live-access".to_string()),
+ model,
+ headers: None,
+ });
+ // Another process removes the credential: the store stays healthy,
+ // but nothing is stored for the provider.
+ std::fs::write(agent_dir.join("auth.json"), "{}").unwrap();
+ engine.reload_live_inputs().expect("the reload applies");
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the reload keeps the target set");
+ assert!(
+ target.api_key.as_deref() == Some("live-access"),
+ "an empty store keeps the last-good stored credential"
+ );
+ // A re-login restores the credential and the rebind resumes.
+ write_oauth_credential(&agent_dir, "fresh-access");
+ engine.reload_live_inputs().expect("the reload applies");
+ let target = engine
+ .provider_target
+ .read()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .expect("the reload keeps the target set");
+ assert!(
+ target.api_key.as_deref() == Some("fresh-access"),
+ "a restored credential rebinds the request auth"
+ );
+}
diff --git a/crates/pa-daemon/src/agent_engine/turn/model.rs b/crates/pa-daemon/src/agent_engine/turn/model.rs
index 9c2d403e8..495756cd5 100644
--- a/crates/pa-daemon/src/agent_engine/turn/model.rs
+++ b/crates/pa-daemon/src/agent_engine/turn/model.rs
@@ -347,13 +347,24 @@ impl AgentSessionEngine {
// The stream's provider target follows the switch (the same slot
// `set_model` swaps).
{
+ // The switch's resolve-and-install serializes
+ // with `/reload`'s live-input refresh — the
+ // restore path in the sibling callback takes
+ // the same lock: a reload landing between
+ // this resolution and its slot write must not
+ // be clobbered by the switch's older pair. The
+ // turn runs on the blocking pool, so the
+ // synchronous resolution never touches an
+ // async executor worker.
+ let _reload_serialized = self
+ .reload_lock
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
// A routed episode keeps serving the route's
- // target across the failover switch.
- if let Some(route) = self.armed_image_route() {
- let mut target =
- self.provider_target.write().expect("provider target lock");
- *target = Some(route.target);
- } else {
+ // target across the failover switch — through
+ // the fenced install (the route lock covers
+ // the clone and the slot write together).
+ if !self.install_armed_route_target() {
let (api_key, headers) =
self.resolve_request_key_and_headers(&next);
let mut target =
@@ -395,20 +406,40 @@ impl AgentSessionEngine {
let agent_model = json_round_trip(&primary_model)
.ok_or_else(|| anyhow::anyhow!("model conversion failed"))?;
{
- let mut target =
- self.provider_target.write().expect("provider target lock");
- if let Some(route) = self.armed_image_route() {
- *target = Some(route.target);
- } else {
- *target = Some(ProviderTarget {
- service_tier: *self
- .service_tier
- .read()
- .expect("service tier lock"),
- api_key: primary_api_key,
- model: primary_model.clone(),
- headers: primary_headers,
- });
+ // The restore serializes with `/reload`'s
+ // live-input refresh: without this fence a
+ // reload landing between the restore's
+ // resolution and its slot write is clobbered
+ // by the restore's older pair — the lock
+ // makes whichever runs last leave the newest
+ // store standing. The whole turn (this
+ // closure included) runs on the blocking
+ // pool — the worker parks the turn there
+ // (`worker/turn.rs`) — so the synchronous
+ // credential resolution below, OAuth refresh
+ // and all, never touches an async executor
+ // worker; only a concurrently reloading
+ // session waits on this span.
+ let _reload_serialized = self
+ .reload_lock
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ // The armed-route install goes through the
+ // fenced helper (no provider-slot lock held
+ // across the route read).
+ if !self.install_armed_route_target() {
+ // The primary's request auth re-resolves at
+ // restore: a credential rotated (and
+ // reloaded) during the failover serves from
+ // the store, never the pre-failover
+ // capture.
+ let target = self.restored_primary_target(
+ &primary_model,
+ primary_api_key,
+ primary_headers,
+ );
+ *self.provider_target.write().expect("provider target lock") =
+ Some(target);
}
}
agent.set_model(agent_model).await;
diff --git a/crates/pa-daemon/src/image_route.rs b/crates/pa-daemon/src/image_route.rs
index d394d0c39..6af3c3ded 100644
--- a/crates/pa-daemon/src/image_route.rs
+++ b/crates/pa-daemon/src/image_route.rs
@@ -89,6 +89,13 @@ impl AgentSessionEngine {
/// at every model-turn attempt; a text-only session model with an
/// unusable or missing `settings.imageModel` returns the refusal.
pub(crate) fn arm_image_turn_route(&self, carries_images: bool) -> Result<(), String> {
+ // The lock spans the route's auth resolution and its publication:
+ // a `/reload` in between would refresh a route the arm then
+ // overwrites with the older pair.
+ let _reload_serialized = self
+ .reload_lock
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
let route = self
.resolve_image_turn_route(carries_images)
.map_err(|error| format!("{error:#}"))?;
@@ -153,7 +160,22 @@ impl AgentSessionEngine {
/// Apply the armed route to a model turn (after the session build, so
/// the build-time target cannot clobber it): the provider target and
/// the agent's per-run override swap to the routed image model.
+ ///
+ /// The route lock is held through the slot write: a `/reload` that
+ /// refreshes the armed route's auth and then the slot's can never be
+ /// overtaken by an older clone of this route installing itself after
+ /// the refresh — the clone and its install are one critical section.
pub(crate) fn apply_armed_image_route(&self, agent: &std::sync::Arc) {
+ // The lock spans the session-target capture AND the route install:
+ // `/reload` refreshes the armed route, releases the route lock,
+ // then rebinds the live slot — an apply in that window would
+ // capture the pre-reload session target (and a later clear would
+ // restore it over the reload's pair). Both run under the same
+ // lock: whichever runs last leaves the newest store standing.
+ let _reload_serialized = self
+ .reload_lock
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
let mut slot = self
.image_route
.lock()
@@ -170,15 +192,46 @@ impl AgentSessionEngine {
.clone_from(&self.provider_target.read().expect("provider target lock"));
}
let route = route.clone();
- drop(slot);
agent.set_model_override(Some(route.agent_override));
*self.provider_target.write().expect("provider target lock") = Some(route.target);
}
+ /// Install the armed route's target as the serving slot: the route
+ /// lock is held through the slot write, so the clone and its install
+ /// are one critical section — a `/reload` that refreshes the armed
+ /// route and then the slot can never be overtaken by an older clone
+ /// (the failover switch and restore install through here too).
+ /// Returns `false` when no route is armed.
+ pub(crate) fn install_armed_route_target(&self) -> bool {
+ let slot = self
+ .image_route
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ let Some(route) = slot.as_ref() else {
+ return false;
+ };
+ let target = route.target.clone();
+ *self.provider_target.write().expect("provider target lock") = Some(target);
+ true
+ }
+
/// Clear the armed route and restore the session's serving target (a
/// fresh resolution, so a mid-episode model switch is honored): the
/// next dispatched batch re-evaluates the routing against it.
pub(crate) fn clear_image_route(&self) {
+ // The lock spans the route take AND the clear's resolve-and-install:
+ // the reload refreshes the armed route in place, so a clear that
+ // took the route first would leave the reload unable to refresh
+ // the detached pair, and the clear's fallback restore would then
+ // clobber the reload's slot refresh with the pre-reload
+ // `session_target`. Both run under the same lock — whichever runs
+ // last leaves the newest store standing. This runs on the turn's
+ // blocking thread (the worker parks the turn there), so the
+ // synchronous resolution never touches an async executor worker.
+ let _reload_serialized = self
+ .reload_lock
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
let route = self
.image_route
.lock()
@@ -194,6 +247,12 @@ impl AgentSessionEngine {
if let Some(agent) = agent {
agent.set_model_override(None);
}
+ // The cleared slot returns to the CURRENT session state: the
+ // freshly resolved model (a mid-episode switch is honored) with
+ // its chain-resolved auth — the create-config override or the
+ // configured fallback key included, exactly what a fresh session
+ // of this model would serve. The captured session target only
+ // backs a resolution that cannot rebuild the model at all.
let mut target = match self.resolve_model() {
Ok(model) => {
let (api_key, headers) = self.resolve_request_key_and_headers(&model);
diff --git a/crates/pa-daemon/src/mcp_connections.rs b/crates/pa-daemon/src/mcp_connections.rs
index 3aaabb7b3..af0004fa7 100644
--- a/crates/pa-daemon/src/mcp_connections.rs
+++ b/crates/pa-daemon/src/mcp_connections.rs
@@ -44,8 +44,10 @@ impl Worker {
// The auth store re-read comes FIRST: the interactive client
// stores the api-key credentials through its own storage
// instance (the `/mcp` key flow runs client-side), so the
- // view's reads must reload the store to see them.
- manager.reload_auth_storage();
+ // view's reads must reload the store to see them. A failed
+ // reload serves the roster's last-good credentials — the
+ // view reports what the manager has, not the reload's error.
+ let _auth_reload = manager.reload_auth_storage();
manager.refresh();
(
manager.connection_roster(),
diff --git a/crates/pa-daemon/src/session_custom.rs b/crates/pa-daemon/src/session_custom.rs
index 9b2313695..1383a0a0b 100644
--- a/crates/pa-daemon/src/session_custom.rs
+++ b/crates/pa-daemon/src/session_custom.rs
@@ -305,13 +305,45 @@ impl Worker {
response_success(None, "refine", Some(result))
}
- /// `reload`: re-read the session's live inputs — settings, provider auth,
- /// the MCP user-server config. This port resolves each per use, so the
- /// command answers the TS success.
- pub(crate) fn handle_reload(&self) -> DaemonResponse {
+ /// `reload`: re-read the session's live inputs — the request auth
+ /// rebinds from the credential store (a `/login` from another process
+ /// never reaches the running session's request path otherwise), and
+ /// the MCP manager re-reads its settings and auth state. Settings and
+ /// the model catalog resolve per use and need no re-read. The reload
+ /// touches the MCP auth store, whose snapshot takes a blocking lock —
+ /// it parks on a blocking thread, the same posture as
+ /// `get_mcp_connections`.
+ pub(crate) async fn handle_reload(&self) -> DaemonResponse {
if let Err(response) = self.require_created("reload") {
return response;
}
+ if let Some(engine) = &self.agent_engine {
+ let engine = std::sync::Arc::clone(engine);
+ // The blocking thread's reload can fail two ways: the auth
+ // store's reload (a malformed document, an unacquirable lock)
+ // or the join itself (a panic). Both answer the client's
+ // reload with the failure, never a success the session did
+ // not apply.
+ match tokio::task::spawn_blocking(move || engine.reload_live_inputs()).await {
+ Ok(Ok(())) => {}
+ Ok(Err(error)) => {
+ return response_failure(
+ None,
+ "reload",
+ &format!("session reload failed: {error}"),
+ None,
+ );
+ }
+ Err(error) => {
+ return response_failure(
+ None,
+ "reload",
+ &format!("session reload failed: {error}"),
+ None,
+ );
+ }
+ }
+ }
response_success(None, "reload", None)
}
}
@@ -970,4 +1002,45 @@ mod tests {
assert!(response.success, "failed: {response:?}");
assert!(response.data.is_none());
}
+
+ /// The reload parks the engine's blocking work off the async executor:
+ /// with a REAL agent engine behind the worker (the faux-script engine)
+ /// the reload reaches the MCP auth store's blocking lock, which panics
+ /// when taken on the runtime — this fails if the blocking work moves
+ /// back onto the executor.
+ #[allow(clippy::await_holding_lock)] // the faux registry is process-global: the guard must span the async flow
+ #[tokio::test]
+ async fn reload_parks_the_engine_reload_off_the_runtime() {
+ let _faux = crate::agent_engine::tests::FAUX_TEST_LOCK
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ // A TempDir keeps the worker's files from piling up in /tmp.
+ let dir = tempfile::TempDir::new().unwrap();
+ let dir_path = dir.path().to_path_buf();
+ let config = crate::worker::WorkerConfig {
+ socket_path: dir_path.join("worker.sock"),
+ supervisor_socket_path: std::path::PathBuf::new(),
+ token: "token".to_string(),
+ worker_instance_id: String::new(),
+ active_session_id: "custom-session".to_string(),
+ agent_dir: dir_path.join("agent"),
+ recovery_journal_path: dir_path.join("recovery.jsonl"),
+ telemetry_disabled: None,
+ script: Some(json!({ "engine": "faux", "responses": ["ack"] })),
+ };
+ let worker = Arc::new(crate::worker::Worker::new(config, None));
+ let created = worker
+ .dispatch("create", &json!({ "noSession": true, "cwd": "/tmp" }))
+ .await;
+ assert!(created.success, "create failed: {created:?}");
+ assert!(
+ worker.agent_engine.is_some(),
+ "the faux script must build a real agent engine"
+ );
+ let response = worker
+ .dispatch("reload", &json!({ "activeSessionId": "custom-session" }))
+ .await;
+ assert!(response.success, "failed: {response:?}");
+ assert!(response.data.is_none());
+ }
}
diff --git a/crates/pa-daemon/src/worker/commands.rs b/crates/pa-daemon/src/worker/commands.rs
index 26ae1c203..a53c01ca9 100644
--- a/crates/pa-daemon/src/worker/commands.rs
+++ b/crates/pa-daemon/src/worker/commands.rs
@@ -161,7 +161,7 @@ impl Worker {
"restore_next_turn" => self.handle_restore_next_turn(payload),
"restore_actions" => self.handle_restore_actions(payload),
"refine" => self.handle_refine(payload).await,
- "reload" => self.handle_reload(),
+ "reload" => self.handle_reload().await,
"cancel_rlm_child" => self.handle_cancel_rlm_child(payload).await,
"delete_rlm_subagent" => self.handle_delete_rlm_subagent(payload).await,
// The engine call blocks on the engine runtime, so it