Luigit
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();
}