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.7 KB
Raw Blame
use super::read_chat::ReadChat;
use ai_toolset::schema::generate_validated_input_schema;

#[test]
fn test_read_chat_schema_validation() {
    let result = generate_validated_input_schema::<ReadChat>();
    assert!(result.is_ok(), "{:?}", result);

    let validated = result.unwrap();
    assert_eq!(
        validated.name, "ReadChat",
        "Tool name should match the schemars title"
    );
    assert!(
        validated.description.contains("chat"),
        "Description should contain expected text"
    );
}

mod self_read_guard {
    use super::super::ChatToolContext;
    use crate::domain::models::{
        ChatErr, ChatResponse, CreateChatArgs, GetChatResponse, PatchChatArgs, Result,
    };
    use crate::domain::ports::ChatService;
    use crate::inbound::toolset::read_chat::ReadChat;
    use ai_toolset::tool_object::UserToolResponse;
    use ai_toolset::{AsyncTool, RequestContext, ServiceContext};
    use entity_access::domain::models::{
        AccessError, AccessLevel, BotAccessScope, BotId, CallChannelInfo, Entity,
        EntityAccessReceipt, EntityPermission, EntityType, RequiredPermission, TeamRole,
        UserTeamInfo,
    };
    use entity_access::domain::ports::EntityAccessService;
    use macro_user_id::lowercased::Lowercase;
    use macro_user_id::user_id::{MacroUserId, MacroUserIdStr};
    use uuid::Uuid;

    /// A [`ChatService`] that panics if any method is invoked — used to prove
    /// the self-read guard returns before ever touching the service.
    struct UnreachableChatService;

    impl ChatService for UnreachableChatService {
        async fn create(
            &self,
            _owner: model_owner::Owner,
            _args: CreateChatArgs,
        ) -> Result<String> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn get_chat(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::ViewAccessLevel,
            >,
        ) -> Result<GetChatResponse> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn get_metadata(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::ViewAccessLevel,
            >,
        ) -> Result<model::chat::Chat> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn copy_chat(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::ViewAccessLevel,
            >,
        ) -> Result<String> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn delete(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
        ) -> Result<()> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn permanently_delete(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
        ) -> Result<()> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn patch(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _args: PatchChatArgs,
        ) -> Result<()> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn revert_delete(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
        ) -> Result<()> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn get_permissions(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::EditAccessLevel,
            >,
        ) -> Result<models_permissions::share_permission::SharePermissionV2> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn update_tool_call(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
            _new_args: serde_json::Value,
        ) -> Result<()> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn update_tool_response(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
            _response: UserToolResponse<serde_json::Value>,
        ) -> Result<()> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn call_tool(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
            _args: Option<serde_json::Value>,
        ) -> Result<serde_json::Value> {
            unreachable!("guard should short-circuit before calling the chat service")
        }

        async fn reject_tool_call(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
        ) -> Result<()> {
            unreachable!("guard should short-circuit before calling the chat service")
        }
    }

    /// An [`EntityAccessService`] that panics if any method is invoked — used
    /// to prove the self-read guard returns before checking access.
    #[derive(Clone)]
    struct UnreachableAccessService;

    impl EntityAccessService for UnreachableAccessService {
        async fn generate_entity_access_receipt<T: RequiredPermission>(
            &self,
            _user_id: &MacroUserId<Lowercase<'_>>,
            _user_org_id: Option<i64>,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<EntityAccessReceipt<T>, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn generate_bot_entity_access_receipt<T: RequiredPermission>(
            &self,
            _bot_id: BotId,
            _scope: BotAccessScope,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<EntityAccessReceipt<T>, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn get_access_level(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<Option<AccessLevel>, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn check_access(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
            _required_level: AccessLevel,
        ) -> std::result::Result<AccessLevel, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn check_public_access(
            &self,
            _entity_id: &str,
            _entity_type: EntityType,
            _required_level: AccessLevel,
        ) -> std::result::Result<AccessLevel, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn get_entity_permission(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
            _user_org_id: Option<i64>,
        ) -> std::result::Result<EntityPermission, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn get_crm_entity_permission_with_team(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<(EntityPermission, Uuid, TeamRole), AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn get_users_by_entity(
            &self,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<Vec<MacroUserIdStr<'static>>, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn get_call_channel(
            &self,
            _call_id: &sqlx::types::Uuid,
        ) -> std::result::Result<Option<CallChannelInfo>, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn get_call_channel_by_channel_id(
            &self,
            _channel_id: &sqlx::types::Uuid,
        ) -> std::result::Result<Option<CallChannelInfo>, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }

        async fn get_user_team(
            &self,
            _user_id: &MacroUserId<Lowercase<'_>>,
        ) -> std::result::Result<Option<UserTeamInfo>, AccessError> {
            unreachable!("guard should short-circuit before checking access")
        }
    }

    /// A [`ChatService`] that returns a canned successful response, so tests
    /// unrelated to the self-read guard can exercise the happy path.
    struct StubChatService;

    impl ChatService for StubChatService {
        async fn create(
            &self,
            _owner: model_owner::Owner,
            _args: CreateChatArgs,
        ) -> Result<String> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn get_metadata(
            &self,
            entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::ViewAccessLevel,
            >,
        ) -> Result<model::chat::Chat> {
            #[allow(deprecated)]
            let chat_id = entity_access_receipt.entity().entity_id.clone();
            Ok(model::chat::Chat {
                id: chat_id.to_string(),
                name: "Other Chat".to_string(),
                user_id: model_owner::Owner::from_principal_str("macro|[email protected]").unwrap(),
                model: None,
                project_id: None,
                created_at: None,
                updated_at: None,
                token_count: None,
                is_persistent: true,
                deleted_at: None,
            })
        }

        async fn get_chat(
            &self,
            entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::ViewAccessLevel,
            >,
        ) -> Result<GetChatResponse> {
            #[allow(deprecated)]
            let chat_id = entity_access_receipt.entity().entity_id.clone();
            Ok(GetChatResponse {
                chat: ChatResponse {
                    id: chat_id,
                    user_id: model_owner::Owner::from_principal_str("macro|[email protected]")
                        .unwrap(),
                    project_id: None,
                    name: "Other Chat".to_string(),
                    messages: Vec::new(),
                    model: None,
                    created_at: None,
                    updated_at: None,
                },
                user_access_level: AccessLevel::Owner,
            })
        }

        async fn copy_chat(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::ViewAccessLevel,
            >,
        ) -> Result<String> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn delete(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
        ) -> Result<()> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn permanently_delete(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
        ) -> Result<()> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn patch(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _args: PatchChatArgs,
        ) -> Result<()> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn revert_delete(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
        ) -> Result<()> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn get_permissions(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::EditAccessLevel,
            >,
        ) -> Result<models_permissions::share_permission::SharePermissionV2> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn update_tool_call(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
            _new_args: serde_json::Value,
        ) -> Result<()> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn update_tool_response(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
            _response: UserToolResponse<serde_json::Value>,
        ) -> Result<()> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn call_tool(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
            _args: Option<serde_json::Value>,
        ) -> Result<serde_json::Value> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }

        async fn reject_tool_call(
            &self,
            _entity_access_receipt: EntityAccessReceipt<
                entity_access::domain::models::OwnerAccessLevel,
            >,
            _message_id: &str,
            _tool_call_id: &str,
        ) -> Result<()> {
            Err(ChatErr::Unknown(anyhow::anyhow!("not used by this test")))
        }
    }

    /// An [`EntityAccessService`] that always grants owner-level access, so
    /// tests unrelated to the self-read guard can exercise the happy path.
    #[derive(Clone)]
    struct StubAccessService;

    impl EntityAccessService for StubAccessService {
        async fn generate_entity_access_receipt<T: RequiredPermission>(
            &self,
            _user_id: &MacroUserId<Lowercase<'_>>,
            _user_org_id: Option<i64>,
            entity_id: &str,
            entity_type: EntityType,
        ) -> std::result::Result<EntityAccessReceipt<T>, AccessError> {
            EntityAccessReceipt::try_new_authenticated_user(
                MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap(),
                Entity {
                    entity_id: entity_id.to_string(),
                    entity_type,
                },
                EntityPermission::AccessLevel {
                    access_level: AccessLevel::Owner,
                },
            )
        }

        async fn generate_bot_entity_access_receipt<T: RequiredPermission>(
            &self,
            _bot_id: BotId,
            _scope: BotAccessScope,
            entity_id: &str,
            entity_type: EntityType,
        ) -> std::result::Result<EntityAccessReceipt<T>, AccessError> {
            EntityAccessReceipt::try_new_authenticated_user(
                MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap(),
                Entity {
                    entity_id: entity_id.to_string(),
                    entity_type,
                },
                EntityPermission::AccessLevel {
                    access_level: AccessLevel::Owner,
                },
            )
        }

        async fn get_access_level(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<Option<AccessLevel>, AccessError> {
            Ok(Some(AccessLevel::Owner))
        }

        async fn check_access(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
            _required_level: AccessLevel,
        ) -> std::result::Result<AccessLevel, AccessError> {
            Ok(AccessLevel::Owner)
        }

        async fn check_public_access(
            &self,
            _entity_id: &str,
            _entity_type: EntityType,
            _required_level: AccessLevel,
        ) -> std::result::Result<AccessLevel, AccessError> {
            Ok(AccessLevel::Owner)
        }

        async fn get_entity_permission(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
            _user_org_id: Option<i64>,
        ) -> std::result::Result<EntityPermission, AccessError> {
            Ok(EntityPermission::AccessLevel {
                access_level: AccessLevel::Owner,
            })
        }

        async fn get_crm_entity_permission_with_team(
            &self,
            _user_id: Option<&MacroUserId<Lowercase<'_>>>,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<(EntityPermission, Uuid, TeamRole), AccessError> {
            unimplemented!("stub does not support CRM entity access")
        }

        async fn get_users_by_entity(
            &self,
            _entity_id: &str,
            _entity_type: EntityType,
        ) -> std::result::Result<Vec<MacroUserIdStr<'static>>, AccessError> {
            Ok(vec![])
        }

        async fn get_call_channel(
            &self,
            _call_id: &sqlx::types::Uuid,
        ) -> std::result::Result<Option<CallChannelInfo>, AccessError> {
            unimplemented!()
        }

        async fn get_call_channel_by_channel_id(
            &self,
            _channel_id: &sqlx::types::Uuid,
        ) -> std::result::Result<Option<CallChannelInfo>, AccessError> {
            unimplemented!()
        }

        async fn get_user_team(
            &self,
            _user_id: &MacroUserId<Lowercase<'_>>,
        ) -> std::result::Result<Option<UserTeamInfo>, AccessError> {
            unimplemented!()
        }
    }

    fn request_context() -> RequestContext {
        RequestContext::new(MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap())
    }

    #[tokio::test]
    async fn blocks_reading_the_currently_running_chat() {
        let self_chat_id = Uuid::new_v4();
        let tool = ReadChat {
            chat_id: self_chat_id.to_string(),
        };
        let context = ServiceContext(ChatToolContext {
            service: std::sync::Arc::new(UnreachableChatService),
            entity_access_service: std::sync::Arc::new(UnreachableAccessService),
            self_chat_id: Some(self_chat_id),
        });

        let result = tool.call(context, request_context()).await;

        let err = result.expect_err("reading the running chat should be refused");
        assert!(
            err.description.contains("currently running"),
            "error should tell the model this is its own chat: {}",
            err.description
        );
    }

    #[tokio::test]
    async fn allows_reading_a_different_chat() {
        let self_chat_id = Uuid::new_v4();
        let other_chat_id = Uuid::new_v4();
        let tool = ReadChat {
            chat_id: other_chat_id.to_string(),
        };
        let context = ServiceContext(ChatToolContext {
            service: std::sync::Arc::new(StubChatService),
            entity_access_service: std::sync::Arc::new(StubAccessService),
            self_chat_id: Some(self_chat_id),
        });

        let result = tool.call(context, request_context()).await;

        assert!(result.is_ok(), "{:?}", result.err());
        assert_eq!(result.unwrap().chat_id, other_chat_id.to_string());
    }

    #[tokio::test]
    async fn allows_reading_any_chat_outside_a_chat_session() {
        let chat_id = Uuid::new_v4();
        let tool = ReadChat {
            chat_id: chat_id.to_string(),
        };
        let context = ServiceContext(ChatToolContext {
            service: std::sync::Arc::new(StubChatService),
            entity_access_service: std::sync::Arc::new(StubAccessService),
            self_chat_id: None,
        });

        let result = tool.call(context, request_context()).await;

        assert!(result.is_ok(), "{:?}", result.err());
    }
}