collavre 0.24.0 → 0.25.0

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Collavre
+  module AiAgent
+    # Keeps a delegated Claude reply's claim, comment insert, and completion on
+    # the topic lock used by TopicMove. A move therefore sees the delegated task
+    # and waits, or runs after the complete reply is committed.
+    class TaskReplyService
+      Result = Data.define(:status, :body, :comment, :agent, :task)
+
+      def initialize(topic:, current_user:, text:, requested_task_id:, agent_resolver:, task_claimer:, claim_service:)
+        @topic = topic
+        @current_user = current_user
+        @text = text
+        @requested_task_id = requested_task_id
+        @agent_resolver = agent_resolver
+        @task_claimer = task_claimer
+        @claim_service = claim_service
+      end
+
+      def call
+        topic.with_lock { build_result }
+      end
+
+      private
+
+      attr_reader :topic, :current_user, :text, :requested_task_id, :agent_resolver, :task_claimer, :claim_service
+
+      def build_result
+        creative = topic.creative&.effective_origin
+        return result(:not_found, error: "Creative not found") unless creative
+        return result(:forbidden, error: "Not authorized") unless creative.has_permission?(current_user, :feedback)
+
+        agent = agent_resolver.call(topic, requested_task_id)
+        return result(:forbidden, error: "Not authorized") unless agent
+
+        task = task_claimer.call(agent, topic, requested_task_id)
+        if requested_task_id.present? && task.nil?
+          return result(:conflict, error: "Task already completed or not delegated")
+        end
+
+        persist_reply(creative, agent, task)
+      end
+
+      def persist_reply(creative, agent, task)
+        comment = creative.comments.build(
+          content: text.to_s, topic: topic, user: agent,
+          skip_default_user: true, skip_dispatch: true
+        )
+        return failed_result(comment, task) unless comment.save
+
+        claim_service.link_reply(task: task, comment: comment) if task
+        claim_service.finalize(agent: agent, task: task, comment: comment) if task
+        Result.new(status: :created, body: { comment_id: comment.id }, comment: comment, agent: agent, task: task)
+      end
+
+      def failed_result(comment, task)
+        task&.update!(status: "delegated")
+        result(:unprocessable_entity, errors: comment.errors.full_messages)
+      end
+
+      def result(status, **body)
+        Result.new(status: status, body: body, comment: nil, agent: nil, task: nil)
+      end
+    end
+  end
+end

data/app/services/collavre/ai_agent_service.rb

@@ -13,25 +13,39 @@ module Collavre
       @task = task
       @agent = task.agent
       @context = task.trigger_event_payload
+      @original_comment = find_original_comment
     end
 
     def call
-      Current.set(user: @agent) do
-        if @agent.claude_channel_agent?
-          delegate_to_claude_channel
-        else
-          execute_llm_conversation
+      begin
+        Current.set(user: @agent, agent_turn: { user: workspace_user, task: @task }) do
+          if @agent.claude_channel_agent?
+            delegate_to_claude_channel
+          else
+            execute_llm_conversation
+          end
         end
+      rescue ApprovalPendingError => e
+        summary = generate_approval_summary(e)
+        AiAgent::ApprovalHandler.new(
+          task: @task, agent: @agent, context: @context,
+          creative: @creative, reply_comment: @reply_comment
+        ).handle(e, summary: summary)
+        raise
       end
-    rescue ApprovalPendingError => e
-      summary = generate_approval_summary(e)
-      AiAgent::ApprovalHandler.new(
-        task: @task, agent: @agent, context: @context,
-        creative: @creative, reply_comment: @reply_comment
-      ).handle(e, summary: summary)
+    rescue TurnDeadlineError => e
+      handle_cancelled(
+        action_type: "failed",
+        message: "Turn exceeded the #{e.deadline_seconds}s deadline"
+      )
+      abort_agent_session_if_needed
       raise
     rescue CancelledError
-      handle_cancelled
+      if @task.reload.status == "failed"
+        handle_cancelled(action_type: "failed", message: "Task failed externally")
+      else
+        handle_cancelled
+      end
       abort_agent_session_if_needed
       raise
     end
@@ -60,7 +74,6 @@ module Collavre
     def execute_llm_conversation
       log_action("start", { message: "Starting agent execution" })
 
-      @original_comment = find_original_comment
       messages_data = build_messages
       log_action("prompt_generated", { messages: messages_data[:messages] })
 
@@ -70,6 +83,14 @@ module Collavre
 
       resolved = resolve_session_context(messages_data, system_prompt)
 
+      # Write down what this turn is about to hand the agent, before it hands it
+      # over. A comment that landed after this task was dispatched and got swept
+      # into the history window has been read by the agent, and the dispatch
+      # still on its way for it should be dropped rather than queued behind this
+      # turn. Recorded off `resolved` — after the session filter — because a
+      # session-backed agent is sent only its :trigger and swallows nothing.
+      Orchestration::DeliveryRecord.record!(@task, resolved)
+
       @reply_comment = create_reply_comment_if_needed
 
       @lifecycle_manager = AiAgent::AgentLifecycleManager.new(
@@ -86,12 +107,40 @@ module Collavre
       @lifecycle_manager.broadcast_status("thinking")
 
       @client = build_ai_client(resolved[:system_prompt])
-      stream_response(@client, resolved)
+      begin
+        stream_response(@client, resolved)
+      ensure
+        # Write down that the payload got there, whatever became of the turn
+        # afterwards. In an `ensure` because the ending this is for leaves by
+        # exception: a user pressing Stop mid-answer raises CancelledError out
+        # of the block above, and the task ends `cancelled` — an undelivered
+        # ending to every reader, although the agent has read this turn's
+        # payload and every comment it swallowed. See
+        # Orchestration::DeliveryRecord::HANDED_OFF_KEY.
+        Orchestration::DeliveryRecord.mark_handed_off!(@task) if @client.handed_off?
+      end
+
+      # ...and write down when the handing over did not happen. The record
+      # above licences discarding other dispatches on the strength of the agent
+      # having read their comments; a request that never reached the provider
+      # read nothing. AiAgentJob finishes this task `done` either way, so
+      # without this the delivered ending is the one it ends in. See
+      # Orchestration::DeliveryRecord::HANDOFF_FAILED_KEY.
+      Orchestration::DeliveryRecord.mark_handoff_failed!(@task) if @client.last_handoff_failed?
+
+      # Signal thinking state during finalize so the indicator shows ⏳
+      @lifecycle_manager.broadcast_status("thinking")
 
       log_action("completion", { response: @streamer.content })
 
       finalized_comment = finalize_response
+      # Stop/failure can land while the finalizer persists and broadcasts the
+      # reply. Revalidate before dispatching that reply to other agents.
+      @lifecycle_manager.check_cancelled!(force: true)
       dispatch_a2a(finalized_comment) unless @finalizer&.review_flow
+      # A2A dispatch may itself perform I/O. Keep the normal return path from
+      # handing a stale "success" to AiAgentJob after a terminal transition.
+      @lifecycle_manager.check_cancelled!(force: true)
 
       @lifecycle_manager.broadcast_status("idle")
 
@@ -172,17 +221,35 @@ module Collavre
           creative: @creative,
           user: @agent,
           task: @task,
-          comment: @reply_comment || @original_comment
-        }
+          comment: @reply_comment || @original_comment,
+          workspace_user: workspace_user
+        },
+        request_timeout_seconds: @lifecycle_manager.method(:remaining_deadline_seconds),
+        # The streaming block below checks cancellation only when a text delta
+        # arrives; a tool-only loop emits none, so the tool-call boundary is
+        # that loop's only checkpoint against terminal status and the deadline.
+        before_tool_call: ->(force = false) { @lifecycle_manager.check_cancelled!(force: force) }
       )
     end
 
     def stream_response(client, messages_data)
-      client.chat(messages_data, tools: @agent.tools || []) do |delta|
+      # Prompt/session preparation can take long enough for Stop or
+      # StuckDetector to end the task before the provider request begins.
+      # Bypass the new manager's initial polling throttle at this handoff
+      # boundary so a terminal turn cannot start remote tool side effects.
+      @lifecycle_manager.check_cancelled!(force: true)
+      response = client.chat(messages_data, tools: @agent.tools || []) do |delta|
         @lifecycle_manager.check_cancelled!
         @streamer.append(delta)
         @lifecycle_manager.heartbeat_if_needed
       end
+      # A provider can return its final response inside the one-second polling
+      # throttle after StuckDetector failed the task or the turn crossed its
+      # deadline. This is the common completion boundary for RubyLLM and both
+      # OpenClaw transports; validate it without throttling before finalization
+      # can overwrite the terminal outcome.
+      @lifecycle_manager.check_cancelled!(force: true)
+      response
     end
 
     def finalize_response
@@ -202,15 +269,36 @@ module Collavre
       dispatcher = AiAgent::A2aDispatcher.new(
         agent: @agent,
         reply_comment: finalized_comment,
-        context: @context
+        context: @context,
+        workspace_user: workspace_user
       )
       dispatcher.dispatch
     end
 
-    def handle_cancelled
+    def workspace_user
+      @workspace_user ||= begin
+        carried_principal = @context.key?("workspace_user_id")
+        carried_user = User.find_by(id: @context["workspace_user_id"])
+        comment_user = @original_comment&.user
+
+        if carried_user && !carried_user.ai_user?
+          carried_user
+        elsif carried_principal
+          nil
+        elsif comment_user && !comment_user.ai_user?
+          comment_user
+        else
+          @agent.creator
+        end
+      end
+    end
+
+    def handle_cancelled(action_type: "cancelled", message: "Task cancelled by user")
       @lifecycle_manager.handle_cancelled(
         reply_comment: @reply_comment,
-        response_content: @streamer.content
+        response_content: @streamer.content,
+        action_type: action_type,
+        message: message
       )
 
       # Reassociate activity logs if there was partial content

data/app/services/collavre/ai_client.rb

@@ -10,13 +10,45 @@ module Collavre
 
     attr_reader :last_input_tokens, :last_output_tokens
 
+    # Did the last #chat end without the provider ever receiving the payload?
+    #
+    # #chat swallows a provider error: it streams "⚠️ AI Error" to the caller
+    # and returns nil — which an ordinary empty answer also returns — so the
+    # return value cannot tell the two apart. Orchestration::DeliveryRecord
+    # needs them apart, because a turn that handed the provider nothing
+    # delivered nothing, and AiAgentJob still marks such a turn `done`.
+    #
+    # An error *after* the provider started answering is not one of these. It
+    # had the payload and acted on it; the truncated reply and the retry beside
+    # it are the ordinary ending the product already shows, and the comments
+    # that turn swallowed did reach the agent. "Started answering" is any chunk,
+    # not any *content* — see the stream block for why a tool-call chunk is the
+    # sharper case.
+    def last_handoff_failed?
+      @last_handoff_failed
+    end
+
+    # Whether the last #chat got its payload to the provider — the same
+    # boundary, asked positively, for the callers the flag above cannot serve.
+    #
+    # #last_handoff_failed? is only ever set from a rescue, so it says nothing
+    # about a #chat that left by exception past it: a user pressing Stop
+    # mid-answer raises CancelledError through here, and the turn ends in a
+    # status every reader counts as undelivered although the provider has the
+    # payload. Answering that needs the fact recorded as it happens rather than
+    # inferred from how the call ended.
+    def handed_off?
+      @handed_off
+    end
+
     # Vendor <select> options for AI-agent config. Core ships only its built-in
     # (stateless) providers; vendor engines append their own through
     # register_vendor_option, so core never names a vendor engine.
     BASE_VENDOR_OPTIONS = [
       [ "Google (Gemini)", "google" ],
       [ "OpenAI", "openai" ],
-      [ "Anthropic", "anthropic" ]
+      [ "Anthropic", "anthropic" ],
+      [ "CLI Proxy", "cli_proxy" ]
     ].freeze
 
     class << self
@@ -54,10 +86,16 @@ module Collavre
     end
 
     # log_interactions: persist each call to ActivityLog. Default true. Pass false
-    # for ephemeral, high-frequency calls on text the user has not submitted (e.g.
-    # inline typo correction on debounced typing) so private drafts are never
-    # written to server-side activity logs.
-    def initialize(vendor:, model:, system_prompt:, llm_api_key: nil, gateway_url: nil, context: {}, log_interactions: true)
+    # when a caller must not persist sensitive request or response content.
+    #
+    # before_tool_call: callable run before every tool execution, on every
+    # iteration of the request->tools->request loop. This is the only
+    # cancellation/deadline checkpoint a tool-only turn has: tool-call chunks
+    # carry no content, so #chat never yields them to the caller's streaming
+    # block, where the text path runs its check. A CancelledError raised here
+    # propagates out of #chat as a cancellation, not an "⚠️ AI Error" delta.
+    def initialize(vendor:, model:, system_prompt:, llm_api_key: nil, gateway_url: nil, context: {},
+                   log_interactions: true, before_tool_call: nil, request_timeout_seconds: nil)
       @vendor = vendor
       @model = model
       @system_prompt = system_prompt
@@ -65,11 +103,17 @@ module Collavre
       @gateway_url = gateway_url
       @context = context
       @log_interactions = log_interactions
+      @before_tool_call = before_tool_call
+      @request_timeout_seconds = request_timeout_seconds
       @last_input_tokens = 0
       @last_output_tokens = 0
+      @last_handoff_failed = false
+      @handed_off = false
     end
 
     def chat(contents, tools: [], &block)
+      @last_handoff_failed = false
+      @handed_off = false
       response_content = +""
       error_message = nil
       input_tokens = nil
@@ -84,6 +128,17 @@ module Collavre
       add_messages(@conversation, contents)
 
       response = @conversation.complete do |chunk|
+        # A chunk at all is the provider having accepted the request and begun
+        # answering — the earliest acceptance observable from here, and the
+        # analogue of the gateway run id the OpenClaw adapter records.
+        #
+        # Set above the empty check, not below it: role-only and tool-call
+        # chunks carry no content, and a conversation that reached its tools has
+        # not merely been handed the payload, it has acted on it — this
+        # product's tools write creatives and post comments. A turn classified
+        # as a failed handoff has everything it swallowed dispatched again, and
+        # the restored turn runs those tools a second time.
+        @handed_off = true
         delta = extract_chunk_content(chunk).to_s
         # Deliberately NOT `blank?`. A delta of exactly "\n\n" — the paragraph
         # break, which providers routinely emit as a token of its own — is
@@ -100,7 +155,10 @@ module Collavre
       end
 
       if response
-        response_content = response.content.to_s if response.content.present?
+        if response.content.present?
+          response_content = response.content.to_s
+          @handed_off = true
+        end
 
         # Extract token usage directly from response object (RubyLLM style)
         if response.respond_to?(:input_tokens)
@@ -119,14 +177,21 @@ module Collavre
     rescue CancelledError
       raise # Re-raise cancellation errors without catching them
     rescue StandardError => e
+      # Nothing came back at all means nothing was handed over — see
+      # #last_handoff_failed?. Asked of @handed_off rather than of the buffer,
+      # and not `blank?`: a delta of exactly "\n\n" is content the branch above
+      # deliberately keeps, so `blank?` calls a stream that broke after a
+      # paragraph break a failed handoff, and the buffer either way says nothing
+      # about the content-less chunks. The two are the same
+      # boundary asked two ways, and Task#ended_undelivered? reads a row carrying
+      # both as undelivered — so it has to be impossible to record both.
+      @last_handoff_failed = !@handed_off
       error_message = "[#{e.class.name}] #{e.message}"
-      # When log_interactions is false (inline typo correction runs on the user's
-      # *unsubmitted* draft), the LLM error message can echo the request text. Log
-      # only the error class to app logs so private drafts never leak — matching the
-      # no-log guarantee already enforced on the parse path (TypoCorrector) and the
-      # ActivityLog gate below. error_message stays intact for the gated ensure log
-      # and the streamed yield (which goes back to the same user).
+      # When log_interactions is false, an LLM error message can echo request text.
+      # Log only the error class so sensitive content never leaks. error_message
+      # stays intact for the gated ensure log and streamed yield to the caller.
       Rails.logger.error "AI Client error: #{@log_interactions ? error_message : "[#{e.class.name}]"}"
+      log_error_response(e) if @log_interactions
       Rails.logger.error "Partial response length: #{response_content.length} chars" if response_content.present?
       Rails.logger.debug e.backtrace.join("\n")
       yield "\n\n⚠️ AI Error: #{error_message}" if block_given?
@@ -152,11 +217,18 @@ module Collavre
     def ask(prompt)
       return nil unless @conversation
 
+      refresh_turn_boundary!(@conversation)
       # Disable tool calls for summary generation to avoid recursive approval
       @conversation.with_tools(replace: true)
       response = @conversation.ask(prompt)
+      refresh_turn_boundary!(@conversation)
       response&.content&.strip.presence
+    rescue CancelledError
+      raise
     rescue StandardError => e
+      # A provider timeout at the turn boundary must become the deadline that
+      # caused it, not a missing summary followed by pending_approval.
+      refresh_turn_boundary!(@conversation)
       Rails.logger.warn("AiClient#ask failed: #{e.class} #{e.message}")
       nil
     end
@@ -165,8 +237,47 @@ module Collavre
 
     attr_reader :vendor, :model, :system_prompt, :llm_api_key, :gateway_url, :context
 
+    # RubyLLM masks provider 400s behind a generic "Invalid request - please check
+    # your input" fallback whenever the provider's error body is not in OpenAI's
+    # {error:{message}} shape — common for OpenAI-compatible gateways (Cerebras,
+    # local Ollama, etc.), whose real reason then lives only in the raw HTTP
+    # response. RubyLLM::Error carries that response (status + body); surface it so
+    # the actual cause is one grep away instead of buried in ruby_llm.log.
+    #
+    # A provider 400 body can echo the offending request (prompt or tool arguments),
+    # so the raw body is written to the app log only under debug logging — the same
+    # level that already gates RubyLLM's own request/response body log (see the
+    # ruby_llm initializer). At INFO (production) we record status + body size only,
+    # keeping user content out of centralized app logs while still capturing that the
+    # provider rejected the request and how large its reason was; raise the log level
+    # to recover the full body on demand. The whole path is additionally gated by
+    # @log_interactions at the call site, like the error-message log above.
+    def log_error_response(error)
+      return unless error.respond_to?(:response) && (response = error.response)
+
+      status = response.respond_to?(:status) ? response.status : nil
+      body = response.respond_to?(:body) ? response.body : nil
+      return if status.nil? && body.blank?
+
+      unless Rails.logger.debug?
+        size = body.is_a?(String) ? "#{body.bytesize}B" : (body.nil? ? "none" : "non-string")
+        Rails.logger.error "AI Client error response: status=#{status} body_size=#{size} " \
+                           "(body suppressed at INFO; raise log level to capture it)"
+        return
+      end
+
+      # Provider error bodies are frequently tagged ASCII-8BIT even though the bytes
+      # are valid UTF-8; reinterpret and scrub so non-ASCII text (e.g. Korean) is
+      # readable and never re-triggers the transcode failure we are eliminating.
+      body_text = body.is_a?(String) ? body.dup.force_encoding("UTF-8").scrub : body.inspect
+      Rails.logger.error "AI Client error response: status=#{status} body=#{body_text.to_s.truncate(2000)}"
+    rescue StandardError => e
+      Rails.logger.debug "AiClient#log_error_response failed: #{e.class}"
+    end
+
     VENDOR_TO_PROVIDER = {
       "openai" => :openai,
+      "cli_proxy" => :openai,
       "anthropic" => :anthropic,
       "google" => :gemini,
       "gemini" => :gemini
@@ -176,9 +287,32 @@ module Collavre
       normalized_vendor = @vendor.to_s.downcase
 
       context_block = case normalized_vendor
-      when "openai"
-        api_key = @llm_api_key.presence || IntegrationSettings.fetch(:openai_api_key)
-        base_url = @gateway_url.presence
+      when "openai", "cli_proxy"
+        if normalized_vendor == "cli_proxy"
+          agent = context[:user]
+          gateway = agent&.agent_gateway
+          raise ArgumentError, "CLI Proxy agent has no active gateway" unless gateway&.active?
+
+          if context.key?(:workspace_user)
+            workspace_user = context[:workspace_user]
+          else
+            comment_user = context[:comment]&.user
+            workspace_user = comment_user unless comment_user&.ai_user?
+            workspace_user ||= agent.creator
+          end
+          if gateway.per_user? && workspace_user.nil?
+            raise ArgumentError, "CLI Proxy per-user workspace requires a verified human principal"
+          end
+          workspace_user = nil if gateway.shared?
+          workspace = Collavre::AgentWorkspace.resolve!(agent: agent, user: workspace_user)
+          gateway = workspace.agent_gateway
+          @cli_proxy_identity = { gateway: gateway, workspace: workspace }
+          api_key = gateway.completion_key
+          base_url = gateway.completion_base_url
+        else
+          api_key = @llm_api_key.presence || IntegrationSettings.fetch(:openai_api_key)
+          base_url = @gateway_url.presence
+        end
         # A custom OpenAI-compatible gateway (local Ollama / LM Studio, etc.) needs
         # no real OpenAI key, but RubyLLM raises ConfigurationError before sending
         # if openai_api_key is blank. Supply a placeholder so keyless local gateways
@@ -187,6 +321,9 @@ module Collavre
         proc do |config|
           config.openai_api_key = api_key
           config.openai_api_base = base_url if base_url
+          if normalized_vendor == "cli_proxy" && !gateway.owner.system_admin? && !gateway.desktop_loopback?
+            config.faraday_adapter = Collavre::CliProxy::SafeNetHttpAdapter
+          end
         end
       when "anthropic"
         api_key = @llm_api_key.presence || IntegrationSettings.fetch(:anthropic_api_key)
@@ -201,17 +338,34 @@ module Collavre
       chat_opts[:provider] = provider if provider
       chat_opts[:assume_model_exists] = true if provider
 
-      # Apply current system timeout setting (picks up changes without restart)
-      RubyLLM.config.request_timeout = SystemSetting.llm_request_timeout_seconds
+      # RubyLLM::Context duplicates the global config. Set the timeout on that
+      # per-client copy so concurrent agent threads cannot overwrite one
+      # another's deadline cap.
+      @ruby_llm_context = RubyLLM.context do |config|
+        context_block.call(config)
+        config.request_timeout = effective_request_timeout_seconds
+      end
 
-      RubyLLM.context(&context_block)
-             .chat(**chat_opts).tap do |chat|
+      @ruby_llm_context.chat(**chat_opts).tap do |chat|
         chat.with_instructions(system_prompt) if system_prompt.present?
-        session_id = build_session_id
-        chat.with_headers("X-Session-Id" => session_id) if session_id
+        apply_request_headers!(chat)
         chat.on_tool_call do |tool_call|
+          # Cancellation ahead of the approval gate: a turn that already
+          # reached a terminal status or its deadline must end, not park
+          # itself as pending approval for a tool it will never run. Force this
+          # boundary through the lifecycle throttle: the first tool call can
+          # arrive during the manager's initial one-second quiet period.
+          @before_tool_call&.call(true)
           check_tool_approval!(tool_call)
         end
+        if @request_timeout_seconds || @cli_proxy_identity
+          chat.after_tool_result do |_result|
+            # A tool can consume much of the turn. Recheck the deadline and
+            # refresh request-scoped state before the loop starts its next
+            # provider request.
+            refresh_turn_boundary!(chat)
+          end
+        end
         if tools.any?
           # Resolve tool names to classes using the gem's helper
           tool_classes = ::Tools::MetaToolService.ruby_llm_tools(tools)
@@ -220,6 +374,42 @@ module Collavre
       end
     end
 
+    def refresh_turn_boundary!(conversation)
+      if @request_timeout_seconds
+        @before_tool_call&.call(true)
+        if @ruby_llm_context
+          @ruby_llm_context.config.request_timeout = effective_request_timeout_seconds
+          conversation.with_context(@ruby_llm_context)
+        end
+      end
+
+      apply_request_headers!(conversation)
+    end
+
+    def apply_request_headers!(conversation)
+      headers = {}
+      session_id = build_session_id
+      headers["X-Session-Id"] = session_id if session_id
+
+      if @cli_proxy_identity
+        headers.merge!(Collavre::CliProxy::Identity.headers(
+          **@cli_proxy_identity,
+          method: :post,
+          path: "/v1/chat/completions"
+        ))
+      end
+
+      conversation.with_headers(**headers) if headers.present?
+    end
+
+    def effective_request_timeout_seconds
+      configured = SystemSetting.llm_request_timeout_seconds.to_f
+      remaining = @request_timeout_seconds&.call
+      return configured unless remaining
+
+      [ configured, remaining.to_f ].min.clamp(0.001, configured)
+    end
+
     def build_session_id
       creative_id = context&.dig(:creative)&.id
       topic_id = context&.dig(:comment)&.topic_id || context&.dig(:topic_id)