Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

13.9 KB
Raw Blame
use super::*;
use agent_client_protocol::schema::v1::{ContentBlock, TextContent};

fn entry(sequence: i64, input: JournalInput) -> JournalEntry {
    JournalEntry {
        sequence,
        turn: Some(TurnId::new("turn~test".into()).unwrap()),
        input,
    }
}
fn native(id: &str, method: &str, params: serde_json::Value) -> JournalInput {
    JournalInput::Native(NativeRecord::from_event(CloudEvent {
        id: id.into(),
        method: method.into(),
        params,
    }))
}
fn reduce(entries: &[JournalEntry]) -> Vec<serde_json::Value> {
    let mut machine = ReplayMachine::default();
    entries
        .iter()
        .flat_map(|entry| machine.push(entry).unwrap())
        .map(|event| serde_json::to_value(event).unwrap())
        .collect()
}
#[test]
fn live_and_serialized_replay_preserve_native_unknown_records_and_suppress_duplicate_output() {
    let inputs = vec![
        JournalInput::HistoryComplete,
        JournalInput::Prompt(vec![ContentBlock::Text(TextContent::new("hello"))]),
        JournalInput::Native(NativeRecord {
            event: "future-event".into(),
            id: None,
            data: "{\"item_type\":\"unknown\",\"future\":{\"kept\":true}}".into(),
        }),
        native(
            "one",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg","delta":"hello"}),
        ),
        native(
            "one",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg","delta":"hello"}),
        ),
        native(
            "two",
            "item/completed",
            serde_json::json!({"item":{"id":"msg","type":"agentMessage","text":"hello"}}),
        ),
        JournalInput::TransportError("EOF".into()),
        JournalInput::RecoveryStarted,
    ];
    let entries: Vec<_> = inputs
        .into_iter()
        .enumerate()
        .map(|(index, input)| entry(index as i64 + 1, input))
        .collect();
    let encoded = serde_json::to_string(&entries).unwrap();
    assert!(encoded.contains("future-event"));
    let restored: Vec<JournalEntry> = serde_json::from_str(&encoded).unwrap();
    assert_eq!(reduce(&entries), reduce(&restored));
    assert_eq!(reduce(&entries).len(), 2);
}
#[test]
fn missing_history_and_sequence_gaps_fail_closed() {
    assert!(
        ReplayMachine::default()
            .push(&entry(1, JournalInput::RecoveryStarted))
            .is_err()
    );
    let mut machine = ReplayMachine::default();
    machine
        .push(&entry(1, JournalInput::HistoryComplete))
        .unwrap();
    assert!(
        machine
            .push(&entry(3, JournalInput::RecoveryStarted))
            .is_err()
    );
}
#[test]
fn completed_poll_fallback_is_emitted_once_across_repeated_recovery() {
    let snapshot = TaskSnapshot {
        pull_requests: vec![],
        native: None,
        task_id: super::super::cloud::CloudId::new("task-test".into()).unwrap(),
        title: None,
        assistant_status: Some("completed".into()),
        turns: vec![super::super::cloud::TurnSnapshot {
            source: "current_assistant_turn".into(),
            id: Some("turn~test".into()),
            messages: vec!["final output".into()],
            output_types: vec![],
            has_diff: false,
        }],
    };
    let mut machine = ReplayMachine::default();
    machine
        .push(&entry(1, JournalInput::HistoryComplete))
        .unwrap();
    machine
        .push(&entry(
            2,
            JournalInput::Poll {
                snapshot: snapshot.clone(),
                native: None,
            },
        ))
        .unwrap();
    assert!(
        machine
            .push(&entry(3, JournalInput::Terminal("completed".into())))
            .unwrap()
            .is_empty()
    );
    assert_eq!(machine.finish().len(), 2);
    machine
        .push(&entry(4, JournalInput::RecoveryStarted))
        .unwrap();
    machine
        .push(&entry(
            5,
            JournalInput::Poll {
                snapshot,
                native: None,
            },
        ))
        .unwrap();
    assert!(
        machine
            .push(&entry(6, JournalInput::Terminal("completed".into())))
            .unwrap()
            .is_empty()
    );
    assert!(machine.finish().is_empty());
}

#[test]
fn native_answer_recovered_after_snapshot_terminal_replaces_the_fallback() {
    let snapshot = TaskSnapshot {
        pull_requests: vec![],
        native: None,
        task_id: super::super::cloud::CloudId::new("task-test".into()).unwrap(),
        title: None,
        assistant_status: Some("completed".into()),
        turns: vec![super::super::cloud::TurnSnapshot {
            source: "current_assistant_turn".into(),
            id: Some("turn~test".into()),
            messages: vec!["answer".into()],
            output_types: vec![],
            has_diff: false,
        }],
    };
    let inputs = vec![
        JournalInput::HistoryComplete,
        JournalInput::Poll {
            snapshot,
            native: None,
        },
        JournalInput::Terminal("completed".into()),
        native(
            "late",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg","delta":"answer"}),
        ),
        JournalInput::Terminal("completed".into()),
    ];
    let mut machine = ReplayMachine::default();
    let mut output = Vec::new();
    for (index, input) in inputs.into_iter().enumerate() {
        output.extend(machine.push(&entry(index as i64 + 1, input)).unwrap());
    }
    output.extend(machine.finish());
    assert_eq!(
        output
            .iter()
            .filter(|event| event.method == "item/completed")
            .count(),
        1
    );
    assert_eq!(output.last().unwrap().method, "session/turn_complete");
}

#[test]
fn missing_and_reordered_deltas_never_corrupt_completed_message_live_or_replay() {
    let inputs = vec![
        JournalInput::HistoryComplete,
        native(
            "middle",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg", "delta":" is"}),
        ),
        native(
            "end",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg", "delta":"Codex."}),
        ),
        native(
            "complete",
            "item/completed",
            serde_json::json!({"item":{"id":"msg","type":"agentMessage","text":"My name is Codex."}}),
        ),
        native(
            "start",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg", "delta":"My name"}),
        ),
        native(
            "middle",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg", "delta":" is"}),
        ),
        native(
            "complete",
            "item/completed",
            serde_json::json!({"item":{"id":"msg","type":"agentMessage","text":"My name is Codex."}}),
        ),
    ];
    let entries: Vec<_> = inputs
        .into_iter()
        .enumerate()
        .map(|(index, input)| entry(index as i64 + 1, input))
        .collect();
    let output = reduce(&entries);
    assert_eq!(output.len(), 1);
    assert_eq!(output[0]["params"]["item"]["text"], "My name is Codex.");
    let replay: Vec<JournalEntry> =
        serde_json::from_str(&serde_json::to_string(&entries).unwrap()).unwrap();
    assert_eq!(reduce(&replay), output);
}

#[test]
fn terminal_poll_preserves_multiple_equal_messages_once_across_repeated_reads() {
    let snapshot = TaskSnapshot {
        pull_requests: vec![],
        native: None,
        task_id: super::super::cloud::CloudId::new("task-test".into()).unwrap(),
        title: None,
        assistant_status: Some("completed".into()),
        turns: vec![super::super::cloud::TurnSnapshot {
            source: "current_assistant_turn".into(),
            id: Some("turn~test".into()),
            messages: vec![
                "First message".into(),
                "Same message".into(),
                "Same message".into(),
            ],
            output_types: vec![],
            has_diff: false,
        }],
    };
    let inputs = vec![
        JournalInput::HistoryComplete,
        native(
            "fragment",
            "item/agentMessage/delta",
            serde_json::json!({"itemId":"msg","delta":" message"}),
        ),
        JournalInput::Poll {
            snapshot: snapshot.clone(),
            native: None,
        },
        JournalInput::Terminal("completed".into()),
    ];
    let mut machine = ReplayMachine::default();
    for (index, input) in inputs.into_iter().enumerate() {
        assert!(
            machine
                .push(&entry(index as i64 + 1, input))
                .unwrap()
                .is_empty()
        );
    }
    let output = machine.finish();
    assert_eq!(output.len(), 4);
    assert_eq!(output[0].params["item"]["text"], "First message");
    assert_eq!(output[1].params["item"]["text"], "Same message");
    assert_eq!(output[2].params["item"]["text"], "Same message");
    assert_ne!(
        output[1].params["item"]["id"],
        output[2].params["item"]["id"]
    );
    machine
        .push(&entry(
            5,
            JournalInput::Poll {
                snapshot,
                native: None,
            },
        ))
        .unwrap();
    assert!(machine.finish().is_empty());
}

#[test]
fn recorded_two_turn_conversation_has_identical_complete_live_and_replayed_answers() {
    let entries: Vec<JournalEntry> = serde_json::from_str(include_str!(
        "../../../tests/fixtures/missing_live_deltas.json"
    ))
    .unwrap();
    let mut live = ReplayMachine::default();
    let mut replay = ReplayMachine::default();
    let mut live_output = Vec::new();
    let mut replay_output = Vec::new();
    for entry in &entries {
        live_output.extend(live.push(entry).unwrap());
        if matches!(entry.input, JournalInput::Terminal(_)) {
            live_output.extend(live.finish());
        }
        replay_output.extend(replay.push(entry).unwrap());
    }
    replay_output.extend(replay.finish());
    let answers = |events: &[CloudEvent]| {
        events
            .iter()
            .filter(|event| {
                event.method == "item/completed" && event.params["item"]["type"] == "agentMessage"
            })
            .map(|event| event.params["item"]["text"].as_str().unwrap().to_owned())
            .collect::<Vec<_>>()
    };
    let actual = answers(&live_output);
    assert_eq!(actual, answers(&replay_output));
    assert_eq!(actual.len(), 3);
    assert_eq!(actual[0].chars().count(), 327);
    assert_eq!(actual[1].chars().count(), 688);
    assert_eq!(
        actual[2],
        "My name is **Codex**. I’m an AI coding assistant created by OpenAI."
    );
    for output in [&live_output, &replay_output] {
        assert!(
            !output
                .iter()
                .any(|event| event.method == "item/agentMessage/delta")
        );
        assert_eq!(
            output
                .iter()
                .filter(|event| event.method == "session/turn_complete")
                .count(),
            2
        );
    }
}

#[test]
fn cancelled_and_failed_turns_do_not_publish_unverified_fragments() {
    for status in ["cancelled", "failed"] {
        let mut machine = ReplayMachine::default();
        for (index, input) in [
            JournalInput::HistoryComplete,
            native(
                "fragment",
                "item/agentMessage/delta",
                serde_json::json!({"itemId":"msg","delta":" middle of a sentence"}),
            ),
            JournalInput::Terminal(status.into()),
        ]
        .into_iter()
        .enumerate()
        {
            assert!(
                machine
                    .push(&entry(index as i64 + 1, input))
                    .unwrap()
                    .is_empty()
            );
        }
        let output = machine.finish();
        assert_eq!(output.len(), 1);
        assert_eq!(output[0].method, "session/turn_complete");
        assert_eq!(output[0].params["status"], status);
    }
}

#[test]
fn native_completion_and_fragmented_poll_text_cover_each_other_without_duplicates() {
    let snapshot = TaskSnapshot {
        pull_requests: vec![],
        native: None,
        task_id: super::super::cloud::CloudId::new("task-test".into()).unwrap(),
        title: None,
        assistant_status: Some("completed".into()),
        turns: vec![super::super::cloud::TurnSnapshot {
            source: "current_assistant_turn".into(),
            id: Some("turn~test".into()),
            messages: vec!["Hello ".into(), "world".into()],
            output_types: vec![],
            has_diff: false,
        }],
    };
    let completion = native(
        "complete",
        "item/completed",
        serde_json::json!({
            "item":{"id":"msg","type":"agentMessage","text":"Hello world"}
        }),
    );
    for poll_first in [true, false] {
        let mut machine = ReplayMachine::default();
        machine
            .push(&entry(1, JournalInput::HistoryComplete))
            .unwrap();
        let mut sequence = 2;
        if !poll_first {
            assert_eq!(
                machine
                    .push(&entry(sequence, completion.clone()))
                    .unwrap()
                    .len(),
                1
            );
            sequence += 1;
        }
        machine
            .push(&entry(
                sequence,
                JournalInput::Poll {
                    snapshot: snapshot.clone(),
                    native: None,
                },
            ))
            .unwrap();
        machine
            .push(&entry(
                sequence + 1,
                JournalInput::Terminal("completed".into()),
            ))
            .unwrap();
        let output = machine.finish();
        assert_eq!(output.len(), if poll_first { 3 } else { 1 });
        if poll_first {
            assert!(
                machine
                    .push(&entry(sequence + 2, completion.clone()))
                    .unwrap()
                    .is_empty()
            );
        }
        assert!(machine.finish().is_empty());
    }
}