//! SMH-SPEC-SPEC0001: Sessions, Context edits; effective context through ordinary components. use assert_cmd::Command; use smith::config::Config; use smith::id::ToolCallId; use smith::message::{ContentBlock, Message, Role}; use smith::structured::ToolArguments; use smith_core::context::{ContextEdit, ContextReplacement}; use smith_core::session::{EntryContent, Session}; use smith_core::store::create_session; use std::io::{Read, Write}; use std::net::{TcpListener, TcpStream}; use std::path::Path; use std::time::Duration; fn smith(home: &Path) -> Command { let mut command = Command::cargo_bin("smith").unwrap(); command .current_dir(home) .timeout(Duration::from_secs(30)) .env("HOME", home) .env("XDG_CONFIG_HOME", home.join("config")) .env("XDG_DATA_HOME", home.join("data")) .env("XDG_STATE_HOME", home.join("state")) .env("XDG_CACHE_HOME", home.join("cache")) .env("XDG_RUNTIME_DIR", home.join("runtime")) .env_remove("SMITH_PROVIDER") .env_remove("SMITH_MODEL") .env_remove("SMITH_BASE_URL") .env_remove("ANTHROPIC_API_KEY") .env_remove("OPENAI_API_KEY") .env_remove("GEMINI_API_KEY") .env_remove("GOOGLE_API_KEY"); command } #[test] fn resumed_component_request_uses_atomic_edits_while_get_retains_originals() { let home = std::env::temp_dir().join(format!("sce-{:x}", smith::id::SessionId::new().as_u128())); std::fs::create_dir(&home).unwrap(); let mut session = Session::new(); let target = session .append(&EntryContent::Message(Message::with_text( Role::User, "raw-original", ))) .unwrap() .id; let omitted = session .append(&EntryContent::Message(Message::with_text( Role::User, "raw-omitted", ))) .unwrap() .id; let call_id = ToolCallId::new(); let mut call = Message::with_text(Role::Assistant, "raw assistant prose"); call.add_block(ContentBlock::tool_use( "read", ToolArguments::empty_object(), call_id, )); let assistant = session.append(&EntryContent::Message(call)).unwrap().id; session .append(&EntryContent::Meta { kind: smith_core::session::PROVIDER_TOOL_CALL_IDENTITIES_KIND.into(), detail: smith_core::metadata::encode( &smith_core::metadata::ProviderToolCallIdentityMetadata { call_id, provider_call_id: "fixture-provider-call".into(), }, ) .unwrap(), }) .unwrap(); session .append(&EntryContent::ToolCall { name: "read".into(), input: ToolArguments::empty_object(), call_id, }) .unwrap(); session .append(&EntryContent::ToolResult { call_id, ok: true, output: "immutable effect evidence".into(), }) .unwrap(); let mut result = Message::new(Role::Tool); result.add_block(ContentBlock::ToolResult { call_id, ok: true, output: "raw tool output".into(), }); let result = session.append(&EntryContent::Message(result)).unwrap().id; let id = session.id().to_string(); let path = home .join("data/smith/sessions/run") .join(format!("{id}.smh")); let mut opened = create_session(&path, &session, Config::default_valid()).unwrap(); // One fixed message, bounded large replacements, then the same tiny request. let mut parent = session.selected_id(); let superseded = "superseded-context-edit".repeat(2400); for _ in 0..100 { let entry = smith_core::session::EntryFrame::new( parent, &EntryContent::ContextEdit(vec![ContextEdit { target, replacement: Some(ContextReplacement::Text(superseded.clone())), }]), ) .unwrap(); parent = Some(entry.id); opened .writer .append_frame(&smith_core::frame::Frame::Known { entry }) .unwrap(); } opened .writer .edit_context(&[ ContextEdit { target, replacement: Some(ContextReplacement::Text("effective-replacement".into())), }, ContextEdit { target: assistant, replacement: Some(ContextReplacement::AssistantText( "effective assistant prose".into(), )), }, ContextEdit { target: result, replacement: Some(ContextReplacement::ToolResultOutput { call_id, output: "effective tool output".into(), }), }, ContextEdit { target: omitted, replacement: None, }, ]) .unwrap(); drop(opened); let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let address = listener.local_addr().unwrap(); let server = std::thread::spawn(move || { let (mut stream, _) = listener.accept().unwrap(); stream .set_read_timeout(Some(Duration::from_secs(10))) .unwrap(); stream .set_write_timeout(Some(Duration::from_secs(10))) .unwrap(); let mut request = Vec::new(); let mut buffer = [0; 4096]; let header_end = loop { let count = stream.read(&mut buffer).unwrap(); assert!(count > 0 && request.len() + count <= 1 << 20); request.extend_from_slice(&buffer[..count]); if let Some(index) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") { break index + 4; } }; let headers = std::str::from_utf8(&request[..header_end]).unwrap(); let length: usize = headers .lines() .find_map(|line| { line.to_ascii_lowercase() .strip_prefix("content-length: ") .and_then(|value| value.trim().parse().ok()) }) .unwrap(); assert!(header_end + length <= 1 << 20); while request.len() < header_end + length { let count = stream.read(&mut buffer).unwrap(); assert!(count > 0); request.extend_from_slice(&buffer[..count]); } let body: serde_json::Value = serde_json::from_slice(&request[header_end..header_end + length]).unwrap(); let response = "data: {\"choices\":[{\"delta\":{\"content\":\"edited response\"}}]}\n\ndata: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\ndata: [DONE]\n\n"; write!(stream, "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{response}", response.len()).unwrap(); body }); let output = smith(&home) .env("OPENAI_API_KEY", "context-fixture-secret") .args([ "eval", "--session", &id, "--provider", "openai", "--model", "test-model", "--base-url", &format!("http://{address}/v1"), "continue", ]) .output() .unwrap(); // Explicit wake-up even on failed startup; command + socket deadlines bound all waits. let _wake = TcpStream::connect_timeout(&address, Duration::from_secs(1)); assert!( output.status.success(), "{}", String::from_utf8_lossy(&output.stderr) ); assert_eq!(output.stdout, b"edited response\n"); let body = server.join().unwrap(); let messages = body["messages"].as_array().unwrap(); assert!( messages .iter() .any(|message| message["content"] == "effective-replacement") ); assert!(messages.iter().any(|message| message["role"] == "tool" && message["content"] == "effective tool output" && message["tool_call_id"] == "fixture-provider-call")); assert!(messages.iter().any(|message| message["role"] == "assistant" && message["content"] == "effective assistant prose" && message["tool_calls"][0]["id"] == "fixture-provider-call")); assert!(!body.to_string().contains("raw tool output")); assert!(!body.to_string().contains("immutable effect evidence")); assert!(!body.to_string().contains("raw-original")); assert!(!body.to_string().contains("superseded-context-edit")); assert!(!body.to_string().contains("raw-omitted")); let raw = smith(&home) .args(["sessions", "get", &id, "--json"]) .output() .unwrap(); assert!( raw.status.success(), "{}", String::from_utf8_lossy(&raw.stderr) ); let raw = String::from_utf8(raw.stdout).unwrap(); assert!(raw.contains("smith:protocol-openai-compatible")); assert!(raw.contains(smith_harness::protocol::embedded_openai_compatible_component_sha256())); assert!(raw.contains("raw tool output")); assert!(raw.contains("immutable effect evidence")); assert!(raw.contains("raw assistant prose")); assert!(raw.contains("raw-original")); assert!(raw.contains("superseded-context-edit")); assert!(raw.contains("raw-omitted")); assert!(!raw.contains("context-fixture-secret")); std::fs::remove_dir_all(home).unwrap(); }