collavre_openclaw 0.2.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff70659073539f4ad6104e96ed6c9a85f4b639cf30e6bfdb6e56166d1e5cdf1d
-  data.tar.gz: c96bff5a56ef9f74fc011d649a3be81cbba192c3a3fabbac13281d48929d2d11
+  metadata.gz: e7022c888e2fbe72f646eba7d022d489ff1458da405058638c0b15bc426076ec
+  data.tar.gz: 4b822a95fba2cba72b9ceda1d8a92f24919b8982221d8ef4ce1ed6cddea4ade0
 SHA512:
-  metadata.gz: a3ba72b2e7fd8de71f8276858c8b81ef3767203c6769ab456d837bb9b1dc94f78c6a2584308582dcdf439e48c11d098d6d3673aecc0e34dd01775a5f9263334d
-  data.tar.gz: eddfebd33fbce4ffd79eb80b33d7715e46706947973b4c406b7d866ff98902de24e9bd8ddaa7addf91c6fad6d071aed195f0dbd36800e59a3fbc832feb5e10cd
+  metadata.gz: 26df63f943760253bba51dd0667e06a6fdac8821a5982e49163d9d6114f94eed5ff110f47d4af58531e22a966f7efa669f3cacafb608c3446b9d025530b9806f
+  data.tar.gz: 33b8d566a78989521fe384add9bdedbdce668422c9658176c4c9cd2aa5620e31fa3fe247f7aefb82fd045ba33573bcfce391f2d3f88c8788c32a6d4737ce3cdb

data/app/jobs/collavre_openclaw/callback_processor_job.rb

@@ -2,6 +2,8 @@ module CollavreOpenclaw
   class CallbackProcessorJob < ApplicationJob
     queue_as :default
 
+    DEDUP_WINDOW = 5.seconds
+
     def perform(user_id, payload)
       @user = User.find_by(id: user_id)
       return unless @user
@@ -98,9 +100,22 @@ module CollavreOpenclaw
         return
       end
 
+      effective_creative = creative.effective_origin
+
+      # Dedup: skip if an identical comment was recently created
+      existing = Collavre::Comment
+        .where(user: @user, creative: effective_creative, content: content)
+        .where("created_at > ?", DEDUP_WINDOW.ago)
+        .first
+
+      if existing
+        Rails.logger.warn("[CollavreOpenclaw] Duplicate comment suppressed for creative #{creative_id} (existing comment #{existing.id})")
+        return existing
+      end
+
       # Build comment attributes
       comment_attrs = {
-        creative: creative.effective_origin,
+        creative: effective_creative,
         user: @user,
         content: content,
         private: false

data/app/services/collavre_openclaw/openclaw_adapter.rb

@@ -35,7 +35,11 @@ module CollavreOpenclaw
       end
 
       # Try WebSocket first, fall back to HTTP
-      if websocket_available?
+      # Set OPENCLAW_TRANSPORT=http to force HTTP-only mode
+      if CollavreOpenclaw.config.transport == "http"
+        Rails.logger.info("[CollavreOpenclaw] Using HTTP transport (forced by config)")
+        chat_via_http(messages, &block)
+      elsif websocket_available?
         chat_via_websocket(messages, &block)
       else
         chat_via_http(messages, &block)

data/app/services/collavre_openclaw/proactive_message_handler.rb

@@ -21,8 +21,12 @@ module CollavreOpenclaw
     # How often (seconds) to check for stale buffers.
     SWEEP_INTERVAL = 60
 
+    # Cooldown (seconds) to remember dispatched runIds and suppress duplicates.
+    DISPATCHED_RUN_TTL = 60
+
     def initialize
-      @buffers = {}   # runId → { text:, session_key:, connection_owner_id:, created_at: }
+      @buffers = {}           # runId → { text:, session_key:, connection_owner_id:, created_at: }
+      @dispatched_runs = {}   # runId → monotonic timestamp (dedup for broadcast+nodeSend duplicates)
       @mutex = Mutex.new
       @last_sweep_at = monotonic_now
     end
@@ -116,7 +120,18 @@ module CollavreOpenclaw
     def handle_final(run_id, user, session_key, payload)
       final_text = extract_text(payload)
 
-      buffer = @mutex.synchronize { @buffers.delete(run_id) }
+      buffer = @mutex.synchronize do
+        # Check if we already dispatched this runId (broadcast+nodeSend duplicate)
+        if @dispatched_runs.key?(run_id)
+          Rails.logger.info(
+            "[CollavreOpenclaw::Proactive] Suppressing duplicate final for runId=#{run_id}"
+          )
+          @buffers.delete(run_id)
+          return
+        end
+
+        @buffers.delete(run_id)
+      end
 
       # Prefer final text (complete message) over buffered deltas (fragments).
       # Fall back to buffered deltas only when final text is empty.
@@ -128,6 +143,9 @@ module CollavreOpenclaw
 
       return unless content.present?
 
+      # Mark as dispatched before enqueuing to prevent duplicates
+      @mutex.synchronize { @dispatched_runs[run_id] = monotonic_now }
+
       # Use session_key from final event, falling back to buffered
       effective_session_key = session_key || buffer&.dig(:session_key)
       context = self.class.parse_session_key(effective_session_key)
@@ -166,6 +184,7 @@ module CollavreOpenclaw
 
       @last_sweep_at = now
       cutoff = now - BUFFER_TTL
+      dispatched_cutoff = now - DISPATCHED_RUN_TTL
 
       @mutex.synchronize do
         stale_ids = @buffers.each_with_object([]) do |(run_id, buf), ids|
@@ -179,6 +198,9 @@ module CollavreOpenclaw
             "(older than #{BUFFER_TTL}s)"
           )
         end
+
+        # Sweep expired dispatched run entries
+        @dispatched_runs.delete_if { |_id, ts| ts < dispatched_cutoff }
       end
     end
 

data/app/services/collavre_openclaw/websocket_client.rb

@@ -19,6 +19,8 @@ module CollavreOpenclaw
   # - Rails threads call public methods which bridge via EM.next_tick + Queue
   class WebsocketClient
     PROTOCOL_VERSION = 3
+    COMPLETED_RUN_COOLDOWN = 5  # seconds to suppress late-arriving events for completed runs
+    SEEN_EVENT_TTL = 30         # seconds to remember (runId, seq) pairs for dedup
 
     attr_reader :user, :state
 
@@ -32,6 +34,8 @@ module CollavreOpenclaw
       @connect_waiters = []   # Queues for threads waiting on in-progress connect
       @pending_requests = {}  # id → { queue:, timer: }
       @pending_runs = {}      # runId → Queue (for chat.send streaming)
+      @completed_runs = {}    # runId → monotonic timestamp (cooldown for late events)
+      @seen_chat_events = {}  # "runId:seq" → monotonic timestamp (broadcast+nodeSend dedup)
       @proactive_handler = nil
       @reconnect_attempts = 0
       @last_activity_at = nil
@@ -169,6 +173,8 @@ module CollavreOpenclaw
       end
 
       # Stream events until final/error/aborted
+      last_seq = nil
+
       loop do
         event = wait_with_timeout(run_queue, config.read_timeout, "chat response")
 
@@ -178,12 +184,27 @@ module CollavreOpenclaw
           raise ChatError, event[:error]
         end
 
+        # Gateway may broadcast + nodeSend the same event, causing
+        # duplicates on the same WebSocket.  Skip already-seen seqs.
+        seq = event[:seq]
+        if seq && last_seq && seq <= last_seq
+          next
+        end
+        last_seq = seq if seq
+
         case event[:state]
         when "delta"
           text = extract_event_text(event)
           if text.present?
-            response_text << text
-            yield({ state: "delta", text: text }) if block_given?
+            # Gateway sends accumulated content (full text so far) in
+            # each delta event.  Compute the incremental delta for callers.
+            delta = if response_text.present? && text.start_with?(response_text)
+                      text[response_text.length..]
+            else
+                      text
+            end
+            response_text.replace(text)
+            yield({ state: "delta", text: delta }) if delta.present? && block_given?
           end
         when "final"
           text = extract_event_text(event)
@@ -205,6 +226,11 @@ module CollavreOpenclaw
         @pending_runs.delete(actual_run_id) if actual_run_id
         # Also clean up idempotency_key if send_rpc failed before we got a runId
         @pending_runs.delete(idempotency_key) if idempotency_key
+
+        # Record completed runs so late-arriving events are suppressed
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @completed_runs[actual_run_id] = now if actual_run_id
+        @completed_runs[idempotency_key] = now if idempotency_key && idempotency_key != actual_run_id
       end
     end
 
@@ -329,17 +355,18 @@ module CollavreOpenclaw
     end
 
     def send_connect_request(challenge_payload)
-      agent_id = extract_agent_id
-      device_id = "collavre-#{@user.id}-#{Digest::SHA256.hexdigest(@user.id.to_s)[0..7]}"
+      # Use valid client constants from OpenClaw protocol schema.
+      # "gateway-client" and "backend" are appropriate for server-side integrations.
+      # Do NOT include partial `device` — it requires full attestation (publicKey, signature, signedAt).
 
       params = {
         minProtocol: PROTOCOL_VERSION,
         maxProtocol: PROTOCOL_VERSION,
         client: {
-          id: "collavre",
+          id: "gateway-client",
           version: CollavreOpenclaw::VERSION,
           platform: "ruby",
-          mode: "operator"
+          mode: "backend"
         },
         role: "operator",
         scopes: [ "operator.read", "operator.write" ],
@@ -348,10 +375,7 @@ module CollavreOpenclaw
         permissions: {},
         auth: { token: @user.llm_api_key },
         locale: "en-US",
-        userAgent: "collavre-openclaw/#{CollavreOpenclaw::VERSION}",
-        device: {
-          id: device_id
-        }
+        userAgent: "collavre-openclaw/#{CollavreOpenclaw::VERSION}"
       }
 
       request_id = SecureRandom.uuid
@@ -398,6 +422,14 @@ module CollavreOpenclaw
 
     def handle_chat_event(payload)
       run_id = payload[:runId]
+      seq = payload[:seq]
+
+      # Dedup: Gateway sends identical events via broadcast() + nodeSendToSession().
+      # Skip if we've already seen this (runId, seq) pair.
+      if run_id && seq && duplicate_chat_event?(run_id, seq)
+        Rails.logger.debug("[CollavreOpenclaw::WS] Skipping duplicate chat event (runId=#{run_id}, seq=#{seq})")
+        return
+      end
 
       # Check if this is a response to a pending chat.send
       run_queue = @mutex.synchronize { @pending_runs[run_id] }
@@ -405,6 +437,9 @@ module CollavreOpenclaw
       if run_queue
         # Known run — forward to the waiting thread
         run_queue.push(payload)
+      elsif recently_completed_run?(run_id)
+        # Late-arriving event for a run we already finished — suppress it
+        Rails.logger.info("[CollavreOpenclaw::WS] Suppressing late event for completed runId=#{run_id}")
       elsif @proactive_handler
         # Unknown run — proactive message from Gateway (cron/heartbeat)
         Rails.logger.info("[CollavreOpenclaw::WS] Proactive message received (runId=#{run_id})")
@@ -414,6 +449,41 @@ module CollavreOpenclaw
       end
     end
 
+    # Check if this (runId, seq) pair was already seen. Records it if new.
+    # Gateway emits each event via broadcast() AND nodeSendToSession(),
+    # delivering the identical payload (same runId + seq) twice.
+    def duplicate_chat_event?(run_id, seq)
+      key = "#{run_id}:#{seq}"
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      @mutex.synchronize do
+        # Sweep expired entries periodically
+        if @seen_chat_events.size > 100
+          @seen_chat_events.delete_if { |_k, ts| now - ts > SEEN_EVENT_TTL }
+        end
+
+        if @seen_chat_events.key?(key)
+          true
+        else
+          @seen_chat_events[key] = now
+          false
+        end
+      end
+    end
+
+    # Check if a runId was recently completed (within cooldown window).
+    # Also sweeps expired entries to prevent unbounded growth.
+    def recently_completed_run?(run_id)
+      @mutex.synchronize do
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        # Sweep expired entries
+        @completed_runs.delete_if { |_id, ts| now - ts > COMPLETED_RUN_COOLDOWN }
+
+        @completed_runs.key?(run_id)
+      end
+    end
+
     def handle_tick(_payload)
       # Respond with a tick acknowledgment (poll response)
       send_frame({

data/lib/collavre_openclaw/configuration.rb

@@ -22,6 +22,9 @@ module CollavreOpenclaw
     # WebSocket connect timeout (seconds)
     attr_accessor :ws_connect_timeout
 
+    # Transport mode: "auto" (WebSocket first, HTTP fallback), "http" (HTTP only)
+    attr_accessor :transport
+
     def initialize
       @open_timeout = ENV.fetch("OPENCLAW_OPEN_TIMEOUT", 10).to_i
       @read_timeout = ENV.fetch("OPENCLAW_READ_TIMEOUT", 180).to_i  # 3 minutes for AI responses
@@ -30,6 +33,7 @@ module CollavreOpenclaw
       @ws_reconnect_max = ENV.fetch("OPENCLAW_WS_RECONNECT_MAX", 10).to_i
       @ws_reconnect_base_delay = ENV.fetch("OPENCLAW_WS_RECONNECT_BASE", 1).to_f
       @ws_connect_timeout = ENV.fetch("OPENCLAW_WS_CONNECT_TIMEOUT", 10).to_i
+      @transport = ENV.fetch("OPENCLAW_TRANSPORT", "http")
     end
 
     # Legacy accessor for backward compatibility

data/lib/collavre_openclaw/version.rb

@@ -1,3 +1,3 @@
 module CollavreOpenclaw
-  VERSION = "0.2.2"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: collavre_openclaw
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors:
 - Collavre