pwn 0.5.686 → 0.5.688

data/lib/pwn/ai/gemini.rb

@@ -46,8 +46,8 @@ module PWN
         http_body = opts[:http_body]
         http_body ||= {}
 
-        timeout = opts[:timeout]
-        timeout ||= 900
+        timeout = PWN::AI::HttpRetry.timeout_s(opts)
+        max_attempts = PWN::AI::HttpRetry.max_attempts(opts)
 
         spinner = opts[:spinner] || false
 
@@ -84,11 +84,31 @@ module PWN
 
           response.body
         rescue RestClient::TooManyRequests => e
-          retry_after = e.response.headers[:retry_after]&.to_i || (0.5 * (retry_count + 1))
-          sleep(retry_after + rand(0.3..5.0))
           retry_count += 1
-
+          if retry_count >= max_attempts
+            unless opts[:quiet]
+              PWN::AI::HttpRetry.report_event(
+                label: 'gemini', which_self: self, quiet: opts[:quiet],
+                http_method: http_method, rest_call: rest_call,
+                extra: '429 retries exhausted', error: e
+              )
+            end
+            raise "Gemini API Error: #{e.message}: #{e.response}"
+          end
+          sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry
+        rescue RestClient::Exceptions::Timeout => e
+          retry_count += 1
+          unless opts[:quiet]
+            PWN::AI::HttpRetry.report_event(
+              label: 'gemini', which_self: self, quiet: opts[:quiet],
+              http_method: http_method, rest_call: rest_call,
+              extra: "timeout=#{timeout}s attempt=#{retry_count}/#{max_attempts}", error: e
+            )
+          end
+          retry if retry_count < max_attempts
+
+          raise "Gemini API Error: #{e.class}: #{e.message}"
         rescue RestClient::ExceptionWithResponse => e
           raise "Gemini API Error: #{e.message}: #{e.response}"
         rescue StandardError => e

data/lib/pwn/ai/grok.rb

@@ -341,7 +341,7 @@ module PWN
       #   rest_call: 'required rest call to make per the schema',
       #   params: 'optional params passed in the URI or HTTP Headers',
       #   http_body: 'optional HTTP body sent in HTTP methods that support it e.g. POST',
-      #   timeout: 'optional timeout in seconds (defaults to 900)',
+      #   timeout: 'optional timeout in seconds (defaults to 180; 5 attempts)',
       #   spinner: 'optional - display spinner (defaults to false)'
       # )
       private_class_method def self.grok_rest_call(opts = {})
@@ -415,8 +415,8 @@ module PWN
         http_body = opts[:http_body]
         http_body ||= {}
 
-        timeout = opts[:timeout]
-        timeout ||= 900
+        timeout = PWN::AI::HttpRetry.timeout_s(opts)
+        max_attempts = PWN::AI::HttpRetry.max_attempts(opts)
 
         spinner = opts[:spinner] || false
 
@@ -466,18 +466,35 @@ module PWN
 
           response
         rescue RestClient::TooManyRequests => e
-          retry_after = e.response.headers[:retry_after]&.to_i ||= (0.5 * (retry_count + 1))
-          sleep(retry_after + rand(0.3..5.0))
           retry_count += 1
-
+          if retry_count >= max_attempts
+            unless opts[:quiet]
+              PWN::AI::HttpRetry.report_event(
+                label: 'grok', which_self: self, quiet: opts[:quiet],
+                http_method: http_method, rest_call: rest_call,
+                extra: '429 retries exhausted', error: e
+              )
+            end
+            return "#{e.message}: #{e.response}"
+          end
+          sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry
+        rescue RestClient::Exceptions::Timeout => e
+          # Sidecar hops (judge / kind / plan) pass quiet:true and a short
+          # timeout. Do not print ERROR: Timed out reading data from server:
+          # — ReadTimeout is ExceptionWithResponse with a nil body.
+          retry_count += 1
+          unless opts[:quiet]
+            PWN::AI::HttpRetry.report_event(
+              label: 'grok', which_self: self, quiet: opts[:quiet],
+              http_method: http_method, rest_call: rest_call,
+              extra: "timeout=#{timeout}s attempt=#{retry_count}/#{max_attempts}", error: e
+            )
+          end
+          retry if retry_count < max_attempts
+
+          nil
         end
-      rescue RestClient::Exceptions::Timeout => e
-        # Sidecar hops (judge / kind / plan) pass quiet:true and a short
-        # timeout. Do not print ERROR: Timed out reading data from server:
-        # — ReadTimeout is ExceptionWithResponse with a nil body.
-        warn "[pwn-ai/grok] #{e.class}: #{e.message} (#{http_method.to_s.upcase} #{rest_call} timeout=#{timeout}s)" unless opts[:quiet]
-        nil
       rescue RestClient::ExceptionWithResponse => e
         puts "ERROR: #{e.message}: #{e.response}" unless opts[:quiet]
         "#{e.message}: #{e.response}" if opts[:quiet]
@@ -512,7 +529,7 @@ module PWN
       #   tool_choice: 'optional - "auto" | "none" | "required" | {type:"function", function:{name:..}}',
       #   model: 'optional - overrides PWN::Env[:ai][:grok][:model]',
       #   temp: 'optional - temperature (defaults to PWN::Env[:ai][:grok][:temp] || 1)',
-      #   timeout: 'optional - seconds (default 900)',
+      #   timeout: 'optional - seconds (default 180)',
       #   spinner: 'optional - display spinner (default false)'
       # )
       #

data/lib/pwn/ai/http_retry.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module PWN
+  module AI
+    # Shared REST timeout / 429 / ReadTimeout policy for every AI provider.
+    # Default wall clock per attempt is 180s with up to 5 attempts (≈900s total).
+    # Short quiet sidecar hops stay single-shot.
+    module HttpRetry
+      DEFAULT_TIMEOUT_S = 180
+      DEFAULT_MAX_ATTEMPTS = 5
+
+      public_class_method def self.timeout_s(opts = {})
+        return DEFAULT_TIMEOUT_S unless opts.is_a?(Hash)
+
+        t = opts[:timeout].to_i
+        t.positive? ? t : DEFAULT_TIMEOUT_S
+      end
+
+      public_class_method def self.max_attempts(opts = {})
+        return 1 unless opts.is_a?(Hash)
+
+        n = opts[:max_attempts].to_i
+        return n if n.positive?
+        return 1 if opts[:quiet]
+        return 1 if opts[:timeout].to_i.positive? && opts[:timeout].to_i < DEFAULT_TIMEOUT_S
+
+        DEFAULT_MAX_ATTEMPTS
+      end
+
+      public_class_method def self.retry_after_s(opts = {})
+        retry_count = [opts[:retry_count].to_i, 1].max
+        retry_after = 0
+        resp = opts[:response]
+        retry_after = resp.headers[:retry_after].to_i if resp.respond_to?(:headers) && resp.headers
+        retry_after = (0.5 * retry_count) if retry_after.to_f <= 0
+        retry_after
+      end
+
+      # Tees provider REST events into the open pwn-ai DEBUG RN log and STDERR.
+      public_class_method def self.report_event(opts = {})
+        return unless opts.is_a?(Hash)
+
+        label = opts[:label].to_s
+        label = 'ai' if label.empty?
+        err = opts[:error]
+        extra = opts[:extra].to_s
+        meth = opts[:http_method].to_s.upcase
+        call = opts[:rest_call].to_s
+        klass = err ? err.class : 'Error'
+        msg = err ? err.message : extra
+        line = "[pwn-ai/#{label}] #{klass}: #{msg} (#{meth} #{call} #{extra})".strip
+        which = opts[:which_self] || self
+        PWN::Plugins::Log.progress(msg: line, which_self: which, cap: 0) if defined?(PWN::Plugins::Log) && PWN::Plugins::Log.debug_enabled?
+        warn line unless opts[:quiet]
+        line
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts <<~USAGE
+          USAGE:
+            PWN::AI::HttpRetry.timeout_s(timeout: nil)         # => 180
+            PWN::AI::HttpRetry.max_attempts(quiet: false)      # => 5
+            PWN::AI::HttpRetry.report_event(
+              label: 'grok',
+              error: e,
+              http_method: :post,
+              rest_call: 'chat/completions'
+            )
+            #{self}.authors
+        USAGE
+      end
+    end
+  end
+end

data/lib/pwn/ai/ollama.rb

@@ -65,8 +65,8 @@ module PWN
         http_body = opts[:http_body]
         http_body ||= {}
 
-        timeout = opts[:timeout]
-        timeout ||= 900
+        timeout = PWN::AI::HttpRetry.timeout_s(opts)
+        max_attempts = PWN::AI::HttpRetry.max_attempts(opts)
 
         spinner = opts[:spinner] || false
         stream = http_body.is_a?(Hash) && http_body[:stream] == true
@@ -173,11 +173,31 @@ module PWN
           end
           response
         rescue RestClient::TooManyRequests => e
-          retry_after = e.response.headers[:retry_after]&.to_i ||= (0.5 * (retry_count + 1))
-          sleep(retry_after + rand(0.3..5.0))
           retry_count += 1
-
+          if retry_count >= max_attempts
+            unless opts[:quiet]
+              PWN::AI::HttpRetry.report_event(
+                label: 'ollama', which_self: self, quiet: opts[:quiet],
+                http_method: http_method, rest_call: rest_call,
+                extra: '429 retries exhausted', error: e
+              )
+            end
+            return "#{e.message}: #{e.response}"
+          end
+          sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry
+        rescue RestClient::Exceptions::Timeout => e
+          retry_count += 1
+          unless opts[:quiet]
+            PWN::AI::HttpRetry.report_event(
+              label: 'ollama', which_self: self, quiet: opts[:quiet],
+              http_method: http_method, rest_call: rest_call,
+              extra: "timeout=#{timeout}s attempt=#{retry_count}/#{max_attempts}", error: e
+            )
+          end
+          retry if retry_count < max_attempts
+
+          nil
         end
       rescue RestClient::ExceptionWithResponse => e
         body = begin

data/lib/pwn/ai/open_ai.rb

@@ -451,8 +451,8 @@ module PWN
         http_body = opts[:http_body]
         http_body ||= {}
 
-        timeout = opts[:timeout]
-        timeout ||= 900
+        timeout = PWN::AI::HttpRetry.timeout_s(opts)
+        max_attempts = PWN::AI::HttpRetry.max_attempts(opts)
 
         spinner = opts[:spinner] || false
 
@@ -502,21 +502,34 @@ module PWN
           end
           response
         rescue RestClient::TooManyRequests => e
-          duration = 0
-          if e.response
-            retry_after = e.response.headers[:retry_after]&.to_i ||= (0.5 * (retry_count + 1))
-            duration = retry_after.to_i
+          retry_count += 1
+          if retry_count >= max_attempts
+            unless opts[:quiet]
+              PWN::AI::HttpRetry.report_event(
+                label: 'openai', which_self: self, quiet: opts[:quiet],
+                http_method: http_method, rest_call: rest_call,
+                extra: '429 retries exhausted', error: e
+              )
+            end
+            return "#{e.message}: #{e.response}"
           end
-          sleep(duration + rand(0.3..5.0))
+          sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
+          retry
+        rescue RestClient::Exceptions::Timeout => e
+          # Sidecar hops pass quiet:true. Never print
+          # ERROR: Timed out reading data from server:
           retry_count += 1
+          unless opts[:quiet]
+            PWN::AI::HttpRetry.report_event(
+              label: 'openai', which_self: self, quiet: opts[:quiet],
+              http_method: http_method, rest_call: rest_call,
+              extra: "timeout=#{timeout}s attempt=#{retry_count}/#{max_attempts}", error: e
+            )
+          end
+          retry if retry_count < max_attempts
 
-          retry
+          nil
         end
-      rescue RestClient::Exceptions::Timeout => e
-        # Sidecar hops pass quiet:true. Never print
-        # ERROR: Timed out reading data from server:
-        warn "[pwn-ai/openai] #{e.class}: #{e.message} (#{http_method.to_s.upcase} #{rest_call} timeout=#{timeout}s)" unless opts[:quiet]
-        nil
       rescue RestClient::ExceptionWithResponse => e
         puts "ERROR: #{e.message}: #{e.response}" unless opts[:quiet]
         "#{e.message}: #{e.response}" if opts[:quiet]

data/lib/pwn/ai/open_web_ui.rb

@@ -77,8 +77,8 @@ module PWN
         http_body = opts[:http_body]
         http_body ||= {}
 
-        timeout = opts[:timeout]
-        timeout ||= 900
+        timeout = PWN::AI::HttpRetry.timeout_s(opts)
+        max_attempts = PWN::AI::HttpRetry.max_attempts(opts)
 
         spinner = opts[:spinner] || false
         stream = http_body.is_a?(Hash) && http_body[:stream] == true
@@ -198,11 +198,31 @@ module PWN
 
           response
         rescue RestClient::TooManyRequests => e
-          retry_after = e.response.headers[:retry_after]&.to_i ||= (0.5 * (retry_count + 1))
-          sleep(retry_after + rand(0.3..5.0))
           retry_count += 1
-
+          if retry_count >= max_attempts
+            unless opts[:quiet]
+              PWN::AI::HttpRetry.report_event(
+                label: 'openwebui', which_self: self, quiet: opts[:quiet],
+                http_method: http_method, rest_call: rest_call,
+                extra: '429 retries exhausted', error: e
+              )
+            end
+            return "#{e.message}: #{e.response}"
+          end
+          sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry
+        rescue RestClient::Exceptions::Timeout => e
+          retry_count += 1
+          unless opts[:quiet]
+            PWN::AI::HttpRetry.report_event(
+              label: 'openwebui', which_self: self, quiet: opts[:quiet],
+              http_method: http_method, rest_call: rest_call,
+              extra: "timeout=#{timeout}s attempt=#{retry_count}/#{max_attempts}", error: e
+            )
+          end
+          retry if retry_count < max_attempts
+
+          nil
         end
       rescue RestClient::ExceptionWithResponse => e
         # Never return nil here — chat_with_tools used to `return nil if response.nil?`

data/lib/pwn/ai.rb

@@ -9,6 +9,7 @@ module PWN
     autoload :Anthropic, 'pwn/ai/anthropic'
     autoload :Gemini, 'pwn/ai/gemini'
     autoload :Grok, 'pwn/ai/grok'
+    autoload :HttpRetry, 'pwn/ai/http_retry'
     autoload :Ollama, 'pwn/ai/ollama'
     autoload :OpenAI, 'pwn/ai/open_ai'
     autoload :OpenWebUI, 'pwn/ai/open_web_ui'

data/lib/pwn/config.rb

@@ -160,7 +160,7 @@ module PWN
             # LLM tangible-task decomposition for autonomous goals (default on).
             task_summary_llm: nil,
             tool_router: nil, # nil = auto (true when :active is local :ollama/:openwebui) — cuts ~11k→~3k schema tokens
-            tool_preference: %w[memory_recall session_recall skills_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember],
+            tool_preference: %w[memory_recall session_recall skills_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember skills_update],
             escalation_persona: 'escalator', # Swarm persona for frontier corrective hints when a local model is stuck
             # sample E3 verify_as_reward: true|false|nil(auto: ~10% local / always frontier when CLAIM_RX hits)
             verify_as_reward: nil,