Lightweight coding agent that runs in your terminal
Rust
Add an in-memory agent message board for ephemeral sessions (#47946)
jifdda227891d27
diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex e08c701225..1e8327a60e 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -2746,6 +2746,10 @@"minimum": 0.0,"type": "integer"},+ "message_board_in_memory": {+ "description": "Keep the message board in memory for a training session, including ephemeral sessions.",+ "type": "boolean"+ },"min_wait_timeout_ms": {"format": "int64","maximum": 3600000.0,diff --git a/codex-rs/core/src/agent_message_board.rs b/codex-rs/core/src/agent_message_board.rsindex b21e94e7c3..e3b6333a46 100644--- a/codex-rs/core/src/agent_message_board.rs+++ b/codex-rs/core/src/agent_message_board.rs@@ -12,6 +12,7 @@ use crate::tools::MULTI_AGENT_V2_NAMESPACE_DESCRIPTION;use chrono::DateTime;use chrono::Utc;use codex_agent_message_board_extension::AgentMessageBoard;+use codex_agent_message_board_extension::InMemoryMessageBoards;use codex_agent_message_board_extension::LocalAgentMessageBoard;use codex_agent_message_board_extension::MessageBoardHost;use codex_agent_message_board_extension::NotificationDelivery;@@ -29,33 +30,40 @@ use futures::future::BoxFuture;use std::sync::Arc;use std::sync::Weak;-/// Registers the local board for opted-in, persistent MAv2 runtimes.-/// Shared session identity and the configured SQLite home survive runtime reloads.+/// Registers the configured board for opted-in MAv2 runtimes.+/// Training can share an in-memory board per tree, including ephemeral sessions.pub fn install_agent_message_board(registry: &mut ExtensionRegistryBuilder<Config>,manager: Weak<ThreadManager>,) {+ let in_memory_boards = Arc::new(InMemoryMessageBoards::default());codex_agent_message_board_extension::install(registry,MULTI_AGENT_V2_NAMESPACE_DESCRIPTION,|config: &Config| config.multi_agent_v2.tool_namespace.clone(),move |config: &Config, tree, caller| {+ let in_memory = config.multi_agent_v2.message_board_in_memory;// MAv2 supplies tree paths; ephemeral runtimes must not open durable storage.if !config.features.enabled(Feature::AgentMessageBoard)|| !config.features.enabled(Feature::MultiAgentV2)- || config.ephemeral+ || (config.ephemeral && !in_memory){return Box::pin(async { Ok(None) });}let sqlite = config.sqlite_config().clone();+ let in_memory_boards = Arc::clone(&in_memory_boards);let host = Arc::new(LocalBoardHost {manager: manager.clone(),tree,caller,});Box::pin(async move {- let board = LocalAgentMessageBoard::open(&sqlite, tree, host).await?;- Ok(Some(Arc::new(board) as Arc<dyn AgentMessageBoard>))+ let board: Arc<dyn AgentMessageBoard> = if in_memory {+ Arc::new(in_memory_boards.open(tree, host).await)+ } else {+ Arc::new(LocalAgentMessageBoard::open(&sqlite, tree, host).await?)+ };+ Ok(Some(board))})},);diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rsindex 2622171432..3e7f1f4a86 100644--- a/codex-rs/core/src/config/config_tests.rs+++ b/codex-rs/core/src/config/config_tests.rs@@ -12086,6 +12086,7 @@ hide_spawn_agent_metadata = trueexpose_spawn_agent_model_overrides = falsewait_agent_enabled = falsedisable_direct_message = true+message_board_in_memory = truenon_code_mode_only = true[agents]@@ -12142,6 +12143,7 @@ max_concurrent_threads_per_session = 9assert!(!config.multi_agent_v2.expose_spawn_agent_model_overrides);assert!(!config.multi_agent_v2.wait_agent_enabled);assert!(config.multi_agent_v2.disable_direct_message);+ assert!(config.multi_agent_v2.message_board_in_memory);assert!(config.multi_agent_v2.non_code_mode_only);Ok(())diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex 4fa07e6625..df6b1258d5 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -1331,6 +1331,7 @@ pub struct MultiAgentV2Config {pub expose_spawn_agent_model_overrides: bool,pub wait_agent_enabled: bool,pub disable_direct_message: bool,+ pub message_board_in_memory: bool,pub non_code_mode_only: bool,}@@ -1351,6 +1352,7 @@ impl MultiAgentV2Config {expose_spawn_agent_model_overrides: true,wait_agent_enabled: true,disable_direct_message: false,+ message_board_in_memory: false,non_code_mode_only: true,}}@@ -2788,6 +2790,9 @@ fn resolve_multi_agent_v2_config(config_toml: &ConfigToml) -> MultiAgentV2Configlet disable_direct_message = base.and_then(|config| config.disable_direct_message).unwrap_or(default.disable_direct_message);+ let message_board_in_memory = base+ .and_then(|config| config.message_board_in_memory)+ .unwrap_or(default.message_board_in_memory);let subagent_developer_instructions = base.and_then(|config| config.subagent_developer_instructions.as_ref()).map(|instructions| instructions.trim().to_string());@@ -2818,6 +2823,7 @@ fn resolve_multi_agent_v2_config(config_toml: &ConfigToml) -> MultiAgentV2Configexpose_spawn_agent_model_overrides,wait_agent_enabled,disable_direct_message,+ message_board_in_memory,non_code_mode_only,}}diff --git a/codex-rs/core/tests/suite/scenarios_agent_message_board.rs b/codex-rs/core/tests/suite/scenarios_agent_message_board.rsindex f9c37bbbbb..2abb0a8fb8 100644--- a/codex-rs/core/tests/suite/scenarios_agent_message_board.rs+++ b/codex-rs/core/tests/suite/scenarios_agent_message_board.rs@@ -203,11 +203,18 @@ async fn board_post_and_reads_reach_model_context_without_self_notices() -> anyhOk(())}+#[test_case::test_case(false; "disk")]+#[test_case::test_case(true; "in_memory")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn board_is_shared_with_children_survives_resume_and_skips_idle_notices() -> anyhow::Result<()>-{+async fn board_is_shared_with_children_and_skips_idle_notices(+ in_memory: bool,+) -> anyhow::Result<()> {let server = responses::start_mock_server().await;- let mut builder = test_codex().with_config(configure);+ let mut builder = test_codex().with_config(move |config| {+ configure(config);+ config.multi_agent_v2.message_board_in_memory = in_memory;+ config.ephemeral = in_memory;+ });let root = builder.build_with_auto_env(&server).await?;responses::mount_sse_sequence(&server,@@ -302,6 +309,17 @@ async fn board_is_shared_with_children_survives_resume_and_skips_idle_notices()serde_json::from_str(&output).with_context(|| format!("root read result: {output}"))?;assert_eq!(result["results"][0]["message_id"], post["message_id"]);child.shutdown_and_wait().await?;+ if in_memory {+ assert!(+ !root+ .config+ .sqlite_config()+ .home()+ .join("agent_message_board_1.sqlite")+ .exists()+ );+ return Ok(());+ }let resumed = test_codex().with_config(configure).restart(&server, &root)diff --git a/codex-rs/ext/agent-message-board/src/api.rs b/codex-rs/ext/agent-message-board/src/api.rsindex fee95aa4ac..75d31931dc 100644--- a/codex-rs/ext/agent-message-board/src/api.rs+++ b/codex-rs/ext/agent-message-board/src/api.rs@@ -21,7 +21,7 @@ use uuid::Uuid;// Local and remote implementations must remain usable through the same handle.const _: Option<&dyn AgentMessageBoard> = None;-/// Stores discussions and subscriptions for one persistent agent tree.+/// Stores discussions and subscriptions for one agent tree.////// Every operation validates caller membership. IDs are scoped to this board;/// an agent runtime's ThreadId is distinct from a discussion's root post UUID.diff --git a/codex-rs/ext/agent-message-board/src/in_memory.rs b/codex-rs/ext/agent-message-board/src/in_memory.rsnew file mode 100644index 0000000000..c780cdf96c--- /dev/null+++ b/codex-rs/ext/agent-message-board/src/in_memory.rs@@ -0,0 +1,384 @@+//! Tree-owned message boards for training. Agent handles share state; nothing is written to disk.+//! Mutations and recipient selection are atomic. Host callbacks run outside the state lock.++use crate::ChannelSummary;+use crate::CreateChannelRequest;+use crate::MessageBoardHost;+use crate::PostDestination;+use crate::PostMetadata;+use crate::PostPreview;+use crate::PostRequest;+use crate::SubscriptionChange;+use crate::SubscriptionRequest;+use crate::SubscriptionState;+use crate::SubscriptionTarget;+use caseless::default_case_fold_str;+use chrono::DateTime;+use chrono::Utc;+use codex_protocol::AgentPath;+use codex_protocol::SessionId;+use codex_protocol::ThreadId;+use codex_protocol::error::CodexErr;+use codex_protocol::error::Result;+use futures::StreamExt;+use std::collections::BTreeMap;+use std::collections::HashMap;+use std::collections::HashSet;+use std::sync::Arc;+use std::sync::Weak;+use tokio::sync::Mutex;+use uuid::Uuid;++mod queries;++/// Shares board state across a tree while giving each agent its own host handle.+#[derive(Default)]+pub struct InMemoryMessageBoards {+ states: Mutex<HashMap<SessionId, Weak<Mutex<State>>>>,+}++impl InMemoryMessageBoards {+ pub async fn open(+ &self,+ identity: SessionId,+ host: Arc<dyn MessageBoardHost>,+ ) -> InMemoryAgentMessageBoard {+ let mut states = self.states.lock().await;+ let entry = states.entry(identity).or_default();+ let state = entry.upgrade().unwrap_or_else(|| {+ let state = Arc::default();+ *entry = Arc::downgrade(&state);+ state+ });+ InMemoryAgentMessageBoard {+ identity,+ host,+ state,+ }+ }+}++/// A board held in memory for one training rollout.+/// The last handle releases its state; there is no persistence or recovery.+#[derive(Clone)]+pub struct InMemoryAgentMessageBoard {+ identity: SessionId,+ host: Arc<dyn MessageBoardHost>,+ state: Arc<Mutex<State>>,+}++#[derive(Default)]+struct State {+ channels: HashMap<String, Channel>,+ posts: Vec<Post>,+ by_id: HashMap<Uuid, usize>,+ requests: HashMap<(ThreadId, String), usize>,+ subscriptions: BTreeMap<SubscriptionTarget, HashMap<ThreadId, SubscriptionChange>>,+}++struct Channel {+ summary: ChannelSummary,+ search: String,+ posts: Vec<usize>,+ roots: Vec<usize>,+}++struct Post {+ metadata: PostMetadata,+ request: PostRequest,+ search: String,+ n_chars: usize,+ replies: Vec<usize>,+ latest_reply: Option<usize>,+}++impl Post {+ fn preview(&self, max_chars: usize) -> PostPreview {+ PostPreview {+ metadata: self.metadata.clone(),+ text_preview: self.request.text.chars().take(max_chars).collect(),+ n_chars: self.n_chars,+ truncated: self.n_chars > max_chars,+ }+ }+}++impl State {+ fn post_index(&self, id: Uuid) -> Result<usize> {+ self.by_id+ .get(&id)+ .copied()+ .ok_or_else(|| invalid("post not found in this board"))+ }++ fn thread_index(&self, id: Uuid) -> Result<usize> {+ let index = self.post_index(id)?;+ if self.posts[index].metadata.thread_id != id {+ return Err(invalid("thread_id must identify a top-level post"));+ }+ Ok(index)+ }++ fn key(&self, index: usize) -> (i64, usize) {+ (+ self.posts[index].metadata.created_at.timestamp_micros(),+ index,+ )+ }++ fn existing_post(+ &self,+ caller: ThreadId,+ request: &PostRequest,+ ) -> Result<Option<PostMetadata>> {+ self.requests+ .get(&(caller, request.request_id.clone()))+ .map(|index| {+ let post = &self.posts[*index];+ if post.request != *request {+ return Err(invalid("request ID was already used for a different post"));+ }+ Ok(post.metadata.clone())+ })+ .transpose()+ }++ fn insert_channel(&mut self, name: &str, author: AgentPath, now: DateTime<Utc>) -> Result<()> {+ if name.is_empty()+ || name.len() > 128+ || name.trim() != name+ || name.chars().any(char::is_control)+ {+ return Err(invalid(+ "channel names must contain 1–128 bytes without edge whitespace or control characters",+ ));+ }+ if self.channels.contains_key(name) {+ return Err(invalid("channel already exists"));+ }+ self.channels.insert(+ name.to_owned(),+ Channel {+ summary: ChannelSummary {+ channel_name: name.to_owned(),+ created_at: now,+ created_by: author,+ message_count: 0,+ last_message_id: None,+ },+ search: default_case_fold_str(name),+ posts: Vec::new(),+ roots: Vec::new(),+ },+ );+ Ok(())+ }++ fn subscribe(&mut self, target: SubscriptionTarget, caller: ThreadId) {+ self.subscriptions+ .entry(target)+ .or_default()+ .entry(caller)+ .or_insert(SubscriptionChange::Subscribe);+ }+}++impl InMemoryAgentMessageBoard {+ pub fn new(identity: SessionId, host: Arc<dyn MessageBoardHost>) -> Self {+ Self {+ identity,+ host,+ state: Arc::default(),+ }+ }++ async fn create_channel(+ &self,+ caller: ThreadId,+ request: CreateChannelRequest,+ ) -> Result<ChannelSummary> {+ let author = self.host.agent_path(caller).await?;+ let now = self.host.current_time(caller).await?;+ let mut state = self.state.lock().await;+ state.insert_channel(&request.channel_name, author, now)?;+ if request.subscription == SubscriptionChange::Subscribe {+ state.subscribe(+ SubscriptionTarget::Channel(request.channel_name.clone()),+ caller,+ );+ }+ Ok(state.channels[&request.channel_name].summary.clone())+ }++ async fn post(&self, caller: ThreadId, request: PostRequest) -> Result<PostMetadata> {+ // Accepted writes and their one-time fanout outlive cancellation of the tool call.+ let board = self.clone();+ tokio::spawn(async move { board.post_inner(caller, request).await })+ .await+ .map_err(|error| CodexErr::Io(std::io::Error::other(error)))?+ }++ async fn post_inner(&self, caller: ThreadId, request: PostRequest) -> Result<PostMetadata> {+ if request.text.is_empty()+ || request.text.len() > 64 * 1024+ || request.request_id.is_empty()+ || request.request_id.len() > 512+ || request.agents_to_notify.len() > 256+ {+ return Err(invalid(+ "post text, request ID or recipient count exceeds the board limits",+ ));+ }+ let author = self.host.agent_path(caller).await?;+ if let Some(post) = self.state.lock().await.existing_post(caller, &request)? {+ return Ok(post);+ }+ let mut recipients = HashSet::new();+ for path in &request.agents_to_notify {+ recipients.insert(self.host.resolve_agent(path.clone()).await?);+ }+ let now = self.host.current_time(caller).await?;+ let (metadata, notice) = {+ let mut state = self.state.lock().await;+ if let Some(post) = state.existing_post(caller, &request)? {+ return Ok(post);+ }+ let id = Uuid::now_v7();+ let (channel_name, root, target) = match &request.destination {+ PostDestination::Channel(name) => {+ if !state.channels.contains_key(name) {+ return Err(invalid("channel not found in this board"));+ }+ (name.clone(), id, SubscriptionTarget::Channel(name.clone()))+ }+ PostDestination::NewChannel(name) => {+ state.insert_channel(name, author.clone(), now)?;+ state.subscribe(SubscriptionTarget::Channel(name.clone()), caller);+ (name.clone(), id, SubscriptionTarget::Channel(name.clone()))+ }+ PostDestination::Thread(root) => {+ let index = state.thread_index(*root)?;+ (+ state.posts[index].metadata.channel_name.clone(),+ *root,+ SubscriptionTarget::Thread(*root),+ )+ }+ };+ if let Some(subscribers) = state.subscriptions.get(&target) {+ recipients.extend(subscribers.iter().filter_map(|(agent, change)| {+ (*change == SubscriptionChange::Subscribe).then_some(*agent)+ }));+ }+ recipients.remove(&caller);+ let metadata = PostMetadata {+ message_id: id,+ channel_name: channel_name.clone(),+ author,+ thread_id: root,+ created_at: now,+ };+ let index = state.posts.len();+ state+ .requests+ .insert((caller, request.request_id.clone()), index);+ state.by_id.insert(id, index);+ state.posts.push(Post {+ metadata: metadata.clone(),+ search: default_case_fold_str(&request.text),+ n_chars: request.text.chars().count(),+ request,+ replies: Vec::new(),+ latest_reply: None,+ });+ let last = state.channels[&channel_name].summary.last_message_id;+ let newest = last.is_none_or(|last| state.key(index) > state.key(state.by_id[&last]));+ #[expect(+ clippy::expect_used,+ reason = "destination was checked or inserted under this lock"+ )]+ let channel = state+ .channels+ .get_mut(&channel_name)+ .expect("validated channel");+ channel.posts.push(index);+ channel.summary.message_count += 1;+ if newest {+ channel.summary.last_message_id = Some(id);+ }+ if root == id {+ channel.roots.push(index);+ } else {+ let root_index = state.by_id[&root];+ let newest = state.posts[root_index]+ .latest_reply+ .is_none_or(|last| state.key(index) > state.key(last));+ let thread = &mut state.posts[root_index];+ thread.replies.push(index);+ if newest {+ thread.latest_reply = Some(index);+ }+ }+ state.subscribe(SubscriptionTarget::Thread(root), caller);+ (metadata, state.posts[index].preview(/*max_chars*/ 150))+ };+ futures::stream::iter(recipients).for_each_concurrent(/*limit*/ 16, |recipient| {+ let notice = notice.clone();+ async move {+ if let Err(error) = self.host.notify(recipient, notice).await {+ tracing::warn!(%recipient, %error, "Failed to deliver message-board notification");+ }+ }+ }).await;+ Ok(metadata)+ }++ async fn set_subscription(+ &self,+ caller: ThreadId,+ request: SubscriptionRequest,+ ) -> Result<SubscriptionState> {+ let caller_path = self.host.agent_path(caller).await?;+ let target_path = request.target_agent.unwrap_or(caller_path);+ let target_agent = self.host.resolve_agent(target_path.clone()).await?;+ let mut state = self.state.lock().await;+ let (channel_name, thread_id, last_message_id) = match &request.target {+ SubscriptionTarget::Channel(name) => {+ let channel = state+ .channels+ .get(name)+ .ok_or_else(|| invalid("channel not found in this board"))?;+ (name.clone(), None, channel.summary.last_message_id)+ }+ SubscriptionTarget::Thread(root) => {+ let index = state.thread_index(*root)?;+ let post = &state.posts[index];+ let last = post+ .latest_reply+ .filter(|last| state.key(*last) > state.key(index))+ .unwrap_or(index);+ (+ post.metadata.channel_name.clone(),+ Some(*root),+ Some(state.posts[last].metadata.message_id),+ )+ }+ };+ state+ .subscriptions+ .entry(request.target)+ .or_default()+ .insert(target_agent, request.change);+ Ok(SubscriptionState {+ channel_name,+ thread_id,+ target_agent: target_path,+ enabled: request.change == SubscriptionChange::Subscribe,+ last_message_id,+ })+ }+}++fn invalid(message: impl Into<String>) -> CodexErr {+ CodexErr::InvalidRequest(message.into())+}diff --git a/codex-rs/ext/agent-message-board/src/in_memory/queries.rs b/codex-rs/ext/agent-message-board/src/in_memory/queries.rsnew file mode 100644index 0000000000..385ad9006d--- /dev/null+++ b/codex-rs/ext/agent-message-board/src/in_memory/queries.rs@@ -0,0 +1,285 @@+//! Trait adapter and queries over indexed in-memory posts. Only page results clone content.++use super::InMemoryAgentMessageBoard;+use super::invalid;+use crate::AgentMessageBoard;+use crate::ChannelQuery;+use crate::ChannelSummary;+use crate::CreateChannelRequest;+use crate::Page;+use crate::PageRequest;+use crate::PostContent;+use crate::PostMetadata;+use crate::PostPreview;+use crate::PostQuery;+use crate::PostRequest;+use crate::ReadPostRequest;+use crate::ReadThreadRequest;+use crate::SortDirection;+use crate::SubscriptionRequest;+use crate::SubscriptionState;+use crate::ThreadPage;+use crate::ThreadQuery;+use crate::ThreadSort;+use crate::ThreadSummary;+use base64::Engine;+use base64::prelude::BASE64_URL_SAFE_NO_PAD;+use caseless::default_case_fold_str;+use codex_protocol::SessionId;+use codex_protocol::ThreadId;+use codex_protocol::error::Result;+use futures::future::BoxFuture;+use std::cmp::Reverse;++impl AgentMessageBoard for InMemoryAgentMessageBoard {+ fn identity(&self) -> SessionId {+ self.identity+ }++ fn create_channel(+ &self,+ caller: ThreadId,+ request: CreateChannelRequest,+ ) -> BoxFuture<'_, Result<ChannelSummary>> {+ Box::pin(self.create_channel(caller, request))+ }++ fn post(&self, caller: ThreadId, request: PostRequest) -> BoxFuture<'_, Result<PostMetadata>> {+ Box::pin(self.post(caller, request))+ }++ fn set_subscription(+ &self,+ caller: ThreadId,+ request: SubscriptionRequest,+ ) -> BoxFuture<'_, Result<SubscriptionState>> {+ Box::pin(self.set_subscription(caller, request))+ }++ fn read_post(+ &self,+ caller: ThreadId,+ request: ReadPostRequest,+ ) -> BoxFuture<'_, Result<PostContent>> {+ Box::pin(async move {+ self.host.agent_path(caller).await?;+ let state = self.state.lock().await;+ let post = &state.posts[state.post_index(request.message_id)?];+ let offset = (request.offset_chars as usize).min(post.n_chars);+ let text: String = post+ .request+ .text+ .chars()+ .skip(offset)+ .take((request.limit_chars.get() as usize).min(20_000))+ .collect();+ Ok(PostContent {+ metadata: post.metadata.clone(),+ n_chars: post.n_chars,+ next_offset_chars: offset + text.chars().count(),+ text,+ })+ })+ }++ fn list_channels(+ &self,+ caller: ThreadId,+ query: ChannelQuery,+ ) -> BoxFuture<'_, Result<Page<ChannelSummary>>> {+ Box::pin(async move {+ self.host.agent_path(caller).await?;+ let search = default_case_fold_str(&query.query.unwrap_or_default());+ let state = self.state.lock().await;+ let mut channels: Vec<_> = state+ .channels+ .values()+ .filter(|channel| channel.search.contains(&search))+ .collect();+ channels.sort_unstable_by_key(|channel| {+ let activity = channel+ .summary+ .last_message_id+ .map_or(channel.summary.created_at.timestamp_micros(), |id| {+ state.key(state.by_id[&id]).0+ });+ (activity, &channel.summary.channel_name)+ });+ if query.direction == SortDirection::NewestFirst {+ channels.reverse();+ }+ let page = page(&query.page, channels)?;+ Ok(Page {+ results: page+ .results+ .into_iter()+ .map(|channel| channel.summary.clone())+ .collect(),+ next_cursor: page.next_cursor,+ })+ })+ }++ fn list_threads(+ &self,+ caller: ThreadId,+ query: ThreadQuery,+ ) -> BoxFuture<'_, Result<Page<ThreadSummary>>> {+ Box::pin(async move {+ self.host.agent_path(caller).await?;+ let state = self.state.lock().await;+ let channel = state+ .channels+ .get(&query.channel_name)+ .ok_or_else(|| invalid("channel not found in this board"))?;+ let mut roots = channel.roots.clone();+ roots.sort_unstable_by_key(|index| {+ let (created, sequence) = state.key(*index);+ let timestamp = match query.sort {+ ThreadSort::Created => created,+ ThreadSort::Activity => state.posts[*index]+ .latest_reply+ .map_or(created, |reply| created.max(state.key(reply).0)),+ };+ (timestamp, sequence)+ });+ if query.direction == SortDirection::NewestFirst {+ roots.reverse();+ }+ let page = page(&query.page, roots)?;+ let chars = (query.max_chars_per_post.get() as usize)+ .min(20_000 / (2 * page.results.len().max(1)));+ Ok(Page {+ results: page+ .results+ .into_iter()+ .map(|index| {+ let root = &state.posts[index];+ let last = root.latest_reply.map(|reply| &state.posts[reply]);+ ThreadSummary {+ thread_id: root.metadata.message_id,+ root_post: root.preview(chars),+ reply_count: root.replies.len(),+ last_activity_at: last.map_or(root.metadata.created_at, |last| {+ last.metadata.created_at.max(root.metadata.created_at)+ }),+ latest_reply: last.map(|post| post.preview(chars)),+ }+ })+ .collect(),+ next_cursor: page.next_cursor,+ })+ })+ }++ fn search_posts(+ &self,+ caller: ThreadId,+ query: PostQuery,+ ) -> BoxFuture<'_, Result<Page<PostPreview>>> {+ Box::pin(async move {+ self.host.agent_path(caller).await?;+ let search = query.query.as_deref().map(default_case_fold_str);+ let state = self.state.lock().await;+ let after = query+ .after_message_id+ .map(|id| state.post_index(id).map(|index| state.key(index)))+ .transpose()?;+ let mut posts: Vec<_> = match &query.channel_name {+ Some(channel) => state+ .channels+ .get(channel)+ .map(|channel| channel.posts.clone())+ .unwrap_or_default(),+ None => (0..state.posts.len()).collect(),+ };+ posts.retain(|index| {+ let post = &state.posts[*index];+ query+ .author+ .as_ref()+ .is_none_or(|author| *author == post.metadata.author)+ && search+ .as_ref()+ .is_none_or(|text| post.search.contains(text))+ && after.is_none_or(|after| state.key(*index) > after)+ });+ posts.sort_unstable_by_key(|index| Reverse(state.key(*index)));+ let page = page(&query.page, posts)?;+ let chars =+ (query.max_chars_per_post.get() as usize).min(20_000 / page.results.len().max(1));+ Ok(Page {+ results: page+ .results+ .into_iter()+ .map(|index| state.posts[index].preview(chars))+ .collect(),+ next_cursor: page.next_cursor,+ })+ })+ }++ fn read_thread(+ &self,+ caller: ThreadId,+ request: ReadThreadRequest,+ ) -> BoxFuture<'_, Result<ThreadPage>> {+ Box::pin(async move {+ self.host.agent_path(caller).await?;+ let state = self.state.lock().await;+ let root = &state.posts[state.thread_index(request.thread_id)?];+ let mut replies = root.replies.clone();+ replies.sort_unstable_by_key(|index| Reverse(state.key(*index)));+ let page = page(&request.page, replies)?;+ let chars =+ (request.max_chars_per_post.get() as usize).min(20_000 / (page.results.len() + 1));+ Ok(ThreadPage {+ root_post: root.preview(chars),+ replies: Page {+ results: page+ .results+ .into_iter()+ .map(|index| state.posts[index].preview(chars))+ .collect(),+ next_cursor: page.next_cursor,+ },+ })+ })+ }+}++fn page<T>(request: &PageRequest, results: Vec<T>) -> Result<Page<T>> {+ let offset = match &request.cursor {+ Some(cursor) => {+ let mut bytes = [0; 4];+ let len = BASE64_URL_SAFE_NO_PAD+ .decode_slice(cursor, &mut bytes)+ .map_err(|_| invalid("invalid cursor"))?;+ if len != bytes.len() {+ return Err(invalid("invalid cursor"));+ }+ u32::from_be_bytes(bytes)+ }+ None => 0,+ };+ let limit = (request.limit.get() as usize).min(50);+ let mut results: Vec<_> = results+ .into_iter()+ .skip(offset as usize)+ .take(limit + 1)+ .collect();+ let has_more = results.len() > limit;+ results.truncate(limit);+ let next_cursor = if has_more {+ let offset = offset+ .checked_add(results.len() as u32)+ .ok_or_else(|| invalid("cursor offset exceeds the board limit"))?;+ Some(BASE64_URL_SAFE_NO_PAD.encode(offset.to_be_bytes()))+ } else {+ None+ };+ Ok(Page {+ results,+ next_cursor,+ })+}diff --git a/codex-rs/ext/agent-message-board/src/lib.rs b/codex-rs/ext/agent-message-board/src/lib.rsindex 509ee24476..534bdc6d5e 100644--- a/codex-rs/ext/agent-message-board/src/lib.rs+++ b/codex-rs/ext/agent-message-board/src/lib.rs@@ -1,4 +1,4 @@-//! Shared agent discussions with interchangeable local and remote backends.+//! Shared agent discussions with interchangeable local, in-memory and remote backends.//!//! Board identity and caller identity come from the host. Implementations own//! storage and notification fanout; tools and feature registration are separate.@@ -6,6 +6,7 @@mod api;mod extension;mod host;+mod in_memory;mod local;mod tools;mod types;@@ -28,6 +29,8 @@ pub use api::ThreadSort;pub use extension::install;pub use host::MessageBoardHost;pub use host::NotificationDelivery;+pub use in_memory::InMemoryAgentMessageBoard;+pub use in_memory::InMemoryMessageBoards;pub use local::LocalAgentMessageBoard;pub use tools::message_board_tools;pub use types::ChannelSummary;diff --git a/codex-rs/ext/agent-message-board/tests/local_board.rs b/codex-rs/ext/agent-message-board/tests/local_board.rsindex 6c1eaa0292..c117b587dd 100644--- a/codex-rs/ext/agent-message-board/tests/local_board.rs+++ b/codex-rs/ext/agent-message-board/tests/local_board.rs@@ -1,4 +1,9 @@-//! Exercises real local storage through independent handles and host capabilities.+//! Exercises message-board backends through their shared trait and host capabilities.++#![expect(+ clippy::unwrap_used,+ reason = "shared test helpers assert successful operations"+)]use std::collections::HashMap;use std::num::NonZeroU32;@@ -383,8 +388,92 @@ async fn shared_handles_resume_posts_and_preserve_subscription_rules() {pool.close().await;}+#[tokio::test]+async fn in_memory_handles_share_posts_deduplicate_calls_and_release_state() {+ let root = ThreadId::new();+ let child = ThreadId::new();+ let child_path = AgentPath::root().join("worker").unwrap();+ let host = Arc::new(Host {+ clock: AtomicI64::default(),+ agent_path_calls: AtomicUsize::default(),+ members: [(root, AgentPath::root()), (child, child_path.clone())].into(),+ active: AtomicBool::new(true),+ fail_notifications: AtomicBool::new(false),+ notifications: Mutex::default(),+ });+ let boards = InMemoryMessageBoards::default();+ let (board, shared) = tokio::join!(+ boards.open(root.into(), host.clone()),+ boards.open(root.into(), host.clone()),+ );+ let request = PostRequest {+ request_id: "same-call".into(),+ destination: PostDestination::NewChannel("work".into()),+ text: "done".into(),+ agents_to_notify: vec![child_path],+ };+ let (first, retry) = tokio::join!(+ board.post(root, request.clone()),+ shared.post(root, request)+ );+ let metadata = first.unwrap();+ assert_eq!(retry.unwrap(), metadata);+ assert_eq!(+ *host.notifications.lock().unwrap(),+ vec![(child, metadata.clone())]+ );+ let read = ReadPostRequest {+ message_id: metadata.message_id,+ offset_chars: 0,+ limit_chars: NonZeroU32::new(20).unwrap(),+ };+ assert_eq!(+ shared.read_post(child, read.clone()).await.unwrap(),+ PostContent {+ metadata,+ text: "done".into(),+ n_chars: 4,+ next_offset_chars: 4+ }+ );+ let other = boards.open(SessionId::new(), host.clone()).await;+ assert!(other.read_post(root, read.clone()).await.is_err());+ drop(board);+ drop(shared);+ let fresh = boards.open(root.into(), host).await;+ assert!(fresh.read_post(root, read).await.is_err());+}++enum Backend {+ Local,+ InMemory,+}++impl Backend {+ async fn open(+ self,+ sqlite: &SqliteConfig,+ identity: SessionId,+ host: Arc<dyn MessageBoardHost>,+ ) -> Arc<dyn AgentMessageBoard> {+ match self {+ Self::Local => Arc::new(+ LocalAgentMessageBoard::open(sqlite, identity, host)+ .await+ .unwrap(),+ ),+ Self::InMemory => Arc::new(InMemoryAgentMessageBoard::new(identity, host)),+ }+ }+}+#[tokio::test]async fn failed_requests_do_not_create_channels_or_notify_inactive_agents() {+ check_failed_requests_do_not_create_channels_or_notify_inactive_agents(Backend::Local).await;+ check_failed_requests_do_not_create_channels_or_notify_inactive_agents(Backend::InMemory).await;+}++async fn check_failed_requests_do_not_create_channels_or_notify_inactive_agents(backend: Backend) {let dir = tempfile::tempdir().unwrap();let sqlite = SqliteConfig::new_for_testing(dir.path().to_path_buf().try_into().unwrap());let root = ThreadId::new();@@ -398,9 +487,9 @@ async fn failed_requests_do_not_create_channels_or_notify_inactive_agents() {active: AtomicBool::new(false),notifications: Mutex::default(),});- let board = LocalAgentMessageBoard::open(&sqlite, SessionId::from(root), host.clone())- .await- .unwrap();+ let board = backend+ .open(&sqlite, SessionId::from(root), host.clone())+ .await;let mut request = PostRequest {request_id: "post".into(),destination: PostDestination::NewChannel("work".into()),@@ -452,6 +541,11 @@ async fn failed_requests_do_not_create_channels_or_notify_inactive_agents() {#[tokio::test]async fn queries_enforce_page_and_preview_caps() {+ check_queries_enforce_page_and_preview_caps(Backend::Local).await;+ check_queries_enforce_page_and_preview_caps(Backend::InMemory).await;+}++async fn check_queries_enforce_page_and_preview_caps(backend: Backend) {let dir = tempfile::tempdir().unwrap();let sqlite = SqliteConfig::new_for_testing(dir.path().to_path_buf().try_into().unwrap());let root = ThreadId::new();@@ -463,9 +557,7 @@ async fn queries_enforce_page_and_preview_caps() {active: AtomicBool::new(false),notifications: Mutex::default(),});- let board = LocalAgentMessageBoard::open(&sqlite, root.into(), host)- .await- .unwrap();+ let board = backend.open(&sqlite, root.into(), host).await;board.create_channel(root,@@ -543,6 +635,11 @@ async fn queries_enforce_page_and_preview_caps() {#[tokio::test]async fn queries_page_discussions_and_search_unicode() {+ check_queries_page_discussions_and_search_unicode(Backend::Local).await;+ check_queries_page_discussions_and_search_unicode(Backend::InMemory).await;+}++async fn check_queries_page_discussions_and_search_unicode(backend: Backend) {let dir = tempfile::tempdir().unwrap();let sqlite = SqliteConfig::new_for_testing(dir.path().to_path_buf().try_into().unwrap());let root = ThreadId::new();@@ -554,11 +651,7 @@ async fn queries_page_discussions_and_search_unicode() {active: AtomicBool::new(true),notifications: Mutex::default(),});- let board: Arc<dyn AgentMessageBoard> = Arc::new(- LocalAgentMessageBoard::open(&sqlite, SessionId::from(root), host)- .await- .unwrap(),- );+ let board = backend.open(&sqlite, SessionId::from(root), host).await;let request = PostRequest {request_id: "first".into(),destination: PostDestination::NewChannel("work".into()),@@ -799,6 +892,14 @@ fn board_tool_call(name: &str, args: serde_json::Value) -> codex_tools::ToolCall#[tokio::test]async fn tools_cover_channel_discussions_subscriptions_and_escaped_previews() {+ check_tools_cover_channel_discussions_subscriptions_and_escaped_previews(Backend::Local).await;+ check_tools_cover_channel_discussions_subscriptions_and_escaped_previews(Backend::InMemory)+ .await;+}++async fn check_tools_cover_channel_discussions_subscriptions_and_escaped_previews(+ backend: Backend,+) {use codex_tools::ToolName;use serde_json::json;let dir = tempfile::tempdir().unwrap();@@ -814,11 +915,7 @@ async fn tools_cover_channel_discussions_subscriptions_and_escaped_previews() {active: AtomicBool::new(true),notifications: Mutex::default(),});- let board = Arc::new(- LocalAgentMessageBoard::open(&sqlite, root.into(), host.clone())- .await- .unwrap(),- );+ let board = backend.open(&sqlite, root.into(), host.clone()).await;let tools = message_board_tools(board,root,@@ -985,6 +1082,15 @@ async fn tools_cover_channel_discussions_subscriptions_and_escaped_previews() {#[tokio::test]async fn tools_validate_arguments_deduplicate_calls_and_bound_unicode_results() {+ check_tools_validate_arguments_deduplicate_calls_and_bound_unicode_results(Backend::Local)+ .await;+ check_tools_validate_arguments_deduplicate_calls_and_bound_unicode_results(Backend::InMemory)+ .await;+}++async fn check_tools_validate_arguments_deduplicate_calls_and_bound_unicode_results(+ backend: Backend,+) {use codex_tools::ToolCallSource;use codex_tools::ToolName;use codex_utils_output_truncation::TruncationPolicy;@@ -1003,11 +1109,7 @@ async fn tools_validate_arguments_deduplicate_calls_and_bound_unicode_results()active: AtomicBool::new(true),notifications: Mutex::default(),});- let board = Arc::new(- LocalAgentMessageBoard::open(&sqlite, root.into(), host.clone())- .await- .unwrap(),- );+ let board = backend.open(&sqlite, root.into(), host.clone()).await;let tools = message_board_tools(board.clone(),root,diff --git a/codex-rs/features/src/feature_configs.rs b/codex-rs/features/src/feature_configs.rsindex d541696e64..b48bc76314 100644--- a/codex-rs/features/src/feature_configs.rs+++ b/codex-rs/features/src/feature_configs.rs@@ -300,6 +300,9 @@ pub struct MultiAgentV2ConfigToml {/// Disable the model's direct-message tools; spawning and automatic child results remain available.#[serde(skip_serializing_if = "Option::is_none")]pub disable_direct_message: Option<bool>,+ /// Keep the message board in memory for a training session, including ephemeral sessions.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub message_board_in_memory: Option<bool>,#[serde(skip_serializing_if = "Option::is_none")]pub non_code_mode_only: Option<bool>,}diff --git a/codex-rs/features/src/tests.rs b/codex-rs/features/src/tests.rsindex bc28a146ea..e11d777440 100644--- a/codex-rs/features/src/tests.rs+++ b/codex-rs/features/src/tests.rs@@ -744,6 +744,7 @@ hide_spawn_agent_metadata = trueexpose_spawn_agent_model_overrides = truewait_agent_enabled = falsedisable_direct_message = true+message_board_in_memory = truenon_code_mode_only = true"#,)@@ -772,6 +773,7 @@ non_code_mode_only = trueexpose_spawn_agent_model_overrides: Some(true),wait_agent_enabled: Some(false),disable_direct_message: Some(true),+ message_board_in_memory: Some(true),non_code_mode_only: Some(true),})));