pwn 0.5.674 → 0.5.675

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a62ba09707c5e4256e02e501ace75b21fd3d29e0f3239b64e054743e8481deaa
-  data.tar.gz: 8c3a604756f02a0f3e47fc7633cc6ed6b7362adb1613a82db8418668b2e3a1fa
+  metadata.gz: 2ed5f171854df678e76d477ad52fee2dd42e1687afc6e950281d2b3e5fe75ab9
+  data.tar.gz: 35712ab0300a98de2dfc52430278088561b84fcd15e4dd70a3c95cd90ccf4645
 SHA512:
-  metadata.gz: cd13158fb37c453d6ed9eb20008ac7896cd9c31c1f4efdc60a18eaa00878ae1bd0a46cdb640ff4a49bd2edd9eeeb6e14a42f2c59c764916641b57a2a040e6477
-  data.tar.gz: 39a6032209299723a26bb76160b980e4c51f3e7ba5e0bd06d7f1228bde1e5637ef9d91ed7f639071e42f6eeaaa8d9e2be688b678551dc6d14faddf1d8137f492
+  metadata.gz: 563ee1d396728ef91353cfc4e6d82da6b90662d03e55d1c027319203e47a8bd91d9c723a09cda3a6836dc9b1ed380bb3e0bb76d802dd23157ff7c92d52a3958b
+  data.tar.gz: 05e3c313c8262273f5799f24a9359b3cadc5448ccebfc5ae031a99a71865b548d24489208f4b7be6e0d4790485ebcc58d35a3ccdafbfddfecdb27eaddd531b9c

data/Gemfile

@@ -49,7 +49,7 @@ gem 'jwt', '3.2.0'
 gem 'libusb', '0.8.0'
 gem 'luhn', '3.0.0'
 gem 'mail', '2.9.1'
-gem 'mcp', '1.1.0'
+gem 'mcp', '1.2.0'
 gem 'meshtastic', '0.0.173'
 gem 'metasm', '1.0.6'
 gem 'mongo', '2.25.0'

data/bin/pwn

@@ -51,9 +51,11 @@ begin
     # ------------------------------------------------------------------
     if opts[:setup] == true
       r = PWN::Setup.check
+      PWN::Setup.ensure_cron(restart: false)
       exit(r[:ok] ? 0 : 1)
     else
       PWN::Setup.deps(profile: opts[:setup])
+      PWN::Setup.ensure_cron(restart: false)
     end
   elsif opts[:ai]
     # ------------------------------------------------------------------

data/bin/pwn_setup

@@ -59,6 +59,18 @@ pwn_driver.auto_opts_help = false
 pwn_driver.parse!
 
 begin
+  status = 0
+  # Seed default jobs + start/reuse the in-process scheduler so last_run
+  # actually advances. Do this BEFORE the doctor so `pwn setup` reports
+  # the worker as running. Skip list/terminal (no host scheduler needed)
+  # and dry-run (must not spawn).
+  unless opts[:list] || opts[:terminal] || opts[:dry_run]
+    PWN::Setup.ensure_cron(
+      restart: false,
+      dry_run: false
+    )
+  end
+
   if opts[:list]
     PWN::Setup.list_profiles
   elsif opts[:migrate]
@@ -66,7 +78,7 @@ begin
       fix: opts[:fix] || opts[:yes],
       dry_run: opts[:dry_run]
     )
-    exit 1 unless r && r[:after] && r[:after][:incompatible].empty?
+    status = 1 unless r && r[:after] && r[:after][:incompatible].empty?
   elsif opts[:terminal]
     PWN::Setup.terminal(
       yes: opts[:yes],
@@ -83,8 +95,19 @@ begin
     # `pwn setup --check`               → same
     # `pwn setup --check --profile net` → gate ONLY on the :net profile
     r = PWN::Setup.check(profile: opts[:profile])
-    exit 1 unless r[:ok]
+    status = 1 unless r[:ok]
+  end
+
+  # Seed default jobs + start/reuse the in-process scheduler so
+  # last_run actually advances. Skip list/terminal (no host scheduler
+  # needed) and dry-run (must not spawn).
+  unless opts[:list] || opts[:terminal] || opts[:dry_run]
+    PWN::Setup.ensure_cron(
+      restart: false,
+      dry_run: false
+    )
   end
+  exit status
 rescue Interrupt
   puts "\naborted."
   exit 130

data/lib/pwn/ai/agent/loop.rb

@@ -1063,6 +1063,16 @@ module PWN
         # 3.2 — local models cannot afford auto_introspect (judge+prm+critic+
         # sentinel+extro) on every success. Default :failure_only when local.
         private_class_method def self.should_auto_introspect?(opts = {})
+          kind = (opts[:kind] || Thread.current[:pwn_request_kind]).to_s.to_sym
+          intent = (opts[:intent] || Thread.current[:pwn_request_intent]).to_s.to_sym
+          fails = opts[:turn_fails].is_a?(Hash) ? opts[:turn_fails].values.sum : 0
+          # Cheap answers already returned user-visible text. The post-answer
+          # critic + 12s ORM printed ERROR: Timed out reading data from server
+          # after greetings / takes / questions.
+          return false if %i[greeting howto recall].include?(intent)
+          return false if kind == :statement
+          return false if kind == :question && fails.zero?
+
           return true unless opts[:local]
 
           policy = agent_flag(key: :local_introspect, default: :failure_only).to_s.to_sym

data/lib/pwn/ai/agent/reflect.rb

@@ -97,7 +97,8 @@ module PWN
                   system_role_content: system_role_content,
                   spinner: spinner,
                   timeout: timeout,
-                  temp: temp
+                  temp: temp,
+                  quiet: opts[:quiet]
                 )
               end
             ensure
@@ -132,6 +133,7 @@ module PWN
           chat_opts[:timeout] = opts[:timeout] unless opts[:timeout].nil?
           chat_opts[:temp] = opts[:temp] unless opts[:temp].nil?
           chat_opts[:model] = opts[:model] unless opts[:model].to_s.empty?
+          chat_opts[:quiet] = opts[:quiet] unless opts[:quiet].nil?
           mod.chat(chat_opts)
         end
 

data/lib/pwn/ai/agent/reward.rb

@@ -1157,11 +1157,20 @@ module PWN
                 spinner: false,
                 model: judge_model,
                 timeout: cheap_orm_timeout,
-                temp: CHEAP_ORM_TEMP
+                temp: CHEAP_ORM_TEMP,
+                quiet: true
               )
               text = extract_chat_text(resp: raw)
               return text unless text.strip.empty?
-            rescue StandardError
+
+              # Quiet ReadTimeout now returns nil instead of raising. That
+              # empty response already spent the cheap-ORM budget — do not
+              # immediately fire engine_chat_cheap (second 12s stall).
+              return nil
+            rescue StandardError => e
+              # A 12s ReadTimeout already spent the cheap-ORM budget.
+              return nil if timeout_error?(err: e)
+
               nil
             end
           end
@@ -1191,7 +1200,8 @@ module PWN
             system_role_content: opts[:system_role_content],
             spinner: false,
             timeout: cheap_orm_timeout,
-            temp: CHEAP_ORM_TEMP
+            temp: CHEAP_ORM_TEMP,
+            quiet: true
           }
           model = judge_model
           chat_opts[:model] = model unless model.to_s.empty?
@@ -1200,6 +1210,20 @@ module PWN
           nil
         end
 
+        private_class_method def self.timeout_error?(opts = {})
+          err = opts[:err]
+          return false if err.nil?
+
+          klass = err.class
+          name = klass.name.to_s
+          return true if name.include?('Timeout') || name.include?('ReadTimeout') || name.include?('OpenTimeout')
+          return true if err.message.to_s.match?(/timed out reading|read timeout|open timeout/i)
+
+          false
+        rescue StandardError
+          false
+        end
+
         private_class_method def self.cheap_orm_timeout
           n = agent_flag(key: :reward_llm_timeout, default: CHEAP_ORM_TIMEOUT).to_i
           n = CHEAP_ORM_TIMEOUT if n < 2

data/lib/pwn/ai/agent/task_summarizer.rb

@@ -566,7 +566,9 @@ module PWN
               request: user,
               system_role_content: system,
               suppress_pii_warning: true,
-              spinner: false
+              spinner: false,
+              timeout: sidecar_timeout,
+              quiet: true
             )
             text = reflect_text(resp: resp)
             return text unless text.to_s.strip.empty?
@@ -846,7 +848,9 @@ module PWN
               request: user,
               system_role_content: system,
               suppress_pii_warning: true,
-              spinner: false
+              spinner: false,
+              timeout: sidecar_timeout,
+              quiet: true
             )
             text = reflect_text(resp: resp)
             return text unless text.to_s.strip.empty?
@@ -896,7 +900,9 @@ module PWN
           r = mod.chat(
             request: opts[:request],
             system_role_content: opts[:system_role_content],
-            spinner: false
+            spinner: false,
+            timeout: sidecar_timeout,
+            quiet: true
           )
           reflect_text(resp: r)
         rescue StandardError => e
@@ -911,6 +917,17 @@ module PWN
           :ollama
         end
 
+        # Kind / plan classification is a sidecar hop. Bound it so a hung
+        # model cannot stall the user's real answer, and stay quiet on timeout.
+        private_class_method def self.sidecar_timeout
+          n = (PWN::Env.dig(:ai, :agent, :sidecar_llm_timeout) if defined?(PWN::Env)).to_i
+          n = 20 if n < 5
+          n = 60 if n > 60
+          n
+        rescue StandardError
+          20
+        end
+
         # Parse JSON array, fenced JSON, or numbered/bulleted plain text.
         #
         # Supported Method Parameters::

data/lib/pwn/ai/anthropic.rb

@@ -362,7 +362,7 @@ module PWN
                        real_config_value?(value: oauth[:bearer_token]) ||
                        real_config_value?(value: oauth[:refresh_token])
 
-        if token.nil? && (oauth_opt_in || !real_config_value?(value: engine[:key]))
+        if token.nil? && (oauth_opt_in || !real_config_value?(value: engine[:key])) && !opts[:non_interactive]
           token = obtain_oauth_bearer_token(oauth)
           using_oauth = true
         end
@@ -372,9 +372,15 @@ module PWN
           using_oauth = false
         end
 
-        token ||= PWN::Plugins::AuthenticationHelper.mask_password(
-          prompt: 'Anthropic API Key (or run PWN::AI::Anthropic.obtain_oauth_bearer_token for Claude Pro/Max OAuth)'
-        )
+        if token.nil?
+          return nil if opts[:non_interactive]
+
+          token = PWN::Plugins::AuthenticationHelper.mask_password(
+            prompt: 'Anthropic API Key (or run PWN::AI::Anthropic.obtain_oauth_bearer_token for Claude Pro/Max OAuth)'
+          )
+        end
+
+        return nil if token.nil?
 
         http_method = if opts[:http_method].nil?
                         :get
@@ -488,6 +494,122 @@ module PWN
         raise e
       end
 
+      # Supported Method Parameters::
+      # usage = PWN::AI::Anthropic.get_plan_usage(
+      #   timeout: 'optional - seconds (default 8)'
+      # )
+      #
+      # Admin Usage API (organizations/usage_report/messages) yields tokens
+      # used; organizations/rate_limits yields the configured ceiling so the
+      # PS1 can show a percent. Individual accounts without an Admin key
+      # return {available:false}. Never prompts for credentials.
+      public_class_method def self.get_plan_usage(opts = {})
+        timeout = opts[:timeout] || 8
+        return { available: false, engine: :anthropic } unless plan_usage_credentials?
+
+        now = Time.now.utc
+        start_of_month = Time.utc(now.year, now.month, 1)
+        report = parse_plan_usage_json(
+          raw: anthropic_rest_call(
+            rest_call: 'organizations/usage_report/messages',
+            params: {
+              starting_at: start_of_month.strftime('%Y-%m-%dT00:00:00Z'),
+              ending_at: now.strftime('%Y-%m-%dT%H:%M:%SZ'),
+              bucket_width: '1d'
+            },
+            timeout: timeout,
+            spinner: false,
+            non_interactive: true
+          )
+        )
+        used_tokens = sum_usage_tokens(report: report)
+
+        limits = parse_plan_usage_json(
+          raw: anthropic_rest_call(
+            rest_call: 'organizations/rate_limits',
+            timeout: timeout,
+            spinner: false,
+            non_interactive: true
+          )
+        )
+        limit_tokens = first_rate_limit(limits: limits)
+
+        normalized = PWN::AI.normalize_plan_usage(
+          used: used_tokens,
+          limit: limit_tokens,
+          source: 'organizations/usage_report',
+          engine: :anthropic
+        )
+        return normalized if normalized[:available]
+
+        { available: false, engine: :anthropic }
+      rescue StandardError
+        { available: false, engine: :anthropic }
+      end
+
+      private_class_method def self.plan_usage_credentials?
+        engine = PWN::Env.dig(:ai, :anthropic) || {}
+        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
+        real_config_value?(value: engine[:key]) ||
+          real_config_value?(value: oauth[:bearer_token]) ||
+          real_config_value?(value: oauth[:refresh_token])
+      end
+
+      private_class_method def self.parse_plan_usage_json(opts = {})
+        raw = opts[:raw]
+        return nil if raw.nil?
+
+        parsed = JSON.parse(raw.to_s, symbolize_names: true)
+        parsed.is_a?(Hash) ? parsed : nil
+      rescue JSON::ParserError, TypeError
+        nil
+      end
+
+      private_class_method def self.sum_usage_tokens(opts = {})
+        report = opts[:report]
+        return nil unless report.is_a?(Hash)
+
+        buckets = report[:data] || report[:usage] || []
+        total = 0
+        Array(buckets).each do |bucket|
+          next unless bucket.is_a?(Hash)
+
+          results = bucket[:results] || bucket[:usage] || [bucket]
+          Array(results).each do |row|
+            next unless row.is_a?(Hash)
+
+            %i[
+              uncached_input_tokens
+              input_tokens
+              cache_read_input_tokens
+              cache_creation_input_tokens
+              output_tokens
+            ].each { |k| total += row[k].to_i }
+          end
+        end
+        total.positive? ? total : nil
+      end
+
+      private_class_method def self.first_rate_limit(opts = {})
+        limits = opts[:limits]
+        return nil unless limits.is_a?(Hash)
+
+        Array(limits[:data]).each do |group|
+          next unless group.is_a?(Hash)
+
+          Array(group[:limits]).each do |lim|
+            next unless lim.is_a?(Hash)
+
+            type = lim[:type].to_s
+            next unless type.match?(/tokens_per|input_tokens|output_tokens/)
+
+            v = lim[:value].to_f
+            return v if v.positive?
+          end
+        end
+        nil
+      end
+
       # ----------------------------------------------------------------------
       # Native tool-calling adapter for PWN::AI::Agent::Loop.
       #
@@ -832,6 +954,8 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
+          usage = #{self}.get_plan_usage
+
           # One-time Claude Pro/Max OAuth enrollment (PKCE paste flow):
           bearer = #{self}.obtain_oauth_bearer_token
           # Subsequent runs silently refresh via ai.anthropic.oauth.refresh_token

data/lib/pwn/ai/gemini.rb

@@ -118,6 +118,19 @@ module PWN
         raise e
       end
 
+      # Supported Method Parameters::
+      # usage = PWN::AI::Gemini.get_plan_usage(
+      #   timeout: 'optional - seconds (default 8)'
+      # )
+      #
+      # Gemini Generative Language has no subscription-usage endpoint that
+      # returns used-vs-limit for an API key. Cached-miss / unavailable so
+      # the PS1 shows ∞ unless the operator later injects used/limit.
+      public_class_method def self.get_plan_usage(opts = {})
+        _timeout = opts[:timeout] || 8
+        { available: false, engine: :gemini }
+      end
+
       # ----------------------------------------------------------------------
       # Native tool-calling adapter for PWN::AI::Agent::Loop.
       #
@@ -432,6 +445,8 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
+          usage = #{self}.get_plan_usage
+
           response = #{self}.chat(
             request: 'required - message to Gemini',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:gemini][:model])',

data/lib/pwn/ai/grok.rb

@@ -382,7 +382,7 @@ module PWN
                        real_config_value?(value: oauth[:bearer_token]) ||
                        real_config_value?(value: oauth[:refresh_token])
 
-        if token.nil? && (oauth_opt_in || !real_config_value?(value: engine[:key]))
+        if token.nil? && (oauth_opt_in || !real_config_value?(value: engine[:key])) && !opts[:non_interactive]
           # Singular device-flow enrollment. Result is written back into the
           # live oauth hash so subsequent grok_rest_call invocations inside the
           # same pwn / pwn-ai process reuse it silently.
@@ -391,9 +391,15 @@ module PWN
 
         token = engine[:key] if token.nil? && real_config_value?(value: engine[:key])
 
-        token ||= PWN::Plugins::AuthenticationHelper.mask_password(
-          prompt: 'Grok API Key (or run PWN::AI::Grok.obtain_oauth_bearer_token for SuperGrok OAuth)'
-        )
+        if token.nil?
+          return nil if opts[:non_interactive]
+
+          token = PWN::Plugins::AuthenticationHelper.mask_password(
+            prompt: 'Grok API Key (or run PWN::AI::Grok.obtain_oauth_bearer_token for SuperGrok OAuth)'
+          )
+        end
+
+        return nil if token.nil?
 
         http_method = opts[:http_method].nil? ? :get : opts[:http_method].to_s.scrub.to_sym
 
@@ -468,15 +474,24 @@ module PWN
 
           retry
         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}"
+        puts "ERROR: #{e.message}: #{e.response}" unless opts[:quiet]
+        "#{e.message}: #{e.response}" if opts[:quiet]
       rescue StandardError => e
         case e.message
         when '400 Bad Request', '404 Resource Not Found'
-          "#{e.message}: #{e.response}"
+          nil
         else
-          raise e
+          raise e unless opts[:quiet]
+
         end
+        "#{e.message}: #{e.response}"
       ensure
         spin.stop if spinner
       end
@@ -492,6 +507,162 @@ module PWN
         raise e
       end
 
+      # Supported Method Parameters::
+      # usage = PWN::AI::Grok.get_plan_usage(
+      #   timeout: 'optional - seconds (default 8)'
+      # )
+      #
+      # Subscription / team usage for the PS1 percent suffix.
+      # GET /v1/api-key yields team_id; then billing preview /
+      # spending-limits / prepaid balance compute used vs limit.
+      # GET /v1/me is also tried (OAuth personal-team payload).
+      public_class_method def self.get_plan_usage(opts = {})
+        timeout = opts[:timeout] || 8
+        return { available: false, engine: :grok } unless plan_usage_credentials?
+
+        me = parse_plan_usage_json(
+          raw: grok_rest_call(rest_call: 'me', timeout: timeout, spinner: false, quiet: true, non_interactive: true)
+        )
+        if me.is_a?(Hash)
+          used = first_numeric(src: me, keys: %i[used usage spend spent used_usd usage_usd])
+          limit = first_numeric(src: me, keys: %i[limit quota allowance hard_limit spending_limit])
+          normalized = PWN::AI.normalize_plan_usage(
+            used: used,
+            limit: limit,
+            source: 'me',
+            engine: :grok
+          )
+          return normalized if normalized[:available]
+        end
+
+        key_info = parse_plan_usage_json(
+          raw: grok_rest_call(rest_call: 'api-key', timeout: timeout, spinner: false, quiet: true, non_interactive: true)
+        )
+        team_id = key_info.is_a?(Hash) ? key_info[:team_id] : nil
+        team_id ||= me.is_a?(Hash) ? (me[:team_id] || me.dig(:team, :id)) : nil
+
+        if team_id.to_s.strip != ''
+          preview = parse_plan_usage_json(
+            raw: grok_rest_call(
+              rest_call: "billing/teams/#{team_id}/postpaid/invoice/preview",
+              timeout: timeout,
+              spinner: false,
+              quiet: true,
+              non_interactive: true
+            )
+          )
+          limits = parse_plan_usage_json(
+            raw: grok_rest_call(
+              rest_call: "billing/teams/#{team_id}/postpaid/spending-limits",
+              timeout: timeout,
+              spinner: false,
+              quiet: true,
+              non_interactive: true
+            )
+          )
+          balance = parse_plan_usage_json(
+            raw: grok_rest_call(
+              rest_call: "billing/teams/#{team_id}/prepaid/balance",
+              timeout: timeout,
+              spinner: false,
+              quiet: true,
+              non_interactive: true
+            )
+          )
+
+          used = nil
+          limit = nil
+          if preview.is_a?(Hash)
+            core = preview[:coreInvoice] || preview[:core_invoice] || {}
+            used_cents = cents_val(src: core, key: :prepaidCreditsUsed) ||
+                         cents_val(src: core, key: :prepaid_credits_used) ||
+                         core[:amountAfterVat] ||
+                         core[:amount_after_vat]
+            prepaid_cents = cents_val(src: core, key: :prepaidCredits) ||
+                            cents_val(src: core, key: :prepaid_credits)
+            spend_limit_cents = preview[:effectiveSpendingLimit] || preview[:effective_spending_limit]
+            used = to_f_or_nil(value: used_cents)
+            limit = to_f_or_nil(value: spend_limit_cents)
+            limit = to_f_or_nil(value: prepaid_cents).abs if (limit.nil? || limit <= 0) && prepaid_cents
+          end
+          used = to_f_or_nil(value: cents_val(src: balance, key: :total)).to_f.abs if (used.nil? || used <= 0) && balance.is_a?(Hash)
+          if (limit.nil? || limit <= 0) && limits.is_a?(Hash)
+            sl = limits[:spendingLimits] || limits[:spending_limits] || {}
+            limit = to_f_or_nil(value: cents_val(src: sl, key: :effectiveSl)) ||
+                    to_f_or_nil(value: cents_val(src: sl, key: :effectiveHardSl)) ||
+                    to_f_or_nil(value: cents_val(src: sl, key: :softSl))
+          end
+
+          normalized = PWN::AI.normalize_plan_usage(
+            used: used,
+            limit: limit,
+            source: 'billing/teams',
+            engine: :grok
+          )
+          return normalized if normalized[:available]
+        end
+
+        { available: false, engine: :grok }
+      rescue StandardError
+        { available: false, engine: :grok }
+      end
+
+      private_class_method def self.plan_usage_credentials?
+        engine = PWN::Env.dig(:ai, :grok) || {}
+        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
+        real_config_value?(value: engine[:key]) ||
+          real_config_value?(value: oauth[:bearer_token]) ||
+          real_config_value?(value: oauth[:refresh_token])
+      end
+
+      private_class_method def self.parse_plan_usage_json(opts = {})
+        raw = opts[:raw]
+        return nil if raw.nil?
+
+        parsed = JSON.parse(raw.to_s, symbolize_names: true)
+        parsed.is_a?(Hash) ? parsed : nil
+      rescue JSON::ParserError, TypeError
+        nil
+      end
+
+      private_class_method def self.cents_val(opts = {})
+        src = opts[:src]
+        key = opts[:key]
+        return nil unless src.is_a?(Hash)
+
+        v = src[key]
+        return v[:val] if v.is_a?(Hash) && v.key?(:val)
+        return v['val'] if v.is_a?(Hash) && v.key?('val')
+
+        v
+      end
+
+      private_class_method def self.to_f_or_nil(opts = {})
+        val = opts.is_a?(Hash) && opts.key?(:value) ? opts[:value] : opts
+        return nil if val.nil?
+        return val.to_f if val.respond_to?(:to_f)
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+      private_class_method def self.first_numeric(opts = {})
+        src = opts[:src]
+        keys = Array(opts[:keys])
+        return nil unless src.is_a?(Hash)
+
+        keys.each do |k|
+          v = src[k]
+          next if v.nil?
+          next if v.is_a?(Hash)
+
+          f = v.to_f
+          return f if f.positive? || v.to_s.strip.match?(/\A-?\d/)
+        end
+        nil
+      end
+
       # Supported Method Parameters::
       # response = PWN::AI::Grok.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -536,7 +707,8 @@ module PWN
           rest_call: 'chat/completions',
           http_body: http_body,
           timeout: opts[:timeout],
-          spinner: opts[:spinner]
+          spinner: opts[:spinner],
+          quiet: opts[:quiet]
         )
         return nil if response.nil?
 
@@ -616,8 +788,10 @@ module PWN
           rest_call: rest_call,
           http_body: http_body,
           timeout: timeout,
-          spinner: spinner
+          spinner: spinner,
+          quiet: opts[:quiet]
         )
+        return nil if response.nil? || response.to_s.strip.empty?
 
         json_resp = JSON.parse(response, symbolize_names: true)
         assistant_resp = json_resp[:choices].first[:message]
@@ -655,6 +829,8 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
+          usage = #{self}.get_plan_usage
+
           response = #{self}.chat(
             request: 'required - message to Grok',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:grok][:model])',