collavre_openclaw 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd95c0741d901e7dd551d64362a7cce7d0b0f7f9b4a87a3469990ccc1479e340
-  data.tar.gz: 7db937c777a492b23e19037e83bf3dd4245a46ff8333e9de6c6e9e55e2960f81
+  metadata.gz: 3a5a10c4a59247ea763b3f635005c08375186c6bb279dfa9e00ea5e5533ae438
+  data.tar.gz: '097534bec297da15507b18e1f060990471fc54e9076ba5f81065a36ecb88b262'
 SHA512:
-  metadata.gz: 701cfb138ae6d0f25da60fcea13e56970647490ec32ab24cb6ec26e06c93ea250f9af1efed0fc9ddc7790b4f8d703e5ca7b2c8730902720e1a0e2d061216c6f9
-  data.tar.gz: 53315260ffb37347b9289080de544e65b19b207943d8784a341eeda0d042175e80753d3a43bf70f42b0ec087ba919827ed7fc50338dbf5d68d63a6daafd40039
+  metadata.gz: 02f5238a8bae2f7061113189918774ebef66a855e26383127f42c3838658124721d465449751fdf0629d5ec52ffc399a5325d91a661a838bf25deb39cb0f1563
+  data.tar.gz: b9089349ca80e5f4f575da36f38f590f4a6607e9cd14dba8dece7c570a3d7f100d6abec58974647da1d4c33b4f00ad47ac31c9c5ec6c75761e9d7e1e587ff36c

data/app/jobs/collavre_openclaw/callback_processor_job.rb

@@ -60,6 +60,10 @@ module CollavreOpenclaw
       content = payload[:content] || payload[:message]
       thread_id = payload[:thread_id] || payload[:topic_id] || payload.dig(:context, :thread_id) || payload.dig(:context, :topic_id)
       parent_comment_id = payload[:parent_comment_id] || payload.dig(:context, :parent_comment_id)
+      # Accept both casings: the HTTP CallbacksController path forwards the raw
+      # Gateway payload, which uses camelCase `runId`.
+      run_id = payload[:run_id] || payload[:runId] ||
+               payload.dig(:context, :run_id) || payload.dig(:context, :runId)
 
       unless creative_id.present?
         Rails.logger.error("[CollavreOpenclaw] Proactive message missing creative_id")
@@ -74,6 +78,7 @@ module CollavreOpenclaw
       context = {
         thread_id: thread_id,
         parent_comment_id: parent_comment_id,
+        openclaw_run_id: run_id,
         proactive: true
       }
 
@@ -105,6 +110,14 @@ module CollavreOpenclaw
       end
 
       effective_creative = creative.effective_origin
+      run_id = context[:openclaw_run_id].presence
+
+      # The Gateway broadcasts a run to every process, so non-initiating ones see
+      # the final as "proactive" — suppress them via the run's tombstone.
+      if run_id && CollavreOpenclaw::ProcessedAiRun.processed?(run_id)
+        Rails.logger.warn("[CollavreOpenclaw] Duplicate run #{run_id} suppressed for creative #{creative_id} (already processed)")
+        return CollavreOpenclaw::ProcessedAiRun.comment_for(run_id)
+      end
 
       # Dedup: skip if an identical comment was recently created
       existing = Collavre::Comment
@@ -132,6 +145,15 @@ module CollavreOpenclaw
       end
 
       comment = Collavre::Comment.create!(comment_attrs)
+
+      # Unique run_id row is the backstop for a concurrent same-run race: the
+      # loser discards its duplicate and returns the winner.
+      if run_id && !CollavreOpenclaw::ProcessedAiRun.claim_proactive(run_id, comment)
+        Rails.logger.warn("[CollavreOpenclaw] Race on run #{run_id} resolved; discarding duplicate comment #{comment.id}")
+        comment.destroy
+        return CollavreOpenclaw::ProcessedAiRun.comment_for(run_id)
+      end
+
       Rails.logger.info("[CollavreOpenclaw] Created AI comment #{comment.id} on creative #{creative_id}")
 
       comment

data/app/models/collavre_openclaw/processed_ai_run.rb

@@ -0,0 +1,72 @@
+module CollavreOpenclaw
+  # Durable idempotency key for OpenClaw Gateway runs. Owned by this engine so
+  # the run concept stays off core collavre's general-purpose comments table.
+  # comment_id is set when a comment owns the run; ON DELETE SET NULL keeps the
+  # row alive as a tombstone after the comment is destroyed (review-fold).
+  class ProcessedAiRun < ApplicationRecord
+    self.table_name = "openclaw_processed_ai_runs"
+
+    belongs_to :comment, class_name: "Collavre::Comment", optional: true
+
+    validates :run_id, presence: true
+
+    def self.processed?(run_id)
+      return false if run_id.blank?
+
+      exists?(run_id: run_id)
+    end
+
+    def self.comment_for(run_id)
+      return nil if run_id.blank?
+
+      find_by(run_id: run_id)&.comment
+    end
+
+    # Returns false when another process already claimed the run, so the caller
+    # discards its duplicate.
+    def self.claim_proactive(run_id, comment)
+      return true if run_id.blank?
+
+      create!(run_id: run_id, comment: comment)
+      true
+    rescue ActiveRecord::RecordNotUnique
+      false
+    rescue StandardError => e
+      Rails.logger.warn("[CollavreOpenclaw::ProcessedAiRun] Failed to claim run #{run_id}: #{e.message}")
+      false
+    end
+
+    # The canonical (activity-logged) reply wins: on a lost race it reclaims the
+    # run from the proactive duplicate and destroys it, leaving one comment.
+    def self.claim_canonical(run_id, comment)
+      return if run_id.blank? || comment.nil?
+
+      create!(run_id: run_id, comment: comment)
+    rescue ActiveRecord::RecordNotUnique
+      reclaim_for(run_id, comment)
+    rescue StandardError => e
+      Rails.logger.warn("[CollavreOpenclaw::ProcessedAiRun] Failed to claim run #{run_id}: #{e.message}")
+    end
+
+    def self.reclaim_for(run_id, canonical)
+      row = find_by(run_id: run_id)
+      return if row.nil?
+
+      duplicate = row.comment
+      if duplicate.nil? || duplicate.id == canonical.id
+        row.update_column(:comment_id, canonical.id)
+        return
+      end
+
+      row.update_column(:comment_id, canonical.id)
+      duplicate.destroy
+      Rails.logger.warn(
+        "[CollavreOpenclaw::ProcessedAiRun] Reclaimed run #{run_id} for comment #{canonical.id}; " \
+        "removed proactive duplicate #{duplicate.id}"
+      )
+    rescue StandardError => e
+      Rails.logger.warn("[CollavreOpenclaw::ProcessedAiRun] Failed to reclaim run #{run_id}: #{e.message}")
+    end
+    private_class_method :reclaim_for
+  end
+end

data/app/services/collavre_openclaw/openclaw_adapter.rb

@@ -106,7 +106,8 @@ module CollavreOpenclaw
         client.chat_send(
           session_key: session_key,
           message: payload[:message],
-          attachments: payload[:attachments]
+          attachments: payload[:attachments],
+          on_run_id: method(:persist_run_id_on_comment)
         ) do |event|
           case event[:state]
           when "delta"
@@ -146,6 +147,20 @@ module CollavreOpenclaw
       end
     end
 
+    # Claim the run for the solicited reply so the same run's final, re-delivered
+    # as "proactive" to other processes, is suppressed. This reply is canonical
+    # (it carries the activity log), so it reclaims on a lost race.
+    def persist_run_id_on_comment(run_id)
+      return if run_id.blank?
+
+      comment = @context[:comment]
+      return unless comment.respond_to?(:id) && comment.id.present?
+
+      CollavreOpenclaw::ProcessedAiRun.claim_canonical(run_id, comment)
+    rescue StandardError => e
+      Rails.logger.warn("[CollavreOpenclaw] Failed to persist run_id on comment: #{e.message}")
+    end
+
     def build_ws_chat_payload
       {
         message: format_message_for_ws,

data/app/services/collavre_openclaw/proactive_message_handler.rb

@@ -150,7 +150,7 @@ module CollavreOpenclaw
       effective_session_key = session_key || buffer&.dig(:session_key)
       context = self.class.parse_session_key(effective_session_key)
 
-      dispatch_to_job(user, content, context)
+      dispatch_to_job(user, content, context, run_id)
     end
 
     def handle_error(run_id, _user, payload)
@@ -208,7 +208,7 @@ module CollavreOpenclaw
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def dispatch_to_job(user, content, context)
+    def dispatch_to_job(user, content, context, run_id = nil)
       creative_id = context[:creative_id]
 
       unless creative_id.present?
@@ -231,9 +231,11 @@ module CollavreOpenclaw
           "type" => "proactive",
           "content" => content,
           "creative_id" => creative_id,
+          "run_id" => run_id,
           "context" => {
             "creative_id" => creative_id,
-            "thread_id" => context[:topic_id]
+            "thread_id" => context[:topic_id],
+            "run_id" => run_id
           }
         }
       )

data/app/services/collavre_openclaw/session_abort_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CollavreOpenclaw
+  # Aborts an in-flight OpenClaw gateway session for a cancelled task.
+  # Registered into Collavre::AgentSessionAbort so core stays vendor-agnostic.
+  class SessionAbortService
+    def self.call(agent:, task:, creative: nil, comment: nil)
+      new(agent: agent, task: task, creative: creative, comment: comment).call
+    end
+
+    def initialize(agent:, task:, creative: nil, comment: nil)
+      @agent = agent
+      @task = task
+      @creative = creative
+      @comment = comment
+    end
+
+    def call
+      return unless defined?(CollavreOpenclaw::ConnectionManager)
+
+      creative = @creative || @task.creative ||
+                 Collavre::Creative.find_by(id: payload.dig("creative", "id"))
+      comment = @comment || Collavre::Comment.find_by(id: payload.dig("comment", "id"))
+
+      adapter = CollavreOpenclaw::OpenclawAdapter.new(
+        user: @agent,
+        system_prompt: "",
+        context: {
+          creative: creative,
+          user: @agent,
+          task: @task,
+          comment: comment
+        }
+      )
+      conn = CollavreOpenclaw::ConnectionManager.instance.connection_for(@agent)
+      conn.chat_abort(session_key: adapter.session_key)
+    end
+
+    private
+
+    def payload
+      @task.trigger_event_payload || {}
+    end
+  end
+end

data/app/services/collavre_openclaw/websocket_client.rb

@@ -154,9 +154,11 @@ module CollavreOpenclaw
     # @param message [String]
     # @param attachments [Array<Hash>, nil]
     # @param idempotency_key [String]
+    # @param on_run_id [#call, nil] called with the resolved Gateway runId before
+    #   streaming, so callers can persist it as a cross-process idempotency key.
     # @yield [Hash] chat events with :state, :text, :message keys
     # @return [String, nil] final response text
-    def chat_send(session_key:, message:, attachments: nil, idempotency_key: nil, &block)
+    def chat_send(session_key:, message:, attachments: nil, idempotency_key: nil, on_run_id: nil, &block)
       ensure_connected!
       touch_activity!
 
@@ -198,6 +200,15 @@ module CollavreOpenclaw
         end
       end
 
+      # Surface runId before streaming; guard so a faulty callback can't abort the stream.
+      if on_run_id
+        begin
+          on_run_id.call(actual_run_id)
+        rescue StandardError => e
+          Rails.logger.warn("[CollavreOpenclaw::WS] on_run_id callback failed: #{e.message}")
+        end
+      end
+
       # Stream events until final/error/aborted
       last_seq = nil
 

data/config/initializers/session_abort.rb

@@ -0,0 +1,5 @@
+Rails.application.config.to_prepare do
+  if defined?(Collavre::AgentSessionAbort)
+    Collavre::AgentSessionAbort.register("openclaw", CollavreOpenclaw::SessionAbortService)
+  end
+end

data/db/migrate/20260609040000_create_openclaw_processed_ai_runs.rb

@@ -0,0 +1,15 @@
+class CreateOpenclawProcessedAiRuns < ActiveRecord::Migration[8.1]
+  # Unique run_id guarantees at most one comment per Gateway run across all
+  # processes and reconnects. ON DELETE SET NULL keeps the row as a tombstone
+  # after its comment is destroyed (review-fold), so re-deliveries stay deduped.
+  def change
+    create_table :openclaw_processed_ai_runs do |t|
+      t.string :run_id, null: false
+      t.references :comment, null: true, foreign_key: { on_delete: :nullify }
+
+      t.timestamps
+    end
+
+    add_index :openclaw_processed_ai_runs, :run_id, unique: true
+  end
+end

data/lib/collavre_openclaw/version.rb

@@ -1,3 +1,3 @@
 module CollavreOpenclaw
-  VERSION = "0.6.2"
+  VERSION = "0.6.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: collavre_openclaw
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors:
 - Collavre
@@ -81,14 +81,17 @@ files:
 - app/jobs/collavre_openclaw/callback_processor_job.rb
 - app/models/collavre_openclaw/application_record.rb
 - app/models/collavre_openclaw/pending_callback.rb
+- app/models/collavre_openclaw/processed_ai_run.rb
 - app/services/collavre_openclaw/ai_client_extension.rb
 - app/services/collavre_openclaw/connection_manager.rb
 - app/services/collavre_openclaw/em_reactor.rb
 - app/services/collavre_openclaw/openclaw_adapter.rb
 - app/services/collavre_openclaw/proactive_message_handler.rb
+- app/services/collavre_openclaw/session_abort_service.rb
 - app/services/collavre_openclaw/websocket_client.rb
 - config/initializers/ai_client_extension.rb
 - config/initializers/integration_settings.rb
+- config/initializers/session_abort.rb
 - config/locales/en.yml
 - config/locales/ko.yml
 - config/routes.rb
@@ -102,6 +105,7 @@ files:
 - db/migrate/20260202140000_rename_api_token_to_api_key_in_openclaw_accounts.rb
 - db/migrate/20260202150001_migrate_pending_callbacks_to_user.rb
 - db/migrate/20260202150002_drop_openclaw_accounts.rb
+- db/migrate/20260609040000_create_openclaw_processed_ai_runs.rb
 - lib/collavre_openclaw.rb
 - lib/collavre_openclaw/configuration.rb
 - lib/collavre_openclaw/engine.rb