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.

25.8 KB
Raw Blame
//! Default [`ChatService`] implementation backed by a [`ChatRepo`].

mod purge_owned;
#[cfg(test)]
mod test;

use crate::domain::{
    events::{
        ChatCopiedMetadata, ChatCreatedMetadata, ChatDeletedMetadata, ChatMacroEvent,
        ChatPermanentlyDeletedMetadata, ChatRestoredMetadata, ChatUpdatedMetadata,
    },
    models::{
        ChatErr, CopyChatArgs, CreateChatArgs, GetChatResponse, PatchChatArgs, PatchChatRepoArgs,
        Result,
    },
    ports::{ChatRepo, ChatService},
};
use agent::types::{AssistantMessagePart, ChatMessageContent};
use ai_toolset::{AsyncToolCollection, RequestContext, tool_object::UserToolResponse};
use entity_access::domain::models::{
    AccessError, AccessLevel, EditAccessLevel, EntityAccessAuth, EntityAccessReceipt,
    EntityPermission, OwnerAccessLevel, ViewAccessLevel,
};
use entity_access_management::domain::ports::EntityAccessManagementService;
use macro_event_broker::{MacroEventBroker, NoopMacroEventBroker};
use macro_user_id::user_id::MacroUserIdStr;
use model_entity::EntityType;
use model_owner::Owner;
use models_permissions::share_permission::SharePermissionV2;
use models_permissions::share_permission::team_share::{
    AuthorizedTeamShareCommand, TeamShareLevel, TeamSharePolicyError, TeamShareRequest,
    authorize_team_share,
};
use std::sync::Arc;
use unicode_segmentation::UnicodeSegmentation;

/// Concrete service implementation that delegates to a [`ChatRepo`]
pub struct ChatServiceImpl<R, ToolSetContext, Eam, B = NoopMacroEventBroker>
where
    ToolSetContext: Clone + Send + Sync + 'static,
    B: MacroEventBroker,
{
    // toolset should be replaced with trait;
    toolset: Arc<AsyncToolCollection<ToolSetContext>>,
    context: ToolSetContext,
    repo: R,
    entity_access_management_service: Eam,
    event_broker: B,
}

/// The user id to attribute a chat lifecycle event to, when the caller is an
/// authenticated user.
fn event_actor_user_id(auth: &EntityAccessAuth) -> Option<MacroUserIdStr<'static>> {
    match auth {
        EntityAccessAuth::Authenticated(user_id) => Some(user_id.clone()),
        EntityAccessAuth::Bot(_)
        | EntityAccessAuth::Unauthenticated
        | EntityAccessAuth::Internal => None,
    }
}

impl<R: ChatRepo, ToolSetContext, Eam: EntityAccessManagementService>
    ChatServiceImpl<R, ToolSetContext, Eam>
where
    ToolSetContext: Clone + Send + Sync + 'static,
{
    /// Create a new [`ChatServiceImpl`] wrapping the given repo and tool executor.
    pub fn new(
        repo: R,
        toolset: Arc<AsyncToolCollection<ToolSetContext>>,
        context: ToolSetContext,
        entity_access_management_service: Eam,
    ) -> Self {
        Self {
            repo,
            toolset,
            context,
            entity_access_management_service,
            event_broker: NoopMacroEventBroker,
        }
    }
}

impl<R: ChatRepo, Eam: EntityAccessManagementService> ChatServiceImpl<R, (), Eam> {
    /// Create a chat service for hosts that only use metadata/lifecycle
    /// operations and never execute stored tool calls.
    pub fn new_without_tools(repo: R, entity_access_management_service: Eam) -> Self {
        Self::new(
            repo,
            Arc::new(AsyncToolCollection::new()),
            (),
            entity_access_management_service,
        )
    }
}

impl<R: ChatRepo, ToolSetContext, Eam: EntityAccessManagementService, B: MacroEventBroker>
    ChatServiceImpl<R, ToolSetContext, Eam, B>
where
    ToolSetContext: Clone + Send + Sync + 'static,
{
    /// Replaces the event broker while preserving every other service dependency.
    pub fn with_event_broker<B2: MacroEventBroker>(
        self,
        event_broker: B2,
    ) -> ChatServiceImpl<R, ToolSetContext, Eam, B2> {
        ChatServiceImpl {
            toolset: self.toolset,
            context: self.context,
            repo: self.repo,
            entity_access_management_service: self.entity_access_management_service,
            event_broker,
        }
    }

    /// Publish a chat lifecycle event; failures are logged and dropped.
    fn publish_chat_event(&self, event: &ChatMacroEvent) {
        drop(self.event_broker.send_event(event).inspect_err(|error| {
            tracing::error!(error = ?error, "failed to schedule chat event");
        }));
    }

    /// Authorize an explicit team-share change against the persisted owner.
    ///
    /// Returns `Ok(None)` without loading anything when the request omits the
    /// team level, so ordinary renames and moves never take the team-share
    /// guard. Effective Owner access (for example via a project) is not enough:
    /// only the chat's actual owner may share it with their team.
    async fn authorize_chat_team_share(
        &self,
        receipt: &EntityAccessReceipt<OwnerAccessLevel>,
        request: TeamShareRequest,
    ) -> Result<Option<AuthorizedTeamShareCommand>> {
        if request == TeamShareRequest::default() {
            return Ok(None);
        }
        let facts = self
            .repo
            .get_team_share_facts(&receipt.entity().entity_id)
            .await?;
        authorize_team_share(
            receipt.acting_user_id(),
            &facts,
            request,
            TeamShareLevel::Edit,
        )
        .map_err(|error| match error {
            TeamSharePolicyError::MissingActor | TeamSharePolicyError::NotOwner => {
                ChatErr::Access(AccessError::Unauthorized)
            }
            TeamSharePolicyError::InvalidRevision => ChatErr::Conflict(error.to_string()),
            TeamSharePolicyError::MissingTeam
            | TeamSharePolicyError::InvalidLevel
            | TeamSharePolicyError::ContradictoryInputs => ChatErr::BadRequest(error.to_string()),
        })
    }
}

impl<R: ChatRepo, ToolSetContext, Eam: EntityAccessManagementService, B: MacroEventBroker>
    ChatService for ChatServiceImpl<R, ToolSetContext, Eam, B>
where
    ToolSetContext: Clone + Send + Sync + 'static,
{
    #[tracing::instrument(err, skip(self))]
    async fn create(&self, owner: Owner, args: CreateChatArgs) -> Result<String> {
        if args.name.graphemes(true).count() > 100 {
            return Err(ChatErr::BadRequest("name too long".to_string()));
        }

        let project_id = args.project_id.clone();
        let name = args.name.clone();

        // The owner's team default link-share preference decides the initial
        // share permission; without a team the chat default (public/view) applies.
        let team_default = self.repo.get_team_default_link_share(&owner).await?;
        let share_permission = SharePermissionV2::new_chat_share_permission(team_default);

        let chat_id = self
            .repo
            .create(owner.clone(), args, share_permission)
            .await?;

        if let Some(project_id) = &project_id
            && !project_id.is_empty()
            && let (Ok(chat_uuid), Ok(project_uuid)) = (
                uuid::Uuid::parse_str(&chat_id),
                uuid::Uuid::parse_str(project_id),
            )
        {
            let _ = self
                .entity_access_management_service
                .add_entity_to_project(&chat_uuid, EntityType::Chat, &project_uuid)
                .await
                .inspect_err(|e| tracing::error!(error=?e, project_id=?project_id, "unable to update entity access for project"));
            let _ = self.repo.update_project_modified(project_id).await.inspect_err(
                |e| tracing::error!(error=?e, project_id=?project_id, "unable to update project modified date"),
            );
        }

        self.publish_chat_event(&ChatMacroEvent::created(ChatCreatedMetadata {
            chat_id: chat_id.clone(),
            owner,
            name,
            project_id,
        }));

        Ok(chat_id)
    }

    #[tracing::instrument(err, skip(self))]
    async fn get_chat(
        &self,
        entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<GetChatResponse> {
        let chat_id = &entity_access_receipt.entity().entity_id;

        // Anonymous public-link viewers hold an Unauthenticated receipt: there
        // is no user to look up an access level for, so report the level the
        // receipt was granted with (the chat's public access level).
        if let EntityAccessAuth::Authenticated(user_id) = entity_access_receipt.auth() {
            let (chat, access_level) = tokio::join!(
                self.repo.get_chat(chat_id),
                self.repo.get_access_level(user_id.to_owned(), chat_id),
            );

            return Ok(GetChatResponse {
                chat: chat?,
                user_access_level: access_level?,
            });
        }

        let chat = self.repo.get_chat(chat_id).await?;
        let user_access_level = match entity_access_receipt.entity_permission() {
            EntityPermission::AccessLevel { access_level } => *access_level,
            _ => AccessLevel::View,
        };

        Ok(GetChatResponse {
            chat,
            user_access_level,
        })
    }

    #[tracing::instrument(err, skip(self))]
    async fn get_metadata(
        &self,
        entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<model::chat::Chat> {
        self.repo
            .get_metadata(&entity_access_receipt.entity().entity_id)
            .await
    }

    #[tracing::instrument(err, skip(self))]
    async fn copy_chat(
        &self,
        entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<String> {
        let user_id = entity_access_receipt.get_authenticated_user()?;
        let chat_id = &entity_access_receipt.entity().entity_id;

        let chat = self.repo.get_metadata(chat_id).await?;
        let name = format!("{} Copy", chat.name);

        // The copier becomes the owner, so their team default decides the
        // copy's initial share permission.
        let owner = Owner::User(user_id.to_owned());
        let team_default = self.repo.get_team_default_link_share(&owner).await?;
        let share_permission = SharePermissionV2::new_chat_share_permission(team_default);

        let new_chat_id = self
            .repo
            .copy_chat(
                owner,
                chat_id,
                CopyChatArgs {
                    name: name.clone(),
                    project_id: None,
                },
                share_permission,
            )
            .await?;

        self.publish_chat_event(&ChatMacroEvent::copied(ChatCopiedMetadata {
            chat_id: new_chat_id.clone(),
            source_chat_id: chat_id.clone(),
            owner: user_id.clone(),
            name,
        }));

        Ok(new_chat_id)
    }

    #[tracing::instrument(err, skip(self))]
    async fn delete(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        let chat_id = &entity_access_receipt.entity().entity_id;
        let project_id = self
            .repo
            .get_metadata(chat_id)
            .await
            .ok()
            .and_then(|c| c.project_id);
        self.repo.delete(chat_id).await?;

        if let Some(project_id) = &project_id
            && !project_id.is_empty()
            && let (Ok(chat_uuid), Ok(project_uuid)) = (
                uuid::Uuid::parse_str(chat_id),
                uuid::Uuid::parse_str(project_id),
            )
        {
            let _ = self
                .entity_access_management_service
                .remove_entity_from_project(&chat_uuid, EntityType::Chat, &project_uuid)
                .await
                .inspect_err(|e| tracing::error!(error=?e, project_id=?project_id, "unable to remove entity from project"));
            let _ = self.repo.update_project_modified(project_id).await.inspect_err(
                |e| tracing::error!(error=?e, project_id=?project_id, "unable to update project modified date"),
            );
        }

        self.publish_chat_event(&ChatMacroEvent::deleted(ChatDeletedMetadata {
            chat_id: chat_id.clone(),
            actor_user_id: event_actor_user_id(entity_access_receipt.auth()),
            project_id,
        }));

        Ok(())
    }

    #[tracing::instrument(err, skip(self))]
    async fn permanently_delete(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        let chat_id = &entity_access_receipt.entity().entity_id;
        let project_id = self
            .repo
            .get_metadata(chat_id)
            .await
            .ok()
            .and_then(|c| c.project_id);
        self.repo.permanently_delete(chat_id).await?;

        if let Some(project_id) = &project_id
            && !project_id.is_empty()
            && let (Ok(chat_uuid), Ok(project_uuid)) = (
                uuid::Uuid::parse_str(chat_id),
                uuid::Uuid::parse_str(project_id),
            )
        {
            let _ = self
                .entity_access_management_service
                .remove_entity_from_project(&chat_uuid, EntityType::Chat, &project_uuid)
                .await
                .inspect_err(|e| tracing::error!(error=?e, project_id=?project_id, "unable to remove entity from project"));
            let _ = self.repo.update_project_modified(project_id).await.inspect_err(
                |e| tracing::error!(error=?e, project_id=?project_id, "unable to update project modified date"),
            );
        }

        self.publish_chat_event(&ChatMacroEvent::permanently_deleted(
            ChatPermanentlyDeletedMetadata {
                chat_id: chat_id.clone(),
                actor_user_id: event_actor_user_id(entity_access_receipt.auth()),
                project_id,
            },
        ));

        Ok(())
    }

    #[tracing::instrument(err, skip(self))]
    async fn patch(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        args: PatchChatArgs,
    ) -> Result<()> {
        if let Some(name) = args.name.as_ref()
            && name.graphemes(true).count() > 100
        {
            return Err(ChatErr::BadRequest("name too long".to_string()));
        }
        let user_id = entity_access_receipt.get_authenticated_user()?;
        let chat_id = &entity_access_receipt.entity().entity_id;

        // Team sharing is authorized against the persisted owner before any
        // write; a rejected request returns here and publishes nothing.
        let team_share = self
            .authorize_chat_team_share(
                &entity_access_receipt,
                TeamShareRequest {
                    access_level: args
                        .share_permission
                        .as_ref()
                        .and_then(|p| p.team_share_access_level),
                    legacy_enabled: None,
                },
            )
            .await?;

        let old_project_id = self
            .repo
            .get_metadata(chat_id)
            .await
            .ok()
            .and_then(|c| c.project_id);
        let new_project_id = args.project_id.clone();
        let project_changing =
            new_project_id.is_some() && new_project_id.as_deref() != old_project_id.as_deref();
        let name = args.name.clone();
        let share_permission_updated = args.share_permission.is_some();

        self.repo
            .patch(
                user_id.to_owned(),
                chat_id,
                PatchChatRepoArgs {
                    name: args.name,
                    project_id: args.project_id,
                    share_permission: args.share_permission,
                    team_share,
                },
            )
            .await?;

        // Remove from old project (only if the project is actually changing)
        if project_changing
            && let Some(old_project_id) = &old_project_id
            && !old_project_id.is_empty()
            && let (Ok(chat_uuid), Ok(old_uuid)) = (
                uuid::Uuid::parse_str(chat_id),
                uuid::Uuid::parse_str(old_project_id),
            )
        {
            let _ = self
                .entity_access_management_service
                .remove_entity_from_project(&chat_uuid, EntityType::Chat, &old_uuid)
                .await
                .inspect_err(|e| tracing::error!(error=?e, project_id=?old_project_id, "unable to remove entity from project"));
            let _ = self.repo.update_project_modified(old_project_id).await.inspect_err(
                |e| tracing::error!(error=?e, project_id=?old_project_id, "unable to update project modified date"),
            );
        }

        // Add to new project's entity access + bump modified timestamp
        if let Some(new_project_id) = &new_project_id
            && !new_project_id.is_empty()
            && let (Ok(chat_uuid), Ok(new_uuid)) = (
                uuid::Uuid::parse_str(chat_id),
                uuid::Uuid::parse_str(new_project_id),
            )
        {
            let _ = self
                .entity_access_management_service
                .add_entity_to_project(&chat_uuid, EntityType::Chat, &new_uuid)
                .await
                .inspect_err(|e| tracing::error!(error=?e, project_id=?new_project_id, "unable to add entity to project"));
            let _ = self.repo.update_project_modified(new_project_id).await.inspect_err(
                |e| tracing::error!(error=?e, project_id=?new_project_id, "unable to update project modified date"),
            );
        }

        self.publish_chat_event(&ChatMacroEvent::updated(ChatUpdatedMetadata {
            chat_id: chat_id.clone(),
            actor_user_id: user_id.clone(),
            name,
            previous_project_id: old_project_id,
            project_id: new_project_id,
            share_permission_updated,
        }));

        Ok(())
    }

    #[tracing::instrument(err, skip(self))]
    async fn revert_delete(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        let chat_id = &entity_access_receipt.entity().entity_id;
        let chat = self.repo.get_metadata(chat_id).await?;
        self.repo
            .revert_delete(chat_id, chat.project_id.as_deref())
            .await?;

        self.publish_chat_event(&ChatMacroEvent::restored(ChatRestoredMetadata {
            chat_id: chat_id.clone(),
            actor_user_id: event_actor_user_id(entity_access_receipt.auth()),
            project_id: chat.project_id,
        }));

        Ok(())
    }

    #[tracing::instrument(err, skip(self))]
    async fn get_permissions(
        &self,
        entity_access_receipt: EntityAccessReceipt<EditAccessLevel>,
    ) -> Result<SharePermissionV2> {
        let chat_id = &entity_access_receipt.entity().entity_id;
        self.repo.get_permissions(chat_id).await
    }

    #[tracing::instrument(err, skip(self, new_args))]
    async fn update_tool_call(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        message_id: &str,
        tool_call_id: &str,
        new_args: serde_json::Value,
    ) -> Result<()> {
        let chat_id = &entity_access_receipt.entity().entity_id;

        let mut parts = self
            .get_tool_call_parts(chat_id, message_id, tool_call_id)
            .await?;

        let Some((name, _)) = find_tool_call(&parts, tool_call_id) else {
            return Err(ChatErr::NotFound);
        };

        if !self.toolset.is_valid_tool(name, &new_args) {
            return Err(ChatErr::BadRequest("Invalid tool".into()));
        }

        update_tool_call_args(&mut parts, tool_call_id, new_args);

        let content = ChatMessageContent::AssistantMessageParts(parts);
        self.repo
            .update_interim_message_content(chat_id, message_id, &content)
            .await
    }

    #[tracing::instrument(err, skip(self, response))]
    async fn update_tool_response(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        message_id: &str,
        tool_call_id: &str,
        response: UserToolResponse<serde_json::Value>,
    ) -> Result<()> {
        let chat_id = &entity_access_receipt.entity().entity_id;
        let mut parts = self
            .get_tool_call_parts(chat_id, message_id, tool_call_id)
            .await?;

        let response_json = serde_json::to_value(response).map_err(anyhow::Error::from)?;
        update_tool_response_json(&mut parts, tool_call_id, response_json);

        let content = ChatMessageContent::AssistantMessageParts(parts);
        self.repo
            .update_message_content(chat_id, message_id, &content)
            .await
    }

    #[tracing::instrument(err, skip(self, args))]
    async fn call_tool(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        message_id: &str,
        tool_call_id: &str,
        args: Option<serde_json::Value>,
    ) -> Result<serde_json::Value> {
        let user_id = entity_access_receipt.get_authenticated_user()?.to_owned();
        let chat_id = entity_access_receipt.entity().entity_id.clone();

        let parts = self
            .get_tool_call_parts(&chat_id, message_id, tool_call_id)
            .await?;

        let Some((tool_name, stored_args)) = find_tool_call(&parts, tool_call_id) else {
            return Err(ChatErr::NotFound);
        };
        let tool_name = tool_name.to_owned();
        let args = match args {
            Some(args) => {
                self.update_tool_call(
                    entity_access_receipt,
                    message_id,
                    tool_call_id,
                    args.clone(),
                )
                .await?;
                args
            }
            None => stored_args.clone(),
        };

        let request_context = RequestContext::new(user_id);

        let outcome = self
            .toolset
            .try_user_tool_call(self.context.clone(), request_context, &tool_name, &args)
            .await
            // this should never happen (validation prevents)
            .map_err(anyhow::Error::from)?;

        let response_json = match outcome {
            Ok(user_response) => {
                serde_json::to_value(user_response).map_err(anyhow::Error::from)?
            }
            Err(tool_err) => serde_json::json!({ "error": tool_err.description }),
        };

        // re-fetch parts since update_tool_call modified them
        let mut parts = self
            .get_tool_call_parts(&chat_id, message_id, tool_call_id)
            .await?;

        update_tool_response_json(&mut parts, tool_call_id, response_json.clone());

        let content = ChatMessageContent::AssistantMessageParts(parts);
        self.repo
            .update_message_content(&chat_id, message_id, &content)
            .await?;

        Ok(response_json)
    }

    #[tracing::instrument(err, skip(self))]
    async fn reject_tool_call(
        &self,
        entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        message_id: &str,
        tool_call_id: &str,
    ) -> Result<()> {
        let rejected_json =
            serde_json::to_value(UserToolResponse::Rejected::<()>).map_err(anyhow::Error::from)?;

        let chat_id = &entity_access_receipt.entity().entity_id;
        let mut parts = self
            .get_tool_call_parts(chat_id, message_id, tool_call_id)
            .await?;

        update_tool_response_json(&mut parts, tool_call_id, rejected_json);

        let content = ChatMessageContent::AssistantMessageParts(parts);
        self.repo
            .update_message_content(chat_id, message_id, &content)
            .await
    }
}

impl<R: ChatRepo, ToolSetContext, Eam: EntityAccessManagementService, B: MacroEventBroker>
    ChatServiceImpl<R, ToolSetContext, Eam, B>
where
    ToolSetContext: Clone + Send + Sync + 'static,
{
    /// Fetch a message's content and extract its AssistantMessageParts,
    /// verifying the tool_call_id exists within it.
    async fn get_tool_call_parts(
        &self,
        chat_id: &str,
        message_id: &str,
        tool_call_id: &str,
    ) -> Result<Vec<AssistantMessagePart>> {
        let content = self.repo.get_message_content(chat_id, message_id).await?;
        match content {
            ChatMessageContent::AssistantMessageParts(parts) => {
                let has_tool = parts.iter().any(|part| {
                    matches!(part, AssistantMessagePart::ToolCall { id, .. } | AssistantMessagePart::McpToolCall { id, .. } if id == tool_call_id)
                });
                if has_tool {
                    Ok(parts)
                } else {
                    Err(ChatErr::NotFound)
                }
            }
            _ => Err(ChatErr::BadRequest(
                "message does not contain tool calls".to_string(),
            )),
        }
    }
}

fn find_tool_call<'a>(
    parts: &'a [AssistantMessagePart],
    tool_call_id: &str,
) -> Option<(&'a str, &'a serde_json::Value)> {
    parts.iter().find_map(|part| match part {
        AssistantMessagePart::ToolCall { id, name, json } if id == tool_call_id => {
            Some((name.as_str(), json))
        }
        AssistantMessagePart::McpToolCall { id, name, json, .. } if id == tool_call_id => {
            Some((name.as_str(), json))
        }
        _ => None,
    })
}

/// Update the json field of the ToolCall part matching the given tool_call_id.
fn update_tool_call_args(
    parts: &mut [AssistantMessagePart],
    tool_call_id: &str,
    new_args: serde_json::Value,
) {
    for part in parts.iter_mut() {
        match part {
            AssistantMessagePart::ToolCall { id, json, .. }
            | AssistantMessagePart::McpToolCall { id, json, .. }
                if id == tool_call_id =>
            {
                *json = new_args;
                return;
            }
            _ => {}
        }
    }
}

/// Update the json field of the ToolCallResponseJson part matching the given tool_call_id.
fn update_tool_response_json(
    parts: &mut [AssistantMessagePart],
    tool_call_id: &str,
    new_json: serde_json::Value,
) {
    for part in parts.iter_mut() {
        if let AssistantMessagePart::ToolCallResponseJson { id, json, .. } = part
            && id == tool_call_id
        {
            *json = new_json;
            return;
        }
    }
}