brainiac-discord 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afab8518a3314e7873e2bec99ba79f7efeedf1b45b80be5ccc9d0654d0b64b77
-  data.tar.gz: a39348b184343d375313e1ca30e746165690562a729bac532e9880af4a9b540c
+  metadata.gz: 3b1fa3c52f3226376895626cbf3ba0d97963dcd8ea9f5ae227f4615797e48a6c
+  data.tar.gz: 99b890d0c8ccb29079b2617e0cd661aef8c703040b90db58a148938a73fc2990
 SHA512:
-  metadata.gz: aecb0bff2e82096ba8ec67c7a862a9316025030fa999d87c323f023a95ab463807c0dcf1eac5b7055b1d6307f346acf80fd08ae0805bf21c7e248fc29e3f35b5
-  data.tar.gz: aeb1f966c703cbf553d50535dcf6768ef1af4fc38443c47b0e0d4544dd11c42d5cf31049ccc86a7a8d6efdfd7e256e9f02c898cac9792ebc82732c243ba4692b
+  metadata.gz: 5754062ffb91909ec05451e84b3b03fca71754cbe9cb4434e154eb9e70df34654ffcd7c37c28be4adea593628944bc2d9b19a46d7d60fc08c15b7ebb40848520
+  data.tar.gz: ac00ebaa2b82042fb2fc7abbf3dcf94d1f674b0b9ded9a1e3fd7cd3974f0256ff0162440935acaa9b334e3eb2f081ed1393aaf2de87b99e61aa53fed8a0c4bcf

data/lib/brainiac/plugins/discord/gateway.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "websocket-client-simple"
+require "websocket"
 
 module Brainiac
   module Plugins
@@ -12,6 +13,15 @@ module Brainiac
       # and MESSAGE_REACTION_ADD events to handler functions.
       module Gateway
         GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json"
+        GATEWAY_QUERY = "?v=10&encoding=json"
+
+        # Reconnect backoff (seconds). A normal disconnect starts at BASE and
+        # doubles up to CAP; a handshake rejection (HTTP non-101, e.g. Discord
+        # returning 429 to the WebSocket upgrade) starts higher to avoid a
+        # reconnect storm across many bots hammering the gateway in lockstep.
+        BACKOFF_BASE = 5
+        BACKOFF_HANDSHAKE_BASE = 30
+        BACKOFF_CAP = 300
 
         # Per-bot state: { agent_key => { token:, user_id:, status:, thread: } }
         @bots = {}
@@ -142,19 +152,80 @@ module Brainiac
 
           private
 
+          # Resolve the gateway URL to connect to, and honor Discord's session
+          # start limits. Queries GET /gateway/bot (authenticated) which returns
+          # the recommended WebSocket URL plus session_start_limit. If the bot
+          # has exhausted its identify allowance, sleep until the window resets
+          # before returning so we don't burn reconnects against a hard limit.
+          # Falls back to the hardcoded GATEWAY_URL if the call fails.
+          def resolve_gateway_url(bot_token, agent_display)
+            info = Api.request(:get, "/gateway/bot", token: bot_token, log_errors: false)
+            unless info.is_a?(Hash) && info["url"]
+              LOG.warn "[Discord:#{agent_display}] Could not fetch /gateway/bot, using default URL" if defined?(LOG)
+              return GATEWAY_URL
+            end
+
+            honor_session_limit(info["session_start_limit"], agent_display)
+
+            "#{info["url"]}/#{GATEWAY_QUERY}"
+          rescue StandardError => e
+            LOG.warn "[Discord:#{agent_display}] /gateway/bot lookup failed: #{e.message}, using default URL" if defined?(LOG)
+            GATEWAY_URL
+          end
+
+          # If Discord reports no remaining identifies, wait out the reset window.
+          def honor_session_limit(limit, agent_display)
+            return unless limit.is_a?(Hash)
+
+            remaining = limit["remaining"].to_i
+            return if remaining.positive?
+
+            reset_after_s = (limit["reset_after"].to_i / 1000.0).ceil
+            reset_after_s = 1 if reset_after_s <= 0
+            LOG.warn "[Discord:#{agent_display}] Session start limit exhausted, waiting #{reset_after_s}s" if defined?(LOG)
+            sleep reset_after_s
+          end
+
+          # Exponential backoff with full jitter, capped. `attempt` is 0-based.
+          def backoff_delay(attempt, base)
+            capped = [base * (2**attempt), BACKOFF_CAP].min
+            # Full jitter: random between base and the capped ceiling.
+            rand(base.to_f..capped.to_f).round(1)
+          end
+
           def start_gateway_for(agent_key, bot_token)
             thread = Thread.new do
               agent_display = agent_display_name(agent_key) || agent_key.capitalize
               bot_user_id = nil
+              attempt = 0
 
               loop do
                 bot_user_id = run_gateway_connection(agent_key, agent_display, bot_token, bot_user_id)
+                # A clean return means the connection was established at least
+                # once; reset backoff so a later transient drop recovers fast.
+                attempt = 0
+                delay = backoff_delay(attempt, BACKOFF_BASE)
+                LOG.info "[Discord:#{agent_display}] Reconnecting in #{delay}s..." if defined?(LOG)
+                sleep delay
+              rescue WebSocket::Error::Handshake::InvalidStatusCode => e
+                @bots_mutex.synchronize do
+                  @bots[agent_key][:status] = "error" if @bots[agent_key]
+                end
+                delay = backoff_delay(attempt, BACKOFF_HANDSHAKE_BASE)
+                attempt += 1
+                if defined?(LOG)
+                  LOG.error "[Discord:#{agent_display}] Gateway handshake rejected (#{e.message}) — " \
+                            "likely rate limited; backing off #{delay}s"
+                end
+                sleep delay
               rescue StandardError => e
                 @bots_mutex.synchronize do
                   @bots[agent_key][:status] = "error" if @bots[agent_key]
                 end
-                LOG.error "[Discord:#{agent_display}] Gateway error: #{e.message}, reconnecting in 5s..." if defined?(LOG)
-                sleep 5
+                delay = backoff_delay(attempt, BACKOFF_BASE)
+                attempt += 1
+                LOG.error "[Discord:#{agent_display}] Gateway error: #{e.message}, reconnecting in #{delay}s..." if defined?(LOG)
+                sleep delay
               end
             end
             @bots_mutex.synchronize { @bots[agent_key][:thread] = thread if @bots[agent_key] }
@@ -172,10 +243,17 @@ module Brainiac
               bots[agent_key][:token] = bot_token
             end
 
-            LOG.debug "[Discord:#{agent_display}] Connecting to Gateway..." if defined?(LOG) && LOG.respond_to?(:debug)
+            # The WebSocket handshake runs in websocket-client-simple's own reader
+            # thread, so a non-101 response surfaces via the :error callback rather
+            # than raising here. Capture it and re-raise after the connection wait
+            # so the reconnect loop can apply handshake-specific backoff.
+            handshake_error = nil
+
+            gateway_url = resolve_gateway_url(bot_token, agent_display)
+            LOG.debug "[Discord:#{agent_display}] Connecting to #{gateway_url}" if defined?(LOG) && LOG.respond_to?(:debug)
             heartbeat_thread = nil
             last_sequence = nil
-            ws = WebSocket::Client::Simple.connect(GATEWAY_URL)
+            ws = WebSocket::Client::Simple.connect(gateway_url)
 
             ws.on :message do |msg|
               next if msg.data.nil? || msg.data.empty?
@@ -203,22 +281,40 @@ module Brainiac
             end
 
             ws.on :error do |e|
+              handshake_error = e if e.is_a?(WebSocket::Error::Handshake::InvalidStatusCode)
               LOG.error "[Discord:#{agent_display}] WebSocket error: #{e.message}" if defined?(LOG)
             end
 
-            wait_for_disconnect(ws, agent_display)
+            wait_for_disconnect(ws, agent_display) { handshake_error }
+
+            # If the connection never opened because Discord rejected the upgrade,
+            # propagate so the caller backs off harder instead of tight-looping.
+            raise handshake_error if handshake_error && !ws.open?
+
             bot_user_id
           end
 
+          # Block until the socket closes. Returns promptly if a handshake error
+          # is reported (the socket never opens in that case). Backoff between
+          # reconnects is owned by the caller (start_gateway_for).
           def wait_for_disconnect(websocket, agent_display)
+            # Give the handshake a brief window to complete before deciding the
+            # socket is dead, so we don't treat a still-connecting socket as lost.
+            grace = 10
+            grace.times do
+              sleep 0.5
+              break if websocket.open? || (block_given? && yield)
+            end
+
             loop do
-              sleep 1
-              next if websocket.open?
+              return if block_given? && yield && !websocket.open?
 
-              LOG.info "[Discord:#{agent_display}] Connection lost, reconnecting in 5s..." if defined?(LOG)
-              sleep 5
-              break
+              break unless websocket.open?
+
+              sleep 1
             end
+
+            LOG.info "[Discord:#{agent_display}] Connection lost" if defined?(LOG)
           end
 
           def handle_gateway_op(websocket, payload, agent_key, agent_display, bot_token, bot_user_id, heartbeat_thread, last_sequence)

data/lib/brainiac/plugins/discord/message.rb

@@ -607,7 +607,8 @@ module Brainiac
               resolved: resolved, project_config: project_config,
               session_key: session_key, supersede_key: supersede_key,
               attachment_paths: attachment_paths, timestamp: timestamp, response_dir: response_dir,
-              profile: parse_inline_tags(clean_content)[:profile]
+              profile: resolve_thread_profile(thread_map_key, clean_content),
+              explicit_model: explicit_model_tag?(clean_content, project_config, cli_provider_override: cli_provider_override)
             )
           end
 
@@ -712,6 +713,55 @@ module Brainiac
                      "cli=#{cli_provider}, model=#{model}, effort=#{effort}"
           end
 
+          # Resolve the profile ([profile:X]/[p:X]) for this dispatch and make it sticky.
+          #
+          # An inline tag wins and is saved on the thread map entry (and the core work item),
+          # so later untagged replies in the same thread keep running on that profile until a
+          # different [p:X] replaces it. Without a tag, the stored thread profile is used, then
+          # the work item's (e.g. set from a Fizzy card). nil means the default profile.
+          # Unknown profile names are passed through (core ignores them with a warning) but
+          # never saved, so a typo can't pin the thread to a nonexistent profile.
+          def resolve_thread_profile(thread_map_key, clean_content)
+            inline = parse_inline_tags(clean_content)[:profile]
+            return inline unless thread_map_key
+
+            if inline
+              persist_thread_profile(thread_map_key, inline) if !defined?(profile_entry) || profile_entry(inline)
+              return inline
+            end
+
+            entry = Config.thread_map_mutex.synchronize { Config.load_thread_map[thread_map_key] }
+            return nil unless entry
+
+            entry["profile"] || work_item_profile_for(entry["branch"])
+          end
+
+          def persist_thread_profile(thread_map_key, profile)
+            branch = Config.thread_map_mutex.synchronize do
+              map = Config.load_thread_map
+              entry = map[thread_map_key]
+              next nil unless entry
+
+              if entry["profile"] != profile
+                entry["profile"] = profile
+                Config.save_thread_map(map)
+                LOG.info "[Discord] Persisted profile for #{thread_map_key}: #{profile}" if defined?(LOG)
+              end
+              entry["branch"]
+            end
+
+            return unless branch && defined?(update_work_item_overrides) &&
+                          method(:update_work_item_overrides).parameters.any? { |t, n| t == :key && n == :profile }
+
+            update_work_item_overrides(branch: branch, profile: profile)
+          end
+
+          def work_item_profile_for(branch)
+            return nil unless branch && defined?(work_item_overrides_for)
+
+            work_item_overrides_for(branch: branch)["profile"]
+          end
+
           def explicit_model_tag?(clean_content, project_config, cli_provider_override: nil)
             return false unless project_config
 
@@ -871,6 +921,8 @@ module Brainiac
                         "model" => model, "effort" => effort, "created_at" => Time.now.iso8601 }
               entry["branch"] = branch if branch
               entry["chat_mode"] = true if chat_mode
+              # Keep a sticky profile when an entry is rebuilt (e.g. its worktree was recreated).
+              entry["profile"] = map.dig(thread_map_key, "profile") if map.dig(thread_map_key, "profile")
               map[thread_map_key] = entry
               Config.save_thread_map(map)
             end
@@ -906,7 +958,8 @@ module Brainiac
           def spawn_agent(agent_key:, agent_name:, bot_token:, channel_id:, message_id:, discord_user:,
                           work_dir:, prompt_file:, response_file:, meta_file:, model:, effort:,
                           actual_resume:, resolved:, project_config:,
-                          session_key:, supersede_key:, attachment_paths:, timestamp:, response_dir:, profile: nil)
+                          session_key:, supersede_key:, attachment_paths:, timestamp:, response_dir:, profile: nil,
+                          explicit_model: nil)
             agent_config_name = agent_key.downcase.gsub(/[^a-z0-9-]/, "-")
             log_file = File.join(response_dir, "discord-agent-#{timestamp}-#{agent_key}-#{message_id}.log")
 
@@ -926,6 +979,10 @@ module Brainiac
             # XDG_DATA_HOME). An explicitly-requested [profile:X] wins over agent
             # env; the default profile is only a fallback. See core profiles.rb.
             agent_env = profile_spawn_env(agent_env, profile) if defined?(profile_spawn_env)
+            # The *effective* profile name that actually ran (explicit if valid,
+            # else the default profile) — recorded in durable history so the
+            # monitor can show which account/profile the session used.
+            effective_profile = defined?(effective_profile_name) ? effective_profile_name(profile) : profile
             unless agent_env.empty?
               spawn_env.merge!(agent_env)
               LOG.info "[Discord:#{agent_name}] Injecting #{agent_env.size} env var(s): #{agent_env.keys.join(", ")}" if defined?(LOG)
@@ -942,6 +999,22 @@ module Brainiac
               LOG.info "[Discord:#{agent_name}] Injecting GitHub App token (GH_TOKEN) for bot identity" if defined?(LOG)
             end
 
+            # For providers with no runtime --model flag (e.g. kiro-cli, model_flag: ""),
+            # persist the model to the provider's settings store before spawning. Discord
+            # dispatches its own agents and never calls core's run_agent, so we invoke the
+            # same helper here — running it under the fully-assembled spawn_env so the write
+            # targets the correct account's KIRO_HOME. No-op when a model_flag is configured.
+            # explicit_model tells the helper whether this came from an inline tag: an explicit
+            # [auto] writes (a deliberate reset), a defaulted "auto" does not. Guard the kwarg
+            # against older core builds whose apply_settings_model has no `explicit:` param.
+            if defined?(apply_settings_model)
+              if method(:apply_settings_model).parameters.any? { |t, n| t == :key && n == :explicit }
+                apply_settings_model(model, resolved, spawn_env, explicit: explicit_model)
+              else
+                apply_settings_model(model, resolved, spawn_env)
+              end
+            end
+
             head_before, status_before = capture_brainiac_state(project_config, work_dir)
             prompt_mode = resolved["prompt_mode"] || "stdin"
 
@@ -966,7 +1039,8 @@ module Brainiac
               attachment_paths: attachment_paths, project_config: project_config,
               head_before: head_before, status_before: status_before,
               supersede_key: supersede_key,
-              resolved: resolved, model: model, work_dir: work_dir, started_at: started_at
+              resolved: resolved, model: model, work_dir: work_dir, started_at: started_at,
+              profile: effective_profile
             )
           end
 
@@ -1145,7 +1219,7 @@ module Brainiac
           def monitor_agent(pid:, session_key:, agent_name:, agent_config_name:, channel_id:, message_id:,
                             bot_token:, response_file:, meta_file:, prompt_file:, log_file:,
                             attachment_paths:, project_config:, head_before:, status_before:, supersede_key: nil,
-                            resolved: nil, model: nil, work_dir: nil, started_at: nil)
+                            resolved: nil, model: nil, work_dir: nil, started_at: nil, profile: nil)
             Thread.new do
               Process.wait(pid)
               exit_status = $CHILD_STATUS
@@ -1162,7 +1236,7 @@ module Brainiac
                 agent_name: agent_name, agent_config_name: agent_config_name,
                 channel_id: channel_id, message_id: message_id, log_file: log_file,
                 resolved: resolved, model: model, work_dir: work_dir, started_at: started_at,
-                exit_status: exit_status
+                exit_status: exit_status, profile: profile
               )
 
               if exit_status.signaled? || session_cancelled
@@ -1205,7 +1279,8 @@ module Brainiac
           # Fully best-effort: archive_session_history already rescues internally, but we
           # guard here too so a history failure can never break Discord's completion path.
           def archive_discord_session_history(agent_name:, agent_config_name:, channel_id:, message_id:,
-                                              log_file:, resolved:, model:, work_dir:, started_at:, exit_status:)
+                                              log_file:, resolved:, model:, work_dir:, started_at:, exit_status:,
+                                              profile: nil)
             return unless defined?(archive_session_history)
 
             ctx = {
@@ -1219,6 +1294,7 @@ module Brainiac
               chdir: work_dir,
               agent_cli: resolved && resolved["agent_cli"],
               model: model,
+              profile: profile,
               started_at: started_at
             }
 

data/lib/brainiac/plugins/discord/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Discord
-      VERSION = "0.0.16"
+      VERSION = "0.0.17"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-discord
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Andy Davis