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.

21.6 KB
Raw Blame
use crate::convert::*;
use crate::types::{AssistantMessagePart, ChatMessage, ChatMessageContent, Role};
use attachment::image::ImageData;
use attachment::{AttachmentContent, AttachmentPart, Attachments};
use model_entity::EntityType;
use non_empty::NonEmpty;
use rig_core::message::{
    AssistantContent, DocumentSourceKind, ImageMediaType, Message, UserContent,
};
use serde_json::json;

/// A minimal valid 1x1 PNG, used to exercise the image-normalization path.
#[rustfmt::skip]
const ONE_BY_ONE_PNG: &[u8] = &[
    0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
    0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, 0xDE, 0x00, 0x00, 0x00,
    0x0C, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0xF8, 0xCF, 0xC0, 0x00,
    0x00, 0x03, 0x01, 0x01, 0x00, 0xC9, 0xFE, 0x92, 0xEF, 0x00, 0x00, 0x00,
    0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
];

/// Build a user message carrying a single resolved attachment made of `parts`.
fn user_msg_with_attachment(text: &str, parts: Vec<AttachmentPart<'static>>) -> ChatMessage {
    let content = AttachmentContent {
        reference: EntityType::StaticFile.with_entity_string(String::new()),
        name: None,
        content: NonEmpty::new(parts).expect("at least one part"),
    };
    let attachments = Attachments::new(NonEmpty::one(Ok(content)));
    ChatMessage {
        role: Role::User,
        content: ChatMessageContent::Text(text.to_owned()),
        attachments: Some(attachments),
    }
}

fn user_msg(text: &str) -> ChatMessage {
    ChatMessage {
        role: Role::User,
        content: ChatMessageContent::Text(text.to_owned()),
        attachments: None,
    }
}

fn assistant_text(text: &str) -> ChatMessage {
    ChatMessage {
        role: Role::Assistant,
        content: ChatMessageContent::Text(text.to_owned()),
        attachments: None,
    }
}

fn system_msg(text: &str) -> ChatMessage {
    ChatMessage {
        role: Role::System,
        content: ChatMessageContent::Text(text.to_owned()),
        attachments: None,
    }
}

fn assistant_parts(parts: Vec<AssistantMessagePart>) -> ChatMessage {
    ChatMessage {
        role: Role::Assistant,
        content: ChatMessageContent::AssistantMessageParts(parts),
        attachments: None,
    }
}

#[test]
fn user_message_converts_to_rig_user() {
    let messages = to_rig_messages(&[user_msg("hello")]);
    assert_eq!(messages.len(), 1);
    assert!(matches!(&messages[0], Message::User { .. }));
    let Message::User { content } = &messages[0] else {
        panic!("expected user message");
    };
    let UserContent::Text(text) = content.first() else {
        panic!("expected text content");
    };
    assert_eq!(text.text, "hello");
}

#[test]
fn assistant_text_converts_to_rig_assistant() {
    let messages = to_rig_messages(&[assistant_text("hi back")]);
    assert_eq!(messages.len(), 1);
    assert!(matches!(&messages[0], Message::Assistant { .. }));
}

#[test]
fn system_messages_are_skipped() {
    let messages = to_rig_messages(&[system_msg("you are helpful"), user_msg("hi")]);
    assert_eq!(messages.len(), 1);
    assert!(matches!(&messages[0], Message::User { .. }));
}

#[test]
fn empty_input_produces_empty_output() {
    let messages = to_rig_messages(&[]);
    assert!(messages.is_empty());
}

#[test]
fn multi_turn_conversation() {
    let messages = to_rig_messages(&[
        user_msg("what is 2+2?"),
        assistant_text("4"),
        user_msg("thanks"),
    ]);
    assert_eq!(messages.len(), 3);
    assert!(matches!(&messages[0], Message::User { .. }));
    assert!(matches!(&messages[1], Message::Assistant { .. }));
    assert!(matches!(&messages[2], Message::User { .. }));
}

#[test]
fn tool_call_produces_assistant_with_tool_use() {
    let msg = assistant_parts(vec![AssistantMessagePart::ToolCall {
        name: "search".to_owned(),
        json: json!({"query": "test"}),
        id: "call_1".to_owned(),
    }]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 1);
    let Message::Assistant { content, .. } = &messages[0] else {
        panic!("expected assistant message");
    };
    assert!(matches!(content.first(), AssistantContent::ToolCall(_)));
}

#[test]
fn tool_call_with_response_splits_into_two_messages() {
    let msg = assistant_parts(vec![
        AssistantMessagePart::ToolCall {
            name: "search".to_owned(),
            json: json!({"query": "test"}),
            id: "call_1".to_owned(),
        },
        AssistantMessagePart::ToolCallResponseJson {
            name: "search".to_owned(),
            json: json!({"results": []}),
            id: "call_1".to_owned(),
        },
    ]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 2);
    assert!(matches!(&messages[0], Message::Assistant { .. }));
    assert!(matches!(&messages[1], Message::User { .. }));

    let Message::User { content } = &messages[1] else {
        panic!("expected user message with tool result");
    };
    assert!(matches!(content.first(), UserContent::ToolResult(_)));
}

#[test]
fn multiple_tool_calls_with_responses_stay_grouped() {
    let msg = assistant_parts(vec![
        AssistantMessagePart::ToolCall {
            name: "search".to_owned(),
            json: json!({"query": "a"}),
            id: "call_1".to_owned(),
        },
        AssistantMessagePart::ToolCall {
            name: "read".to_owned(),
            json: json!({"id": "doc_1"}),
            id: "call_2".to_owned(),
        },
        AssistantMessagePart::ToolCallResponseJson {
            name: "search".to_owned(),
            json: json!({"results": ["x"]}),
            id: "call_1".to_owned(),
        },
        AssistantMessagePart::ToolCallResponseJson {
            name: "read".to_owned(),
            json: json!({"content": "hello"}),
            id: "call_2".to_owned(),
        },
    ]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 2, "should be one assistant + one user");

    let Message::Assistant { content, .. } = &messages[0] else {
        panic!("expected assistant");
    };
    assert_eq!(content.len(), 2, "two tool calls in assistant message");

    let Message::User { content } = &messages[1] else {
        panic!("expected user");
    };
    assert_eq!(content.len(), 2, "two tool results in user message");
}

#[test]
fn tool_call_error_becomes_tool_result() {
    let msg = assistant_parts(vec![
        AssistantMessagePart::ToolCall {
            name: "delete".to_owned(),
            json: json!({"id": "x"}),
            id: "call_1".to_owned(),
        },
        AssistantMessagePart::ToolCallErr {
            name: "delete".to_owned(),
            description: "permission denied".to_owned(),
            id: "call_1".to_owned(),
        },
    ]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 2);

    let Message::User { content } = &messages[1] else {
        panic!("expected user message with tool result");
    };
    let UserContent::ToolResult(result) = content.first() else {
        panic!("expected tool result");
    };
    assert_eq!(result.id, "fc_call_1");
    assert_eq!(result.call_id.as_deref(), Some("call_1"));
}

#[test]
fn tool_call_round_trip_carries_call_id_and_fc_item_id() {
    let msg = assistant_parts(vec![
        AssistantMessagePart::ToolCall {
            name: "search".to_owned(),
            json: json!({"query": "test"}),
            id: "call_1".to_owned(),
        },
        AssistantMessagePart::ToolCallResponseJson {
            name: "search".to_owned(),
            json: json!({"results": []}),
            id: "call_1".to_owned(),
        },
    ]);
    let messages = to_rig_messages(&[msg]);

    let Message::Assistant { content, .. } = &messages[0] else {
        panic!("expected assistant");
    };
    let AssistantContent::ToolCall(call) = content.first() else {
        panic!("expected tool call");
    };
    assert_eq!(call.id, "fc_call_1");
    assert_eq!(call.call_id.as_deref(), Some("call_1"));

    let Message::User { content } = &messages[1] else {
        panic!("expected tool result user message");
    };
    let UserContent::ToolResult(result) = content.first() else {
        panic!("expected tool result");
    };
    assert_eq!(
        result.id, "fc_call_1",
        "result id must match the call's item id"
    );
    assert_eq!(result.call_id.as_deref(), Some("call_1"));
}

#[test]
fn trailing_separator_ids_are_trimmed_before_replay() {
    // A persisted nanoid can end in `_` or `-`; the OpenAI Responses API
    // rejects replayed `function_call` item ids / `call_id`s ending in a
    // separator. Both the item id and call_id must be trimmed, and a call and
    // its result must stay paired afterwards.
    for raw in ["74JQSgjB6MEaTtCNVdDG_", "abcDEF123-"] {
        let msg = assistant_parts(vec![
            AssistantMessagePart::ToolCall {
                name: "search".to_owned(),
                json: json!({}),
                id: raw.to_owned(),
            },
            AssistantMessagePart::ToolCallResponseJson {
                name: "search".to_owned(),
                json: json!({}),
                id: raw.to_owned(),
            },
        ]);
        let messages = to_rig_messages(&[msg]);

        let trimmed = raw.trim_end_matches(['_', '-']);
        let expected_item = format!("fc_{trimmed}");

        let Message::Assistant { content, .. } = &messages[0] else {
            panic!("expected assistant");
        };
        let AssistantContent::ToolCall(call) = content.first() else {
            panic!("expected tool call");
        };
        assert_eq!(call.id, expected_item, "item id must be trimmed for {raw}");
        assert_eq!(
            call.call_id.as_deref(),
            Some(trimmed),
            "call_id must be trimmed for {raw}"
        );
        assert!(
            !call.id.ends_with(['_', '-'])
                && !call.call_id.as_deref().unwrap().ends_with(['_', '-']),
            "no replayed id may end in a separator ({raw})"
        );

        let Message::User { content } = &messages[1] else {
            panic!("expected tool result");
        };
        let UserContent::ToolResult(result) = content.first() else {
            panic!("expected tool result");
        };
        // Result must pair to its call on both ids.
        assert_eq!(result.id, expected_item);
        assert_eq!(result.call_id.as_deref(), Some(trimmed));
    }
}

/// Anthropic's Messages API rejects a `tool_use.input` that is not a JSON
/// object. Older persisted messages may carry a non-object `json` (e.g. from
/// before the source of the value started guaranteeing an object); replay
/// must coerce it to `{}` rather than resending the bad value.
#[test]
fn tool_call_with_non_object_json_coerces_to_empty_object() {
    for bad in [json!(null), json!("oops"), json!([1, 2, 3])] {
        let msg = assistant_parts(vec![AssistantMessagePart::ToolCall {
            name: "ListSkills".to_owned(),
            json: bad.clone(),
            id: "call_1".to_owned(),
        }]);
        let messages = to_rig_messages(&[msg]);
        let Message::Assistant { content, .. } = &messages[0] else {
            panic!("expected assistant message");
        };
        let AssistantContent::ToolCall(call) = content.first() else {
            panic!("expected tool call");
        };
        assert_eq!(
            call.function.arguments,
            json!({}),
            "non-object json {bad:?} must coerce to an empty object"
        );
    }
}

#[test]
fn mcp_tool_call_converts_like_regular_tool_call() {
    let msg = assistant_parts(vec![AssistantMessagePart::McpToolCall {
        name: "slack_search".to_owned(),
        service: "slack".to_owned(),
        display_name: Some("Search Slack".to_owned()),
        json: json!({"query": "standup"}),
        id: "call_mcp".to_owned(),
    }]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 1);

    let Message::Assistant { content, .. } = &messages[0] else {
        panic!("expected assistant");
    };
    let AssistantContent::ToolCall(tc) = content.first() else {
        panic!("expected tool call");
    };
    assert_eq!(tc.function.name, "slack_search");
}

#[test]
fn adjacent_text_parts_are_merged() {
    let msg = assistant_parts(vec![
        AssistantMessagePart::Text {
            text: "I'll dem".to_owned(),
        },
        AssistantMessagePart::Text {
            text: "o a few tools.".to_owned(),
        },
        AssistantMessagePart::Text {
            text: " Here we go.".to_owned(),
        },
    ]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 1);

    let Message::Assistant { content, .. } = &messages[0] else {
        panic!("expected assistant");
    };
    assert_eq!(content.len(), 1);
    let AssistantContent::Text(text) = content.first() else {
        panic!("expected text");
    };
    assert_eq!(text.text, "I'll demo a few tools. Here we go.");
}

#[test]
fn text_after_tool_calls_splits_into_new_assistant_message() {
    let msg = assistant_parts(vec![
        AssistantMessagePart::Text {
            text: "Let me ".to_owned(),
        },
        AssistantMessagePart::Text {
            text: "search.".to_owned(),
        },
        AssistantMessagePart::ToolCall {
            name: "search".to_owned(),
            json: json!({"q": "x"}),
            id: "c1".to_owned(),
        },
        AssistantMessagePart::Text {
            text: "Found ".to_owned(),
        },
        AssistantMessagePart::Text {
            text: "results.".to_owned(),
        },
    ]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(
        messages.len(),
        2,
        "first assistant (text+tool), second assistant (text)"
    );

    let Message::Assistant { content, .. } = &messages[0] else {
        panic!("expected first assistant");
    };
    assert_eq!(content.len(), 2, "merged text + tool call");

    let Message::Assistant { content, .. } = &messages[1] else {
        panic!("expected second assistant");
    };
    assert_eq!(content.len(), 1);
    let AssistantContent::Text(text) = content.first() else {
        panic!("expected text");
    };
    assert_eq!(text.text, "Found results.");
}

#[test]
fn text_and_tool_calls_coexist_in_assistant_message() {
    let msg = assistant_parts(vec![
        AssistantMessagePart::Text {
            text: "Let me search for that.".to_owned(),
        },
        AssistantMessagePart::ToolCall {
            name: "search".to_owned(),
            json: json!({"q": "foo"}),
            id: "call_1".to_owned(),
        },
    ]);
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 1);

    let Message::Assistant { content, .. } = &messages[0] else {
        panic!("expected assistant");
    };
    assert_eq!(content.len(), 2);
    assert!(matches!(
        &content.iter().next().unwrap(),
        AssistantContent::Text(_)
    ));
}

#[test]
fn full_conversation_with_tool_round_trip() {
    let messages = to_rig_messages(&[
        user_msg("search for cats"),
        assistant_parts(vec![
            AssistantMessagePart::Text {
                text: "Searching...".to_owned(),
            },
            AssistantMessagePart::ToolCall {
                name: "search".to_owned(),
                json: json!({"query": "cats"}),
                id: "c1".to_owned(),
            },
            AssistantMessagePart::ToolCallResponseJson {
                name: "search".to_owned(),
                json: json!({"results": ["cat1", "cat2"]}),
                id: "c1".to_owned(),
            },
            AssistantMessagePart::Text {
                text: "Found 2 cats.".to_owned(),
            },
        ]),
        user_msg("tell me more about cat1"),
    ]);

    // The flattened assistant message splits into 3 messages:
    // assistant(text + tool_call), user(tool_result), assistant(text)
    assert_eq!(messages.len(), 5);
    assert!(matches!(&messages[0], Message::User { .. }));
    assert!(matches!(&messages[1], Message::Assistant { .. }));
    assert!(matches!(&messages[2], Message::User { .. }));
    assert!(matches!(&messages[3], Message::Assistant { .. }));
    assert!(matches!(&messages[4], Message::User { .. }));

    let Message::User { content } = &messages[2] else {
        panic!("expected tool result user message");
    };
    assert!(matches!(content.first(), UserContent::ToolResult(_)));

    let Message::Assistant { content, .. } = &messages[3] else {
        panic!("expected second assistant message");
    };
    let AssistantContent::Text(text) = content.first() else {
        panic!("expected text");
    };
    assert_eq!(text.text, "Found 2 cats.");
}

#[test]
fn user_message_with_image_url_attachment_includes_image_content() {
    let msg = user_msg_with_attachment(
        "what is in this image?",
        vec![AttachmentPart::Image(ImageData::StaticUrl(
            "https://example.com/cat.png".to_owned(),
        ))],
    );
    let messages = to_rig_messages(&[msg]);
    assert_eq!(messages.len(), 1);

    let Message::User { content } = &messages[0] else {
        panic!("expected user message");
    };
    // text block + image block
    assert_eq!(content.len(), 2);

    let mut iter = content.iter();
    let UserContent::Text(text) = iter.next().unwrap() else {
        panic!("expected leading text");
    };
    assert_eq!(text.text, "what is in this image?");

    let UserContent::Image(image) = iter.next().unwrap() else {
        panic!("expected image content");
    };
    assert!(matches!(
        &image.data,
        DocumentSourceKind::Url(url) if url == "https://example.com/cat.png"
    ));
}

#[test]
fn user_message_with_base64_image_is_sent_as_webp() {
    // A non-WebP source is normalized to a downscaled WebP, so the model
    // always receives base64 WebP content.
    let image = ImageData::try_from_bytes(ONE_BY_ONE_PNG.to_vec()).expect("valid image");
    assert!(matches!(image, ImageData::Base64(_)));

    let msg = user_msg_with_attachment("look", vec![AttachmentPart::Image(image)]);
    let messages = to_rig_messages(&[msg]);

    let Message::User { content } = &messages[0] else {
        panic!("expected user message");
    };
    let UserContent::Image(image) = content.iter().nth(1).unwrap() else {
        panic!("expected image content");
    };
    assert_eq!(image.media_type, Some(ImageMediaType::WEBP));
    let DocumentSourceKind::Base64(data) = &image.data else {
        panic!("expected base64 image data");
    };
    assert!(!data.is_empty(), "base64 payload should not be empty");
}

#[test]
fn user_message_with_text_attachment_appends_text_block() {
    let msg = user_msg_with_attachment(
        "summarize",
        vec![AttachmentPart::Content("attached document body".to_owned())],
    );
    let messages = to_rig_messages(&[msg]);

    let Message::User { content } = &messages[0] else {
        panic!("expected user message");
    };
    assert_eq!(content.len(), 2);
    let UserContent::Text(text) = content.iter().nth(1).unwrap() else {
        panic!("expected attachment text");
    };
    assert_eq!(text.text, "attached document body");
}

#[test]
fn user_message_with_only_attachment_and_empty_text_omits_text_block() {
    let mut msg = user_msg_with_attachment(
        "",
        vec![AttachmentPart::Image(ImageData::StaticUrl(
            "https://example.com/x.png".to_owned(),
        ))],
    );
    msg.content = ChatMessageContent::Text(String::new());

    let messages = to_rig_messages(&[msg]);
    let Message::User { content } = &messages[0] else {
        panic!("expected user message");
    };
    assert_eq!(content.len(), 1);
    assert!(matches!(content.first(), UserContent::Image(_)));
}

mod merge_consecutive_parts_tests {
    use super::*;

    fn part_text(s: &str) -> AssistantMessagePart {
        AssistantMessagePart::Text { text: s.into() }
    }
    fn part_thinking(s: &str) -> AssistantMessagePart {
        AssistantMessagePart::Thinking { thinking: s.into() }
    }
    fn part_call(id: &str) -> AssistantMessagePart {
        AssistantMessagePart::ToolCall {
            name: "t".into(),
            json: json!({}),
            id: id.into(),
        }
    }

    #[test]
    fn merges_consecutive_text() {
        let parts = vec![part_text("a"), part_text("b"), part_text("c")];
        assert_eq!(merge_consecutive_parts(parts), vec![part_text("abc")]);
    }

    #[test]
    fn merges_consecutive_thinking() {
        let parts = vec![part_thinking("a"), part_thinking("b")];
        assert_eq!(merge_consecutive_parts(parts), vec![part_thinking("ab")]);
    }

    #[test]
    fn does_not_merge_across_different_types() {
        let parts = vec![part_text("a"), part_call("1"), part_text("b")];
        assert_eq!(merge_consecutive_parts(parts.clone()), parts);
    }

    #[test]
    fn thinking_then_text_stays_separate() {
        let parts = vec![part_thinking("t"), part_text("a")];
        assert_eq!(merge_consecutive_parts(parts.clone()), parts);
    }

    #[test]
    fn empty_input() {
        assert!(merge_consecutive_parts(vec![]).is_empty());
    }
}

#[test]
fn normalized_uploaded_image_has_the_mime_type_required_by_gemini() {
    let image = ImageData::try_from_bytes(ONE_BY_ONE_PNG.to_vec()).unwrap();
    let message = user_msg_with_attachment("describe", vec![AttachmentPart::Image(image)]);
    let rig_message = to_rig_messages(&[message]).remove(0);
    let content =
        rig_core::providers::gemini::completion::gemini_api_types::Content::try_from(rig_message)
            .expect("normalized uploads must convert for Gemini");
    let wire = serde_json::to_value(content).unwrap();
    assert_eq!(wire["parts"][1]["inlineData"]["mimeType"], "image/webp");
    assert!(
        wire["parts"][1]["inlineData"]["data"]
            .as_str()
            .is_some_and(|data| !data.is_empty())
    );
}