collavre 0.3.2 → 0.5.0

data/app/services/collavre/ai_agent/message_builder.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Collavre
+  module AiAgent
+    # Builds the message array for AI agent conversations.
+    #
+    # Extracts creative context, chat history, and the trigger comment
+    # into the format expected by AiClient.
+    class MessageBuilder
+      def initialize(agent:, context:, original_comment: nil)
+        @agent = agent
+        @context = context
+        @original_comment = original_comment
+      end
+
+      def build
+        messages = []
+
+        append_creative_context(messages)
+        append_chat_history(messages)
+        append_trigger_message(messages)
+
+        messages
+      end
+
+      private
+
+      def append_creative_context(messages)
+        creative_id = @context.dig("creative", "id")
+        return unless creative_id
+
+        creative = Creative.find_by(id: creative_id)
+        return unless creative
+
+        children_level = @agent.creative_children_level
+        max_depth = 1 + children_level
+        markdown = ApplicationController.helpers.render_creative_tree_markdown(
+          [ creative ], 1, true, max_depth: max_depth
+        )
+
+        topic = current_topic
+        topic_info = topic ? "\nTopic: #{topic.name} (id: #{topic.id})" : ""
+
+        messages << { role: "user", parts: [ { text: "Creative (id: #{creative.id}):#{topic_info}\n#{markdown}" } ] }
+      end
+
+      def append_chat_history(messages)
+        creative_id = @context.dig("creative", "id")
+        return unless creative_id
+
+        topic_id = trigger_comment&.topic_id
+
+        history_limit = @agent.chat_history_limit
+        history_size_limit = @agent.chat_history_size_limit
+        history_chars = 0
+
+        Comment.where(creative_id: creative_id, private: false)
+               .where(topic_id: topic_id)
+               .where.not(user_id: nil)
+               .includes(:user)
+               .order(created_at: :desc)
+               .limit(history_limit)
+               .reverse
+               .each do |c|
+          next if c.id == trigger_comment&.id
+
+          role = (c.user_id == @agent.id) ? "model" : "user"
+          content = c.content.to_s
+
+          if role == "user"
+            content = MentionParser.strip_self_mention(content, @agent.name)
+            speaker = c.user&.name || "unknown"
+            content = "[#{speaker}]: #{content}"
+          end
+
+          history_chars += content.length
+          break if history_chars > history_size_limit
+
+          messages << { role: role, parts: [ { text: content } ] }
+        end
+      end
+
+      def append_trigger_message(messages)
+        payload_text = @context.dig("comment", "content") || @context.to_json
+
+        if review_eligible?
+          quoted_body = @original_comment.quoted_comment&.content
+          review_context = I18n.t("collavre.ai_agent.review.context")
+          review_parts = [ review_context ]
+          review_parts << "---\nOriginal message:\n#{quoted_body}\n---" if quoted_body.present?
+          payload_text = "#{review_parts.join("\n\n")}\n\n#{payload_text}"
+        end
+
+        sender_name = @context.dig("sender", "name")
+        if sender_name
+          payload_text = MentionParser.strip_self_mention(payload_text, @agent.name)
+          payload_text = "[#{sender_name}]: #{payload_text}"
+        end
+
+        trigger_parts = [ { text: payload_text } ]
+
+        if @original_comment&.images&.attached?
+          @original_comment.images.each do |image|
+            trigger_parts << { image: image.blob }
+          end
+        end
+
+        messages << { role: "user", parts: trigger_parts }
+      end
+
+      def trigger_comment
+        @trigger_comment ||= begin
+          id = @context.dig("comment", "id")
+          Comment.find_by(id: id) if id
+        end
+      end
+
+      def current_topic
+        return unless trigger_comment&.topic_id
+
+        Topic.find_by(id: trigger_comment.topic_id)
+      end
+
+      def review_eligible?
+        ReviewHandler.eligible?(@original_comment, @agent)
+      end
+    end
+  end
+end

data/app/services/collavre/ai_agent/review_handler.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Collavre
+  module AiAgent
+    # Handles AI agent review workflows: eligibility checks,
+    # in-place content updates, and completion reactions.
+    class ReviewHandler
+      def initialize(original_comment, agent)
+        @original_comment = original_comment
+        @agent = agent
+      end
+
+      # Class-level convenience for eligibility checks.
+      def self.eligible?(original_comment, agent)
+        new(original_comment, agent).eligible?
+      end
+
+      def eligible?
+        return false unless @original_comment&.review_message?
+
+        quoted_comment = @original_comment.quoted_comment
+        return false unless quoted_comment
+        return false unless quoted_comment.user_id == @agent.id
+        return false unless quoted_comment.creative_id == @original_comment.creative_id
+        return false if quoted_comment.private?
+        return false unless quoted_comment.topic_id == @original_comment.topic_id
+
+        true
+      end
+
+      # Update the quoted comment with the AI response content.
+      # Returns true if the review was handled, false otherwise.
+      def handle(response_content, task:)
+        return false unless eligible?
+
+        quoted_comment = @original_comment.quoted_comment
+        quoted_comment.update!(content: response_content)
+
+        task.task_actions.create!(
+          action_type: "review_updated",
+          payload: {
+            quoted_comment_id: quoted_comment.id,
+            original_comment_id: @original_comment.id,
+            content: response_content
+          },
+          status: "done"
+        )
+
+        true
+      end
+
+      # Add a completion reaction emoji to the review comment.
+      def add_completion_reaction
+        reaction = begin
+          CommentReaction.find_or_create_by!(
+            comment: @original_comment,
+            user: @agent,
+            emoji: "✅"
+          )
+        rescue ActiveRecord::RecordNotUnique
+          CommentReaction.find_by(comment: @original_comment, user: @agent, emoji: "✅")
+        end
+
+        CommentReaction.broadcast_reaction_update(@original_comment) if reaction
+      rescue StandardError => e
+        Rails.logger.warn("[AiAgent::ReviewHandler] Failed to add review reaction: #{e.message}")
+      end
+    end
+  end
+end

data/app/services/collavre/ai_agent_service.rb

@@ -4,6 +4,8 @@ module Collavre
     STREAM_THROTTLE_INTERVAL = 0.1
     # Minimum interval (in seconds) between cancellation checks to avoid excessive DB queries
     CANCEL_CHECK_INTERVAL = 1.0
+    # Interval (in seconds) between agent_status heartbeats during streaming
+    AGENT_STATUS_HEARTBEAT_INTERVAL = 3.0
 
     def initialize(task)
       @task = task
@@ -13,26 +15,25 @@ module Collavre
 
     def call
       Current.set(user: @agent) do
-        # Log start action
         log_action("start", { message: "Starting agent execution" })
 
-        # Prepare messages for AI
-        messages = build_messages
+        target_comment_id = @context.dig("comment", "id")
+        @original_comment = target_comment_id ? Comment.find_by(id: target_comment_id) : nil
+
+        messages = AiAgent::MessageBuilder.new(
+          agent: @agent, context: @context, original_comment: @original_comment
+        ).build
 
-        # Log prompt generation
         log_action("prompt_generated", { messages: messages })
 
-        # Call AI Client
         @response_content = ""
 
-        # Enrich context for rendering
         rendering_context = @context.dup
         if @context.dig("creative", "id")
           creative = Creative.find_by(id: @context["creative"]["id"])
           rendering_context["creative"] = creative.as_json if creative
         end
 
-        # Add agent collaboration context
         agent_context = build_agent_context(creative)
         rendering_context.merge!(agent_context)
 
@@ -41,18 +42,14 @@ module Collavre
           context: rendering_context
         ).render
 
-        # Append collaboration guide to system prompt
         collaboration_prompt = build_collaboration_prompt(creative)
         rendered_system_prompt = "#{rendered_system_prompt}\n\n#{collaboration_prompt}" if collaboration_prompt.present?
 
-        # Create a placeholder comment to stream into
-        target_comment_id = @context.dig("comment", "id")
-        @original_comment = target_comment_id ? Comment.find_by(id: target_comment_id) : nil
         @reply_comment = nil
 
         if @original_comment
           @reply_comment = @original_comment.creative.comments.create!(
-            content: Comment::STREAMING_PLACEHOLDER_CONTENT, # Placeholder — replaced during streaming
+            content: Comment::STREAMING_PLACEHOLDER_CONTENT,
             user: @agent,
             topic_id: @original_comment.topic_id
           )
@@ -60,7 +57,6 @@ module Collavre
 
         @creative = @context.dig("creative", "id") ? Creative.find_by(id: @context["creative"]["id"]) : nil
 
-        # Broadcast "thinking" status via presence channel
         broadcast_agent_status("thinking")
 
         client = AiClient.new(
@@ -77,52 +73,45 @@ module Collavre
         )
 
         last_broadcast_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        last_heartbeat_at = last_broadcast_at
         @last_cancel_check_at = last_broadcast_at
 
         client.chat(messages, tools: @agent.tools || []) do |delta|
           check_cancelled!
           @response_content += delta
 
-          # Stream updates to placeholder comment (throttled)
           now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           if @reply_comment && (now - last_broadcast_at) >= STREAM_THROTTLE_INTERVAL
             @reply_comment.update_column(:content, @response_content)
             @reply_comment.broadcast_update_to(
               [ @reply_comment.creative, :comments ],
-              partial: "collavre/comments/comment"
+              partial: "collavre/comments/comment",
+              locals: { comment: @reply_comment, streaming: true }
             )
             last_broadcast_at = now
           end
+
+          # Periodic agent_status heartbeat so clients know we're still streaming
+          if (now - last_heartbeat_at) >= AGENT_STATUS_HEARTBEAT_INTERVAL
+            broadcast_agent_status("streaming")
+            last_heartbeat_at = now
+          end
         end
 
-        # Log completion
         log_action("completion", { response: @response_content })
 
-        # Final save to ensure everything is consistent and trigger final callbacks
-        if @reply_comment
-          if @response_content.present?
-            # Force dirty tracking since update_column bypassed it during streaming
-            @reply_comment.content_will_change!
-            @reply_comment.update!(content: @response_content)
-            log_action("reply_created", { comment_id: @reply_comment.id, content: @response_content })
+        finalize_response
 
-            # Re-associate activity logs from the trigger comment to the reply comment
-            reassociate_activity_logs(@original_comment, @reply_comment)
-          else
-            @reply_comment.destroy!
-          end
-        elsif target_comment_id && @response_content.present?
-          reply_to_comment(target_comment_id, @response_content)
-        end
-
-        # Broadcast "idle" status
         broadcast_agent_status("idle")
 
         @response_content
       end
     rescue ApprovalPendingError => e
-      handle_approval_pending(e)
-      raise # Re-raise to signal the job to handle status
+      AiAgent::ApprovalHandler.new(
+        task: @task, agent: @agent, context: @context,
+        creative: @creative, reply_comment: @reply_comment
+      ).handle(e)
+      raise
     rescue CancelledError
       handle_cancelled
       raise
@@ -139,11 +128,15 @@ module Collavre
     end
 
     def handle_cancelled
-      # Save accumulated content to the placeholder comment before stopping
       if @reply_comment
         if @response_content.present?
           @reply_comment.content_will_change!
           @reply_comment.update!(content: @response_content)
+          @reply_comment.broadcast_update_to(
+            [ @reply_comment.creative, :comments ],
+            partial: "collavre/comments/comment",
+            locals: { comment: @reply_comment, streaming: false }
+          )
           log_action("reply_created", { comment_id: @reply_comment.id, content: @response_content, partial: true })
           reassociate_activity_logs(@original_comment, @reply_comment)
         else
@@ -155,6 +148,35 @@ module Collavre
       log_action("cancelled", { message: "Task cancelled by user" })
     end
 
+    def finalize_response
+      review_handler = AiAgent::ReviewHandler.new(@original_comment, @agent)
+
+      if @reply_comment
+        if @response_content.present?
+          if @original_comment&.review_message? && review_handler.handle(@response_content, task: @task)
+            review_handler.add_completion_reaction
+            reassociate_activity_logs(@reply_comment, @original_comment.quoted_comment)
+            @reply_comment.destroy!
+          else
+            @reply_comment.content_will_change!
+            @reply_comment.update!(content: @response_content)
+            @reply_comment.broadcast_update_to(
+              [ @reply_comment.creative, :comments ],
+              partial: "collavre/comments/comment",
+              locals: { comment: @reply_comment, streaming: false }
+            )
+            log_action("reply_created", { comment_id: @reply_comment.id, content: @response_content })
+            reassociate_activity_logs(@original_comment, @reply_comment)
+            dispatch_a2a_if_needed
+          end
+        else
+          @reply_comment.destroy!
+        end
+      elsif @context.dig("comment", "id") && @response_content.present?
+        reply_to_comment(@context["comment"]["id"], @response_content)
+      end
+    end
+
     def broadcast_agent_status(status, content: nil)
       return unless @creative
 
@@ -178,68 +200,46 @@ module Collavre
       )
     end
 
-    def build_messages
-      messages = []
-
-      if @context["creative"]
-        creative_id = @context.dig("creative", "id")
-        if creative_id
-          creative = Creative.find_by(id: creative_id)
-          if creative
-            markdown = ApplicationController.helpers.render_creative_tree_markdown([ creative ], 1, true)
-            messages << { role: "user", parts: [ { text: "Creative:\n#{markdown}" } ] }
-          end
-        end
-      end
-
-      if @context.dig("creative", "id")
-        creative_id = @context["creative"]["id"]
-
-        trigger_comment_id = @context.dig("comment", "id")
-        trigger_comment = Comment.find_by(id: trigger_comment_id)
-        topic_id = trigger_comment&.topic_id
-
-        Comment.where(creative_id: creative_id, private: false)
-               .where(topic_id: topic_id)
-               .order(created_at: :desc)
-               .limit(50)
-               .reverse
-               .each do |c|
-          next if c.id == @context.dig("comment", "id")
-
-          role = (c.user_id == @agent.id) ? "model" : "user"
-          content = c.content
-
-          if role == "user"
-            if content.match?(/\A@#{Regexp.escape(@agent.name)}:/i)
-              content = content.sub(/\A@#{Regexp.escape(@agent.name)}:\s*/i, "")
-            elsif content.match?(/\A@#{Regexp.escape(@agent.name)}\s+/i)
-              content = content.sub(/\A@#{Regexp.escape(@agent.name)}\s+/i, "")
-            end
-          end
-
-          messages << { role: role, parts: [ { text: content } ] }
-        end
-      end
-
-      payload_text = @context.dig("comment", "content") || @context.to_json
-      messages << { role: "user", parts: [ { text: payload_text } ] }
-
-      messages
-    end
-
     def reply_to_comment(comment_id, content)
       original_comment = Comment.find_by(id: comment_id)
       return unless original_comment
 
-      reply = original_comment.creative.comments.create!(
+      @reply_comment = original_comment.creative.comments.create!(
         content: content,
         user: @agent,
         topic_id: original_comment.topic_id
       )
 
-      log_action("reply_created", { comment_id: reply.id, content: content })
-      reassociate_activity_logs(original_comment, reply)
+      log_action("reply_created", { comment_id: @reply_comment.id, content: content })
+      reassociate_activity_logs(original_comment, @reply_comment)
+      dispatch_a2a_if_needed
+    end
+
+    def dispatch_a2a_if_needed
+      return unless @reply_comment&.content.present?
+
+      # Find all mentioned AI agents anywhere in the response (not just at the start)
+      mentioned_agents = MentionParser.resolve_all_users(@reply_comment.content).select(&:ai_user?)
+      return if mentioned_agents.empty?
+
+      creative = @reply_comment.creative
+
+      mentioned_agents.each do |mentioned_user|
+        if creative
+          context = { "creative" => { "id" => creative.id }, "topic" => { "id" => @reply_comment.topic_id } }
+          Orchestration::LoopBreaker.new(context).record_interaction(@agent.id, mentioned_user.id, creative.id)
+        end
+      end
+
+      # Dispatch event — downstream Matcher will route to the correct agent(s)
+      SystemEvents::Dispatcher.dispatch("comment_created", {
+        comment: { id: @reply_comment.id, content: @reply_comment.content, user_id: @reply_comment.user_id },
+        creative: { id: creative&.id, description: creative&.description },
+        topic: { id: @reply_comment.topic_id },
+        chat: { content: @reply_comment.content }
+      })
+    rescue StandardError => e
+      Rails.logger.error("[AiAgentService] A2A dispatch failed: #{e.message}")
     end
 
     def reassociate_activity_logs(from_comment, to_comment)
@@ -263,70 +263,13 @@ module Collavre
       Orchestration::AgentContextBuilder.new(
         agent: @agent,
         creative: creative,
-        sender: @context["sender"]
+        sender: @context["sender"],
+        policy_resolver: build_policy_resolver
       ).to_collaboration_prompt
     end
 
-    def handle_approval_pending(error)
-      # Clean up placeholder comment if exists
-      @reply_comment&.destroy! if @reply_comment&.content == Comment::STREAMING_PLACEHOLDER_CONTENT
-
-      broadcast_agent_status("idle")
-
-      @task.update!(
-        status: "pending_approval",
-        pending_tool_call: {
-          tool_name: error.tool_name,
-          tool_call_id: error.tool_call_id,
-          arguments: error.tool_arguments,
-          requested_at: Time.current.iso8601
-        }
-      )
-
-      log_action("pending_approval", error.to_h)
-      create_approval_comment(error)
-    end
-
-    def create_approval_comment(error)
-      return unless @creative
-
-      approver = @creative.user || User.find_by(id: @context.dig("comment", "user_id"))
-      return unless approver
-
-      action_payload = {
-        action: "execute_tool",
-        tool_name: error.tool_name,
-        arguments: error.tool_arguments,
-        resume: {
-          task_id: @task.id,
-          tool_call_id: error.tool_call_id
-        }
-      }
-
-      args_display = if error.tool_arguments.present?
-                       JSON.pretty_generate(error.tool_arguments)
-      else
-                       I18n.t("collavre.ai_agent.approval.no_arguments")
-      end
-
-      content = I18n.t(
-        "collavre.ai_agent.approval.message",
-        tool_name: error.tool_name,
-        arguments: args_display
-      )
-
-      original_comment = Comment.find_by(id: @context.dig("comment", "id"))
-      topic_id = original_comment&.topic_id
-
-      Comment.create!(
-        creative: @creative,
-        content: content,
-        user: @agent,
-        approver: approver,
-        action: JSON.pretty_generate(action_payload),
-        topic_id: topic_id,
-        private: false
-      )
+    def build_policy_resolver
+      Orchestration::PolicyResolver.new(@context)
     end
   end
 end

data/app/services/collavre/ai_client.rb

@@ -129,9 +129,12 @@ module Collavre
       tool_name = tool_call.name
       task = context&.dig(:task)
 
-      # Check if this tool requires approval
+      # Check if this tool requires approval (dynamic McpTool or system tool)
       mcp_tool = McpTool.find_by(name: tool_name)
-      return unless mcp_tool&.requires_approval?
+      system_tool_class = ToolMeta.registry.find { |klass| klass.tool_metadata[:name] == tool_name }
+      requires = mcp_tool&.requires_approval? ||
+                 (system_tool_class.respond_to?(:requires_approval?) && system_tool_class.requires_approval?)
+      return unless requires
 
       # Check if we already have approval for this specific call (resume scenario)
       if task&.pending_tool_call.present?
@@ -159,9 +162,18 @@ module Collavre
         next unless role
 
         text = extract_message_text(message)
-        next if text.blank?
+        image_sources = extract_image_sources(message)
 
-        conversation.add_message(role:, content: text)
+        next if text.blank? && image_sources.empty?
+
+        if image_sources.any?
+          content = RubyLLM::Content.new(text.presence, image_sources)
+          conversation.add_message(role:, content: content)
+        else
+          next if text.blank?
+
+          conversation.add_message(role:, content: text)
+        end
       end
     end
 
@@ -177,6 +189,13 @@ module Collavre
       end
     end
 
+    def extract_image_sources(message)
+      parts = message[:parts] || message["parts"]
+      return [] if parts.nil?
+
+      Array(parts).filter_map { |part| part[:image] || part["image"] }
+    end
+
     def extract_message_text(message)
       parts = message[:parts] || message["parts"]
       return message[:text] || message["text"] if parts.nil?