repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-cli/tests/e2e_context_edits.rs
Raw//! 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();
}