Lightweight coding agent that runs in your terminal
Rust
Prioritize human evidence in memory v2 extraction (#43799)
jif6924ce636b21
diff --git a/codex-rs/core/src/context/memory.rs b/codex-rs/core/src/context/memory.rsnew file mode 100644index 0000000000..3b1aefc1d6--- /dev/null+++ b/codex-rs/core/src/context/memory.rs@@ -0,0 +1,63 @@+//! Typed, bounded v2 memory context. Extraction chunks preserve selected evidence in order.++use super::ContextualUserFragment;+use codex_protocol::models::ContentItemKind;+use codex_protocol::models::ResponseItem;+use codex_utils_output_truncation::TruncationPolicy;+use codex_utils_output_truncation::truncate_text;++/// Memory-owned model context, capped below 10k tokens even for byte-heavy text.+pub enum MemoryContextFragment {+ ReadInstructions(String),+ ExtractionEvidence(String),+}++impl MemoryContextFragment {+ /// Splits already-budgeted extraction input without dropping evidence.+ pub fn extraction_messages(mut text: &str) -> Vec<ResponseItem> {+ let mut messages = Vec::new();+ while !text.is_empty() {+ let end = text.floor_char_boundary(text.len().min(8_900));+ messages.push(ContextualUserFragment::into(Self::ExtractionEvidence(+ text[..end].to_string(),+ )));+ text = &text[end..];+ }+ messages+ }+}++impl ContextualUserFragment for MemoryContextFragment {+ fn role(&self) -> &'static str {+ match self {+ Self::ReadInstructions(_) => "developer",+ Self::ExtractionEvidence(_) => "user",+ }+ }+ fn content_kind(&self) -> ContentItemKind {+ ContentItemKind(+ match self {+ Self::ReadInstructions(_) => "memories.instructions",+ Self::ExtractionEvidence(_) => "memories.extraction_evidence",+ }+ .to_string(),+ )+ }+ fn requires_separate_message(&self) -> bool {+ true+ }+ fn markers(&self) -> (&'static str, &'static str) {+ Self::type_markers()+ }+ fn type_markers() -> (&'static str, &'static str) {+ ("", "")+ }+ fn body(&self) -> String {+ let (Self::ReadInstructions(text) | Self::ExtractionEvidence(text)) = self;+ truncate_text(text, TruncationPolicy::Bytes(8_900))+ }+}++#[cfg(test)]+#[path = "memory_tests.rs"]+mod tests;diff --git a/codex-rs/core/src/context/memory_tests.rs b/codex-rs/core/src/context/memory_tests.rsnew file mode 100644index 0000000000..b8b687533b--- /dev/null+++ b/codex-rs/core/src/context/memory_tests.rs@@ -0,0 +1,21 @@+use super::*;+use codex_protocol::models::ContentItem;+use pretty_assertions::assert_eq;++#[test]+fn extraction_chunks_preserve_unicode_evidence_with_bounded_messages() {+ let evidence = "User correction: 🐈\n".repeat(2_000);+ let mut reconstructed = String::new();+ for message in MemoryContextFragment::extraction_messages(&evidence) {+ let ResponseItem::Message { role, content, .. } = message else {+ panic!("message")+ };+ assert_eq!(role, "user");+ let [ContentItem::InputText { text }] = content.as_slice() else {+ panic!("text")+ };+ assert!(text.len() < 9_000);+ reconstructed.push_str(text);+ }+ assert_eq!(reconstructed, evidence);+}diff --git a/codex-rs/core/src/context/mod.rs b/codex-rs/core/src/context/mod.rsindex 23b5a97e9f..832cbce3b3 100644--- a/codex-rs/core/src/context/mod.rs+++ b/codex-rs/core/src/context/mod.rs@@ -24,6 +24,7 @@ mod internal_model_context;mod legacy_apply_patch_exec_command_warning;mod legacy_model_mismatch_warning;mod legacy_unified_exec_process_limit_warning;+mod memory;mod model_switch_instructions;mod multi_agent_mode_instructions;mod multi_agent_role_instructions;@@ -87,6 +88,7 @@ pub use internal_model_context::InvalidInternalContextSource;pub(crate) use legacy_apply_patch_exec_command_warning::LegacyApplyPatchExecCommandWarning;pub(crate) use legacy_model_mismatch_warning::LegacyModelMismatchWarning;pub(crate) use legacy_unified_exec_process_limit_warning::LegacyUnifiedExecProcessLimitWarning;+pub use memory::MemoryContextFragment;pub(crate) use model_switch_instructions::ModelSwitchInstructions;pub(crate) use multi_agent_mode_instructions::MultiAgentModeInstructions;pub(crate) use multi_agent_role_instructions::MultiAgentRoleInstructions;diff --git a/codex-rs/memories/write/src/lib.rs b/codex-rs/memories/write/src/lib.rsindex c4e4da6463..616753603f 100644--- a/codex-rs/memories/write/src/lib.rs+++ b/codex-rs/memories/write/src/lib.rs@@ -11,6 +11,7 @@ mod metrics;mod phase1;mod phase2;mod prompts;+mod rollout_input;mod runtime;mod start;mod storage;diff --git a/codex-rs/memories/write/src/phase1.rs b/codex-rs/memories/write/src/phase1.rsindex 9f7d7ff1ea..a66e36d542 100644--- a/codex-rs/memories/write/src/phase1.rs+++ b/codex-rs/memories/write/src/phase1.rs@@ -3,12 +3,14 @@ use crate::metrics::MEMORY_PHASE_ONE_E2E_MS;use crate::metrics::MEMORY_PHASE_ONE_JOBS;use crate::metrics::MEMORY_PHASE_ONE_OUTPUT;use crate::metrics::MEMORY_PHASE_ONE_TOKEN_USAGE;+use crate::rollout_input::sanitize_response_item_for_memories;use crate::runtime::MemoryStartupContext;use crate::runtime::StageOneRequestContext;use codex_config::types::MemoriesConfig;use codex_core::Prompt;use codex_core::RolloutRecorder;use codex_core::config::Config;+use codex_protocol::MemoryVersion;use codex_protocol::ResponseItemId;use codex_protocol::error::CodexErr;use codex_protocol::models::BaseInstructions;@@ -17,7 +19,6 @@ use codex_protocol::models::ResponseItem;use codex_protocol::protocol::TokenUsage;use codex_rollout::INTERACTIVE_SESSION_SOURCES;use codex_rollout::RolloutItem;-use codex_rollout::should_persist_response_item_for_memories;use codex_secrets::redact_secrets;use futures::StreamExt;use serde::Deserialize;@@ -287,7 +288,13 @@ mod job {stage_one_context: &StageOneRequestContext,) -> anyhow::Result<(StageOneOutput, Option<TokenUsage>)> {let (rollout_items, _, _) = RolloutRecorder::load_rollout_items(rollout_path).await?;- let rollout_contents = serialize_filtered_rollout_response_items(&rollout_items)?;+ let rollout_contents = match config.memories.version {+ MemoryVersion::V1 => serialize_filtered_rollout_response_items(&rollout_items)?,+ MemoryVersion::V2 => crate::rollout_input::serialize_tiered_input(+ &rollout_items,+ crate::prompts::rollout_token_limit(&stage_one_context.model_info),+ )?,+ };let mut prompt = Prompt::default();prompt.input = vec![ResponseItem::Message {@@ -426,105 +433,10 @@ mod job {Ok(redact_secrets(serialized))}- fn sanitize_response_item_for_memories(item: &ResponseItem) -> Option<ResponseItem> {- let ResponseItem::Message {- id,- role,- content,- phase,- internal_chat_message_metadata_passthrough: metadata,- } = item- else {- return should_persist_response_item_for_memories(item).then(|| item.clone());- };-- if role == "developer" {- return None;- }-- if role != "user" {- return Some(item.clone());- }-- let content = content- .iter()- .filter(|content_item| !is_memory_excluded_contextual_user_fragment(content_item))- .cloned()- .collect::<Vec<_>>();- if content.is_empty() {- return None;- }-- Some(ResponseItem::Message {- id: id.clone(),- role: role.clone(),- content,- phase: phase.clone(),- internal_chat_message_metadata_passthrough: metadata.clone(),- })- }-- fn is_memory_excluded_contextual_user_fragment(content_item: &ContentItem) -> bool {- let ContentItem::InputText { text } = content_item else {- return false;- };-- matches_marked_fragment(text, "# AGENTS.md instructions", "</INSTRUCTIONS>")- || matches_marked_fragment(text, "<skill>", "</skill>")- }-- fn matches_marked_fragment(text: &str, start_marker: &str, end_marker: &str) -> bool {- let trimmed = text.trim_start();- let starts_with_marker = trimmed- .get(..start_marker.len())- .is_some_and(|candidate| candidate.eq_ignore_ascii_case(start_marker));- let trimmed = trimmed.trim_end();- let ends_with_marker = trimmed- .get(trimmed.len().saturating_sub(end_marker.len())..)- .is_some_and(|candidate| candidate.eq_ignore_ascii_case(end_marker));- starts_with_marker && ends_with_marker- }-#[cfg(test)]mod tests {use super::*;- #[test]- fn classifies_memory_excluded_fragments() {- let cases = [- (- "# AGENTS.md instructions for /tmp\n\n<INSTRUCTIONS>\nbody\n</INSTRUCTIONS>",- true,- ),- (- "# AGENTS.md instructions\n\n<INSTRUCTIONS>\nbody\n</INSTRUCTIONS>",- true,- ),- (- "<skill>\n<name>demo</name>\n<path>skills/demo/SKILL.md</path>\nbody\n</skill>",- true,- ),- (- "<environment_context>\n<cwd>/tmp</cwd>\n</environment_context>",- false,- ),- (- "<subagent_notification>{\"agent_id\":\"a\",\"status\":\"completed\"}</subagent_notification>",- false,- ),- ];-- for (text, expected) in cases {- assert_eq!(- is_memory_excluded_contextual_user_fragment(&ContentItem::InputText {- text: text.to_string(),- }),- expected,- "{text}",- );- }- }-#[test]fn output_schema_requires_rollout_slug_and_keeps_it_nullable() {let schema = output_schema();diff --git a/codex-rs/memories/write/src/prompts.rs b/codex-rs/memories/write/src/prompts.rsindex e0019f610f..9b536c4b87 100644--- a/codex-rs/memories/write/src/prompts.rs+++ b/codex-rs/memories/write/src/prompts.rs@@ -95,6 +95,16 @@ fn render_memory_extensions_block(template: &Template, memory_extensions_root: &})}+pub(crate) fn rollout_token_limit(model_info: &ModelInfo) -> usize {+ model_info+ .resolved_context_window()+ .and_then(|limit| (limit > 0).then_some(limit))+ .map(|limit| limit.saturating_mul(model_info.effective_context_window_percent) / 100)+ .map(|limit| (limit.saturating_mul(crate::stage_one::CONTEXT_WINDOW_PERCENT) / 100).max(1))+ .and_then(|limit| usize::try_from(limit).ok())+ .unwrap_or(crate::stage_one::DEFAULT_ROLLOUT_TOKEN_LIMIT)+}+/// Builds the stage-1 user message containing rollout metadata and content.////// Large rollout payloads are truncated to 70% of the active model's effective@@ -105,13 +115,7 @@ pub fn build_stage_one_input_message(rollout_cwd: &Path,rollout_contents: &str,) -> anyhow::Result<String> {- let rollout_token_limit = model_info- .resolved_context_window()- .and_then(|limit| (limit > 0).then_some(limit))- .map(|limit| limit.saturating_mul(model_info.effective_context_window_percent) / 100)- .map(|limit| (limit.saturating_mul(crate::stage_one::CONTEXT_WINDOW_PERCENT) / 100).max(1))- .and_then(|limit| usize::try_from(limit).ok())- .unwrap_or(crate::stage_one::DEFAULT_ROLLOUT_TOKEN_LIMIT);+ let rollout_token_limit = rollout_token_limit(model_info);let truncated_rollout_contents = truncate_text(rollout_contents,TruncationPolicy::Tokens(rollout_token_limit),diff --git a/codex-rs/memories/write/src/rollout_input.rs b/codex-rs/memories/write/src/rollout_input.rsnew file mode 100644index 0000000000..1e99325cfd--- /dev/null+++ b/codex-rs/memories/write/src/rollout_input.rs@@ -0,0 +1,305 @@+//! Selects v2 extraction evidence by provenance, then restores chronological order.+//! Human replies retain their questions; message media is replaced with placeholders.+//! Budgets use the same token estimate as the rest of the memory pipeline.++use codex_protocol::ToolName;+use codex_protocol::models::ContentItem;+use codex_protocol::models::MessagePhase;+use codex_protocol::models::ResponseItem;+use codex_protocol::protocol::InterAgentCommunication;+use codex_protocol::request_user_input::RequestUserInputResponse;+use codex_rollout::RolloutItem;+use codex_rollout::should_persist_response_item_for_memories;+use codex_secrets::redact_secrets;+use codex_utils_output_truncation::TruncationPolicy;+use codex_utils_output_truncation::approx_bytes_for_tokens;+use codex_utils_output_truncation::truncate_text;+use std::collections::HashMap;++const OMITTED: &str = "[... response items omitted ...]\n";+const TRUNCATION_RESERVE_BYTES: usize = 96;+const TOOL_OUTPUT_TOKENS: usize = 2_000;+const MAX_ROW_BYTES: usize = 10_000;++#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]+enum Tier {+ Human,+ Final,+ OtherAgent,+ Commentary,+ Context,+ Tool,+}++/// Select newest evidence first within each tier, but render in source order.+pub(crate) fn serialize_tiered_input(+ items: &[RolloutItem],+ token_limit: usize,+) -> anyhow::Result<String> {+ let mut rows = Vec::new();+ let mut user_input_calls = HashMap::new();+ for item in items {+ let item = match item {+ RolloutItem::ResponseItem(item) => sanitize_response_item_for_memories(&item.item),+ RolloutItem::InterAgentCommunication(message) => Some(message.to_model_input_item()),+ RolloutItem::SessionMeta(_)+ | RolloutItem::InterAgentCommunicationMetadata { .. }+ | RolloutItem::Compacted(_)+ | RolloutItem::TurnContext(_)+ | RolloutItem::RealtimeItem(_)+ | RolloutItem::WorldState(_)+ | RolloutItem::SecurityRiskScore(_)+ | RolloutItem::TokenUsageRecord(_)+ | RolloutItem::RetainedContext(_)+ | RolloutItem::EventMsg(_) => None,+ };+ let Some(mut item) = item else { continue };+ if let ResponseItem::Message { content, .. } = &mut item {+ for part in content {+ match part {+ ContentItem::InputImage { .. } => {+ *part = ContentItem::InputText {+ text: "[image omitted]".into(),+ };+ }+ ContentItem::InputAudio { .. } => {+ *part = ContentItem::InputText {+ text: "[audio omitted]".into(),+ };+ }+ ContentItem::InputText { .. } | ContentItem::OutputText { .. } => {}+ }+ }+ }+ let question = match &item {+ ResponseItem::FunctionCall {+ name,+ namespace,+ call_id,+ arguments,+ ..+ } if name == "request_user_input"+ && ToolName::new(namespace.clone(), name).is_default_namespace() =>+ {+ user_input_calls.insert(call_id.clone(), arguments.clone());+ None+ }+ ResponseItem::FunctionCallOutput {+ call_id: Some(call_id),+ output,+ ..+ } if user_input_calls.contains_key(call_id)+ && output+ .text_content()+ .and_then(|text| serde_json::from_str::<RequestUserInputResponse>(text).ok())+ .is_some_and(|reply| {+ reply+ .answers+ .values()+ .any(|answer| answer.answers.iter().any(|text| !text.trim().is_empty()))+ }) =>+ {+ user_input_calls.remove(call_id)+ }+ _ => None,+ };+ let tier = match &item {+ ResponseItem::FunctionCallOutput { .. } if question.is_some() => Tier::Human,+ ResponseItem::AgentMessage { .. } => Tier::OtherAgent,+ ResponseItem::Message {+ role,+ content,+ phase,+ internal_chat_message_metadata_passthrough,+ ..+ } => {+ let agent_content = internal_chat_message_metadata_passthrough+ .as_ref()+ .and_then(|metadata| metadata.content_item_kinds.as_ref())+ .is_some_and(|kinds| {+ kinds.iter().any(|kind| kind.0.starts_with("multi_agent."))+ })+ || InterAgentCommunication::is_message_content(content)+ || content.iter().any(|part| match part {+ ContentItem::InputText { text } | ContentItem::OutputText { text } => {+ let text = text.trim_start();+ text.starts_with("<subagent_notification>")+ || (text.starts_with("Message Type:")+ && text+ .lines()+ .nth(1)+ .is_some_and(|line| line.starts_with("Task name:"))+ && text+ .lines()+ .nth(2)+ .is_some_and(|line| line.starts_with("Sender:"))+ && text.lines().nth(3) == Some("Payload:"))+ }+ _ => false,+ });+ if agent_content {+ Tier::OtherAgent+ } else if role == "user" {+ let contextual = internal_chat_message_metadata_passthrough.as_ref()+ .and_then(|metadata| metadata.content_item_kinds.as_ref())+ .is_some_and(|kinds| !kinds.is_empty() && kinds.iter().all(|kind| !kind.0.starts_with("user.")))+ || content.iter().any(|part| matches!(part, ContentItem::InputText { text }+ if matches_marked_fragment(text, "<environment_context>", "</environment_context>")));+ if contextual {+ Tier::Context+ } else {+ Tier::Human+ }+ } else if matches!(phase, Some(MessagePhase::Commentary)) {+ Tier::Commentary+ } else {+ Tier::Final+ }+ }+ _ => Tier::Tool,+ };+ let label = match tier {+ Tier::Human => "human user",+ Tier::Final => "assistant final",+ Tier::Commentary => "assistant commentary",+ Tier::OtherAgent => "other agent",+ Tier::Context => "harness context",+ Tier::Tool => "tool",+ };+ let text = serde_json::to_string(&item)?;+ let mut text = redact_secrets(match question {+ Some(question) => format!("Assistant question: {question}\nHuman reply: {text}"),+ None => text,+ });+ if tier == Tier::Tool+ && matches!(+ item,+ ResponseItem::FunctionCallOutput { .. }+ | ResponseItem::CustomToolCallOutput { .. }+ | ResponseItem::ToolSearchOutput { .. }+ )+ {+ text = truncate_text(+ &text,+ TruncationPolicy::Bytes(+ approx_bytes_for_tokens(TOOL_OUTPUT_TOKENS)+ .saturating_sub(TRUNCATION_RESERVE_BYTES),+ ),+ );+ }+ text = truncate_text(+ &text,+ TruncationPolicy::Bytes(MAX_ROW_BYTES - TRUNCATION_RESERVE_BYTES),+ );+ rows.push((tier, format!("[{label}]\n{text}\n")));+ }+ let mut remaining = approx_bytes_for_tokens(token_limit).saturating_sub(OMITTED.len());+ let mut selected = vec![None; rows.len()];+ for tier in [+ Tier::Human,+ Tier::Final,+ Tier::OtherAgent,+ Tier::Commentary,+ Tier::Context,+ Tier::Tool,+ ] {+ for (index, (row_tier, text)) in rows.iter().enumerate().rev() {+ if *row_tier != tier || remaining <= OMITTED.len() + TRUNCATION_RESERVE_BYTES {+ continue;+ }+ let budget = remaining - OMITTED.len();+ let text = if text.len() <= budget {+ text.clone()+ } else {+ truncate_text(+ text,+ TruncationPolicy::Bytes(budget - TRUNCATION_RESERVE_BYTES),+ )+ };+ remaining = remaining.saturating_sub(text.len() + OMITTED.len());+ selected[index] = Some(text);+ }+ }+ let mut rendered = String::new();+ let mut gap = false;+ for row in selected {+ match row {+ Some(text) => {+ rendered.push_str(&text);+ gap = false;+ }+ None if !gap => {+ rendered.push_str(OMITTED);+ gap = true;+ }+ None => {}+ }+ }+ if rendered.len() > approx_bytes_for_tokens(token_limit) {+ return Ok(String::new());+ }+ Ok(rendered)+}++pub(crate) fn sanitize_response_item_for_memories(item: &ResponseItem) -> Option<ResponseItem> {+ let ResponseItem::Message {+ id,+ role,+ content,+ phase,+ internal_chat_message_metadata_passthrough: metadata,+ } = item+ else {+ return should_persist_response_item_for_memories(item).then(|| item.clone());+ };++ if role == "developer" {+ return None;+ }++ if role != "user" {+ return Some(item.clone());+ }++ let content = content+ .iter()+ .filter(|content_item| !is_memory_excluded_contextual_user_fragment(content_item))+ .cloned()+ .collect::<Vec<_>>();+ if content.is_empty() {+ return None;+ }++ Some(ResponseItem::Message {+ id: id.clone(),+ role: role.clone(),+ content,+ phase: phase.clone(),+ internal_chat_message_metadata_passthrough: metadata.clone(),+ })+}++fn is_memory_excluded_contextual_user_fragment(content_item: &ContentItem) -> bool {+ let ContentItem::InputText { text } = content_item else {+ return false;+ };++ matches_marked_fragment(text, "# AGENTS.md instructions", "</INSTRUCTIONS>")+ || matches_marked_fragment(text, "<skill>", "</skill>")+}++fn matches_marked_fragment(text: &str, start_marker: &str, end_marker: &str) -> bool {+ let trimmed = text.trim_start();+ let starts_with_marker = trimmed+ .get(..start_marker.len())+ .is_some_and(|candidate| candidate.eq_ignore_ascii_case(start_marker));+ let trimmed = trimmed.trim_end();+ let ends_with_marker = trimmed+ .get(trimmed.len().saturating_sub(end_marker.len())..)+ .is_some_and(|candidate| candidate.eq_ignore_ascii_case(end_marker));+ starts_with_marker && ends_with_marker+}++#[cfg(test)]+#[path = "rollout_input_tests.rs"]+mod tests;diff --git a/codex-rs/memories/write/src/rollout_input_tests.rs b/codex-rs/memories/write/src/rollout_input_tests.rsnew file mode 100644index 0000000000..c2f4baafd8--- /dev/null+++ b/codex-rs/memories/write/src/rollout_input_tests.rs@@ -0,0 +1,38 @@+use super::*;+use pretty_assertions::assert_eq;++#[test]+fn classifies_memory_excluded_fragments() {+ let cases = [+ (+ "# AGENTS.md instructions for /tmp\n\n<INSTRUCTIONS>\nbody\n</INSTRUCTIONS>",+ true,+ ),+ (+ "# AGENTS.md instructions\n\n<INSTRUCTIONS>\nbody\n</INSTRUCTIONS>",+ true,+ ),+ (+ "<skill>\n<name>demo</name>\n<path>skills/demo/SKILL.md</path>\nbody\n</skill>",+ true,+ ),+ (+ "<environment_context>\n<cwd>/tmp</cwd>\n</environment_context>",+ false,+ ),+ (+ "<subagent_notification>{\"agent_id\":\"a\",\"status\":\"completed\"}</subagent_notification>",+ false,+ ),+ ];++ for (text, expected) in cases {+ assert_eq!(+ is_memory_excluded_contextual_user_fragment(&ContentItem::InputText {+ text: text.to_string(),+ }),+ expected,+ "{text}",+ );+ }+}diff --git a/codex-rs/memories/write/src/startup_tests.rs b/codex-rs/memories/write/src/startup_tests.rsindex 4771d42029..87190d1d68 100644--- a/codex-rs/memories/write/src/startup_tests.rs+++ b/codex-rs/memories/write/src/startup_tests.rs@@ -1248,3 +1248,18 @@ async fn shutdown_test_codex(test: &TestCodex) -> anyhow::Result<()> {wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await;Ok(())}++#[tokio::test]+async fn memories_startup_phase1_v2_uses_tiered_input() -> anyhow::Result<()> {+ let server = start_mock_server().await;+ let home = Arc::new(TempDir::new()?);+ let mut memories = startup_test_memories_config();+ memories.version = codex_protocol::MemoryVersion::V2;+ let request = run_memory_phase_one_model_request_test(&server, home, memories).await?;+ assert!(+ request.body_json()["input"]+ .to_string()+ .contains("[human user]")+ );+ Ok(())+}