Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

16.9 KB
Raw Blame
//! Transcript-level tests for `threads::ops::edit`'s private truncation
//! helpers (`truncate_transcript_before_turn`, `truncate_transcript_for_regenerate`).
//!
//! Every fixture is written through the transcript port the session host
//! writes through (`TranscriptStore::locator` -> `open_session` +
//! `append_turn`), never through a file path, so the helpers are exercised
//! against exactly the store and key a real turn lands in. See
//! `edit_turn_state_tests.rs` for `clear_dropped_turn_states` /
//! `next_reply_request_id_after`, which need different fixtures (turn-state
//! snapshots, the message-log store).

use super::*;
use std::path::Path;
use tempfile::TempDir;
use tinyagents_session::transcript::{MessageUsage, TranscriptTurn, TurnUsage};

const AGENT_ID: &str = "test-agent";
/// The store key a desktop turn of the default chat agent is written under.
const STORE_KEY: &str = "orchestrator";

fn store(workspace: &Path) -> TranscriptStore {
    // Sealing a generation writes under a lease condition the in-memory test
    // backend cannot enforce, so the workspace opens its durable default.
    #[cfg(feature = "storage-sqlite")]
    crate::storage::local::use_persistent_default_for_test(workspace);
    TranscriptStore {
        workspace_dir: workspace.to_path_buf(),
        key: STORE_KEY.to_string(),
    }
}

fn base_meta(agent_id: &str, thread_id: &str) -> TranscriptMeta {
    TranscriptMeta {
        agent_name: agent_id.to_string(),
        agent_id: Some(agent_id.to_string()),
        agent_type: Some("test".into()),
        dispatcher: "native".into(),
        provider: Some("openhuman".into()),
        model: Some("test-model".into()),
        created: "2026-09-24T00:00:00Z".into(),
        updated: "2026-09-24T00:00:00Z".into(),
        turn_count: 0,
        prefix_message_count: None,
        prefix_reset: false,
        input_tokens: 0,
        output_tokens: 0,
        cached_input_tokens: 0,
        charged_amount_usd: 0.0,
        thread_id: Some(thread_id.to_string()),
        task_id: None,
        session_id: None,
        parent_session_id: None,
    }
}

fn turn_usage() -> TurnUsage {
    TurnUsage {
        provider: "openhuman".into(),
        model: "test-model".into(),
        usage: MessageUsage {
            input: 10,
            output: 5,
            cached_input: 0,
            context_window: 1_000_000,
            cost_usd: 0.0,
            ..Default::default()
        },
        ts: "2026-09-24T00:00:01Z".into(),
        reasoning_content: None,
        tool_calls: Vec::new(),
        iteration: 1,
    }
}

/// Write a two-turn root transcript for `thread_id`/`AGENT_ID` into `store`
/// the way the session host does, and return the two turns' `request_id`s.
fn write_two_turn_transcript(store: &TranscriptStore, thread_id: &str) -> (String, String) {
    let session = SessionRef::scoped(thread_id, AGENT_ID);
    let meta = base_meta(AGENT_ID, thread_id);
    let history = store
        .locator()
        .open_session(&session, meta.clone())
        .expect("open fixture session");
    let req1 = "turn-1".to_string();
    let req2 = "turn-2".to_string();

    let turn1 = vec![
        TranscriptMessage::new("user", "user prompt 1"),
        TranscriptMessage::assistant("answer 1"),
    ];
    let mut turn1_meta = meta.clone();
    turn1_meta.turn_count = 1;
    history
        .append_turn(TranscriptTurn {
            prev: &[],
            next: &turn1,
            meta: &turn1_meta,
            turn_usage: Some(&turn_usage()),
            request_id: Some(&req1),
            tools: None,
        })
        .expect("append turn 1");

    let mut turn2 = turn1.clone();
    turn2.push(TranscriptMessage::new("user", "user prompt 2"));
    turn2.push(TranscriptMessage::assistant("answer 2"));
    let mut turn2_meta = meta;
    turn2_meta.turn_count = 2;
    history
        .append_turn(TranscriptTurn {
            prev: &turn1,
            next: &turn2,
            meta: &turn2_meta,
            turn_usage: Some(&turn_usage()),
            request_id: Some(&req2),
            tools: None,
        })
        .expect("append turn 2");

    (req1, req2)
}

/// A root transcript with a single system row and no user/assistant turn at
/// all — feeds the "nothing to regenerate" `Ok(None)` case.
fn write_turnless_transcript(store: &TranscriptStore, thread_id: &str) {
    let session = SessionRef::scoped(thread_id, AGENT_ID);
    let meta = base_meta(AGENT_ID, thread_id);
    let messages = vec![TranscriptMessage::new("system", "boot preamble")];
    store
        .locator()
        .open_session(&session, meta.clone())
        .expect("open fixture session")
        .append_turn(TranscriptTurn {
            prev: &[],
            next: &messages,
            meta: &meta,
            turn_usage: None,
            request_id: None,
            tools: None,
        })
        .expect("append system row");
}

/// The first (sealed) generation of the thread's session, read back through
/// the store: a fork never erases it.
fn sealed_generation(store: &TranscriptStore, thread_id: &str) -> Vec<TranscriptMessage> {
    store
        .locator()
        .read_session_transcript(&SessionRef::scoped(thread_id, AGENT_ID))
        .expect("sealed generation stays in the store")
        .read_session()
        .expect("read sealed")
        .expect("sealed transcript exists")
        .messages
}

#[test]
fn truncate_transcript_before_turn_cuts_head_and_keeps_the_sealed_generation() {
    let dir = TempDir::new().expect("tempdir");
    let store = store(dir.path());
    let thread_id = "thread-before-turn";
    let (req1, req2) = write_two_turn_transcript(&store, thread_id);

    truncate_transcript_before_turn(&store, thread_id, &req2).expect("truncate");

    // Head truncated: the new head ends right before turn 2's first row.
    let (head_ref, _, head) = resolve_head_transcript(&store, thread_id).expect("resolve head");
    assert_eq!(
        head_ref.generation, 1,
        "the fork opened the next generation"
    );
    assert!(
        head.messages
            .iter()
            .all(|m| m.request_id.as_deref() != Some(req2.as_str())),
        "turn 2 must be entirely dropped from the head: {:?}",
        head.messages
    );
    let last = head.messages.last().expect("head keeps turn 1");
    assert_eq!(last.request_id.as_deref(), Some(req1.as_str()));
    assert_eq!(last.content, "answer 1", "turn 1's answer is kept intact");

    // "A compaction never erases" applies identically to this edit-driven
    // fork: the sealed generation still holds both turns.
    assert!(
        sealed_generation(&store, thread_id)
            .iter()
            .any(|m| m.request_id.as_deref() == Some(req2.as_str())),
        "the sealed generation keeps the dropped turn"
    );
}

#[test]
fn truncate_transcript_before_turn_errs_when_turn_not_found() {
    let dir = TempDir::new().expect("tempdir");
    let store = store(dir.path());
    let thread_id = "thread-missing-turn";
    write_two_turn_transcript(&store, thread_id);

    let err = truncate_transcript_before_turn(&store, thread_id, "no-such-turn")
        .expect_err("unknown request_id must fail");
    assert!(
        err.contains("no-such-turn"),
        "error should name the missing turn: {err}"
    );
}

#[test]
fn truncate_transcript_before_turn_errs_when_thread_has_no_transcript() {
    let dir = TempDir::new().expect("tempdir");
    let err = truncate_transcript_before_turn(&store(dir.path()), "thread-none", "turn-1")
        .expect_err("a thread with no transcript has nothing to cut");
    assert!(err.contains("has no session transcript"), "{err}");
}

#[test]
fn truncate_transcript_for_regenerate_targets_specific_turn() {
    let dir = TempDir::new().expect("tempdir");
    let store = store(dir.path());
    let thread_id = "thread-regen-target";
    let (_req1, req2) = write_two_turn_transcript(&store, thread_id);

    let (prompt, request_id) = truncate_transcript_for_regenerate(&store, thread_id, Some(&req2))
        .expect("truncate")
        .expect("a turn to regenerate");
    assert_eq!(prompt, "user prompt 2");
    assert_eq!(request_id, req2);

    let (_, _, head) = resolve_head_transcript(&store, thread_id).expect("resolve head");
    let last = head.messages.last().expect("head keeps turn 2's prompt");
    assert_eq!(last.role, "user");
    assert_eq!(last.content, "user prompt 2");
    assert!(
        head.messages.iter().all(|m| m.content != "answer 2"),
        "turn 2's answer must be dropped: {:?}",
        head.messages
    );
    assert!(
        sealed_generation(&store, thread_id)
            .iter()
            .any(|m| m.content == "answer 2"),
        "the sealed generation keeps the dropped answer"
    );
}

#[test]
fn truncate_transcript_for_regenerate_none_resolves_last_turn() {
    let dir = TempDir::new().expect("tempdir");
    let store = store(dir.path());
    let thread_id = "thread-regen-last";
    let (_req1, req2) = write_two_turn_transcript(&store, thread_id);

    let (prompt, request_id) = truncate_transcript_for_regenerate(&store, thread_id, None)
        .expect("truncate")
        .expect("a turn to regenerate");

    assert_eq!(prompt, "user prompt 2", "last turn's prompt is resent");
    assert_eq!(request_id, req2, "last turn's request_id is resolved");
}

#[test]
fn truncate_transcript_for_regenerate_returns_none_when_no_turn_exists() {
    let dir = TempDir::new().expect("tempdir");
    let store = store(dir.path());
    let thread_id = "thread-no-turns";
    write_turnless_transcript(&store, thread_id);

    let result = truncate_transcript_for_regenerate(&store, thread_id, None).expect("truncate");
    assert_eq!(result, None, "no user/assistant turn to regenerate");
}

/// Sentry TAURI-REACT-AK: regenerating on a thread that never wrote a session
/// transcript surfaced "thread <id> has no session transcript" instead of the
/// friendly "has no turn to regenerate" the caller maps `Ok(None)` to.
#[test]
fn truncate_transcript_for_regenerate_returns_none_when_thread_has_no_transcript() {
    let dir = TempDir::new().expect("tempdir");

    let result =
        truncate_transcript_for_regenerate(&store(dir.path()), "thread-without-transcript", None)
            .expect("a thread with no transcript has no turn to regenerate, not an error");
    assert_eq!(result, None);
}

/// A SaaS profile's turns are written under `<profile>~<agent>`. The edit
/// path resolves its key from the request's tenant (not the config alone),
/// so it finds and forks that same transcript, and the unprefixed key of the
/// same workspace never sees it.
#[test]
fn a_profile_prefixed_key_round_trips_through_edit_and_regenerate() {
    let dir = TempDir::new().expect("tempdir");
    #[cfg(feature = "storage-sqlite")]
    crate::storage::local::use_persistent_default_for_test(dir.path());
    let config = crate::config::Config {
        workspace_dir: dir.path().to_path_buf(),
        ..crate::config::Config::default()
    };
    let tenant = crate::core::runtime::Tenant {
        profile: Some("profile-a".to_string()),
        agent: None,
    };

    // What the session host writes under: the ambient-tenant resolution, fed
    // the same tenant the request carries.
    let writer_key = crate::storage::sessions::agent_key_for(
        &tenant,
        &crate::web_chat::pick_target_agent_id(&config),
    );
    let store = super::super::support::transcript_store_for(&config, &tenant);
    assert_eq!(
        store.key, writer_key,
        "the reader resolves the writer's key"
    );
    assert_eq!(
        store.key, "profile-a~default",
        "the key keeps the profile prefix"
    );
    assert_eq!(store.workspace_dir, dir.path());

    let thread_id = "thread-profile";
    let (req1, req2) = write_two_turn_transcript(&store, thread_id);

    let unprefixed = TranscriptStore {
        workspace_dir: dir.path().to_path_buf(),
        key: crate::web_chat::pick_target_agent_id(&config),
    };
    assert_eq!(
        truncate_transcript_for_regenerate(&unprefixed, thread_id, None).expect("lookup"),
        None,
        "the config-only key does not see the profile's transcript"
    );

    truncate_transcript_before_turn(&store, thread_id, &req2).expect("edit forks the transcript");
    let (_, _, head) = resolve_head_transcript(&store, thread_id).expect("resolve head");
    assert_eq!(
        head.messages.last().and_then(|m| m.request_id.as_deref()),
        Some(req1.as_str()),
        "the edit cut the profile's own transcript"
    );

    let (prompt, request_id) = truncate_transcript_for_regenerate(&store, thread_id, None)
        .expect("regenerate")
        .expect("turn 1 is left to regenerate");
    assert_eq!(prompt, "user prompt 1");
    assert_eq!(request_id, req1);
}

#[test]
fn transcript_store_for_a_desktop_tenant_uses_the_chat_agent_and_an_embedded_agent_its_own() {
    let dir = TempDir::new().expect("tempdir");
    let config = crate::config::Config {
        workspace_dir: dir.path().to_path_buf(),
        ..crate::config::Config::default()
    };

    let desktop = super::super::support::transcript_store_for(
        &config,
        &crate::core::runtime::Tenant::default(),
    );
    assert_eq!(desktop.key, crate::web_chat::pick_target_agent_id(&config));

    let embedded = super::super::support::transcript_store_for(
        &config,
        &crate::core::runtime::Tenant {
            profile: None,
            agent: Some("agent-7".to_string()),
        },
    );
    assert_eq!(embedded.key, "agent-7");
}

/// The handler-level resolution: the key comes from the request's own
/// `DispatchCtx` (its profile), with no ambient context in scope.
#[tokio::test]
async fn transcript_store_reads_the_profile_from_the_request_context() {
    use crate::core::runtime::{ContextOverlay, CoreContext, DispatchCtx, DomainSet};
    let dir = TempDir::new().expect("tempdir");
    let config = crate::config::Config {
        workspace_dir: dir.path().to_path_buf(),
        ..crate::config::Config::default()
    };
    let overlay = ContextOverlay::new(
        config,
        DomainSet::kernel(),
        crate::tools::toolpacks::ToolGroups::none(),
    )
    .profile("profile-b");
    let ctx = DispatchCtx::new(CoreContext::for_test(DomainSet::full(), None).derive_with(overlay));

    let store = transcript_store(&ctx, "any-thread")
        .await
        .expect("resolve the store");
    assert_eq!(store.key, "profile-b~default");
    assert_eq!(store.workspace_dir, dir.path());
}

/// Edit and regenerate read the store the thread's first session recorded, so
/// they still find the earlier turns after `[agent] chat_agent_id` changed.
#[tokio::test]
async fn edit_and_regenerate_use_the_threads_recorded_key_after_a_chat_agent_change() {
    use crate::core::runtime::{ContextOverlay, CoreContext, DispatchCtx, DomainSet};
    let _ = crate::agent_registry::host_definition::AgentDefinitionRegistry::init_global_builtins();
    let dir = TempDir::new().expect("tempdir");
    #[cfg(feature = "storage-sqlite")]
    crate::storage::local::use_persistent_default_for_test(dir.path());
    let ctx_with = |chat_agent: Option<&str>| {
        let mut config = crate::config::Config {
            workspace_dir: dir.path().to_path_buf(),
            ..crate::config::Config::default()
        };
        config.agent.chat_agent_id = chat_agent.map(str::to_string);
        let overlay = ContextOverlay::new(
            config,
            DomainSet::kernel(),
            crate::tools::toolpacks::ToolGroups::none(),
        );
        DispatchCtx::new(CoreContext::for_test(DomainSet::full(), None).derive_with(overlay))
    };
    let (before, after) = (ctx_with(None), ctx_with(Some("summarizer")));
    let thread_id = "thread-flipped";

    // The first session records its key and writes the transcript there.
    let written = transcript_store(&before, thread_id).await.expect("store");
    let recorded = crate::threads::store::bind_transcript_key(
        &before,
        dir.path(),
        thread_id,
        written.key.clone(),
    )
    .await;
    assert_eq!(recorded, written.key);
    let (req1, req2) = write_two_turn_transcript(&written, thread_id);

    // After the flip the current rule names another store, the record wins.
    let flipped = transcript_store(&after, thread_id).await.expect("store");
    assert_eq!(flipped.key, written.key, "the recorded key is used");
    assert_ne!(
        transcript_store(&after, "unrecorded-thread")
            .await
            .expect("store")
            .key,
        written.key,
        "the chat agent change does move the derived key"
    );

    truncate_transcript_before_turn(&flipped, thread_id, &req2).expect("edit forks the transcript");
    let (_, _, head) = resolve_head_transcript(&flipped, thread_id).expect("resolve head");
    assert_eq!(
        head.messages.last().and_then(|m| m.request_id.as_deref()),
        Some(req1.as_str())
    );
    let (prompt, request_id) = truncate_transcript_for_regenerate(&flipped, thread_id, None)
        .expect("regenerate")
        .expect("turn 1 is left to regenerate");
    assert_eq!(prompt, "user prompt 1");
    assert_eq!(request_id, req1);
}