pwn 0.5.756 → 0.5.758

data/lib/pwn/ai/open_web_ui.rb

@@ -3,6 +3,7 @@
 require 'json'
 require 'base64'
 require 'securerandom'
+require 'uri'
 
 module PWN
   module AI
@@ -433,11 +434,43 @@ module PWN
         raise e
       end
 
+      # Supported Method Parameters::
+      # model = PWN::AI::OpenWebUI.get_model(name: 'required - model id')
+      #
+      # Open WebUI mixes OpenAI-compat rows and proxied Ollama tags. A direct
+      # model route is tried first; otherwise the already-fetched catalog row
+      # is returned. Local tags without a price stay unpriced.
+
+      public_class_method def self.get_model(opts = {})
+        name = opts[:name].to_s.strip
+        raise 'ERROR: Model name is required' if name.empty?
+
+        hop = PWN::AI::ModelCatalog.lookup_opts(opts)
+        encoded = URI.encode_www_form_component(name)
+        row = PWN::AI::ModelCatalog.parse_row(raw: openwebui_rest_call(hop.merge(rest_call: "api/v1/models/#{encoded}")))
+        return row if PWN::AI::ModelCatalog.model_row?(row: row)
+        return nil if opts[:fallback] == false
+
+        listed = PWN::AI::ModelCatalog.parse_row(raw: openwebui_rest_call(hop.merge(rest_call: 'api/v1/models')))
+        found = PWN::AI::ModelCatalog.find_row(models: listed.is_a?(Hash) ? (listed[:data] || listed[:models]) : listed, name: name)
+        return found if found
+
+        tags = PWN::AI::ModelCatalog.parse_row(raw: openwebui_rest_call(hop.merge(rest_call: 'ollama/api/tags')))
+        PWN::AI::ModelCatalog.find_row(models: tags.is_a?(Hash) ? tags[:models] : tags, name: name)
+      rescue StandardError => e
+        raise e if name.empty?
+
+        nil
+      end
+
       # Coerce OpenAI-wire message history into Ollama-native shapes before
       # POST /api/chat (or Open WebUI /ollama/api/chat):
       # - function.arguments must be a Hash/Array object, not a JSON string
       #   (string args → HTTP 400 "can't find closing '}' symbol")
       # - assistant content nil + tool_calls → "" (Open WebUI form validation)
+      # - system/developer rows after the first message are merged into one
+      #   leading system message. Qwen-style templates raise HTTP 500
+      #   "System message must be at the beginning" otherwise.
       private_class_method def self.parse_tool_arguments_object(opts = {})
         raw = opts[:arguments]
         case raw
@@ -460,7 +493,7 @@ module PWN
       end
 
       private_class_method def self.normalize_messages_for_ollama(opts = {})
-        Array(opts[:messages]).filter_map do |m|
+        rows = Array(opts[:messages]).filter_map do |m|
           next unless m.is_a?(Hash)
 
           role = (m[:role] || m['role']).to_s
@@ -510,6 +543,71 @@ module PWN
 
           out
         end
+        lead_system(messages: rows, fold_into_user: opts[:fold_into_user])
+      end
+
+      # One system role is only safe when the server does not already prepend one.
+      # mini-mythos-mission-ready has a Modelfile SYSTEM prompt and a template that
+      # raises if any later message has role system. Fold those rows into the
+      # first user message instead of sending a second system role.
+      private_class_method def self.lead_system(opts = {})
+        parts = []
+        rest = []
+        Array(opts[:messages]).each do |row|
+          next unless row.is_a?(Hash)
+
+          role = (row[:role] || row['role']).to_s
+          if %w[system developer].include?(role)
+            text = (row.key?(:content) ? row[:content] : row['content']).to_s
+            parts << text unless text.strip.empty?
+          else
+            rest << row
+          end
+        end
+        return rest if parts.empty?
+
+        text = parts.join("\n\n")
+        return [{ role: 'system', content: text }] + rest unless opts[:fold_into_user]
+
+        user = rest.find { |row| (row[:role] || row['role']).to_s == 'user' }
+        if user
+          body = (user.key?(:content) ? user[:content] : user['content']).to_s
+          user[:content] = "#{text}\n\n#{body}"
+          user.delete('content')
+          rest
+        else
+          [{ role: 'user', content: text }] + rest
+        end
+      end
+
+      private_class_method def self.strict_system_template?(opts = {})
+        name = opts[:model].to_s.strip
+        return false if name.empty?
+
+        @strict_system_cache ||= {}
+        return @strict_system_cache[name] if @strict_system_cache.key?(name)
+
+        @strict_system_cache[name] = template_rejects_later_system?(model: name)
+      rescue StandardError
+        false
+      end
+
+      private_class_method def self.template_rejects_later_system?(opts = {})
+        name = opts[:model].to_s
+        names = [name]
+        names << "#{name}:latest" unless name.include?(':')
+        names.each do |candidate|
+          raw = openwebui_rest_call(
+            http_method: :post, rest_call: 'ollama/api/show',
+            http_body: { model: candidate }, timeout: 8, quiet: true, non_interactive: true
+          )
+          template = PWN::AI::ModelCatalog.parse_row(raw: raw)
+          text = template.is_a?(Hash) ? (template[:template] || template['template']).to_s : ''
+          return true if text.include?('System message must be at the beginning')
+        end
+        false
+      rescue StandardError
+        false
       end
 
       # Supported Method Parameters::
@@ -529,13 +627,16 @@ module PWN
       # Bare POST /api/chat is not an API route on stock Open WebUI (405).
 
       public_class_method def self.chat_with_tools(opts = {})
-        engine   = PWN::Env[:ai][:openwebui]
-        messages = normalize_messages_for_ollama(messages: opts[:messages])
-        raise 'ERROR: messages array is required' if messages.nil? || messages.empty?
-
+        engine = PWN::Env[:ai][:openwebui]
         model = opts[:model] ||= engine[:model]
         raise 'ERROR: Model is required.  Call #get_models method for details' unless real_config_value?(value: model)
 
+        messages = normalize_messages_for_ollama(
+          messages: opts[:messages],
+          fold_into_user: strict_system_template?(model: model)
+        )
+        raise 'ERROR: messages array is required' if messages.nil? || messages.empty?
+
         temp = opts[:temp].to_f
         temp = engine[:temp].to_f.nonzero? || 1 if temp.zero?
 
@@ -652,6 +753,10 @@ module PWN
         end
 
         http_body[:messages].push(user_role)
+        http_body[:messages] = lead_system(
+          messages: http_body[:messages],
+          fold_into_user: strict_system_template?(model: model)
+        )
 
         timeout = opts[:timeout]
         spinner = opts[:spinner]
@@ -705,6 +810,13 @@ module PWN
           # Run get models and return its result
           #{self}.get_models
 
+          # Return one catalog row. OpenAI-compat and proxied Ollama tags use different routes.
+          #{self}.get_model(
+            name: 'required - model id',
+            timeout: 'optional - seconds (default 15)',
+            fallback: 'optional - false skips the catalog list when the direct route misses'
+          )
+
           # Run chat with tools and return its result
           #{self}.chat_with_tools(
             messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',

data/lib/pwn/ai.rb

@@ -13,6 +13,7 @@ module PWN
     autoload :Grok, 'pwn/ai/grok'
     autoload :HttpRetry, 'pwn/ai/http_retry'
     autoload :MCP, 'pwn/ai/mcp'
+    autoload :ModelCatalog, 'pwn/ai/model_catalog'
     autoload :Ollama, 'pwn/ai/ollama'
     autoload :OpenAI, 'pwn/ai/open_ai'
     autoload :OpenWebUI, 'pwn/ai/open_web_ui'

data/lib/pwn/plugins/repl/ai_console.rb

@@ -686,7 +686,7 @@ module PWN
 
             return clear_view if key == "\u000c"
 
-            if key == "\u0007"
+            if ["\u0007", "\u0013"].include?(key)
               @workspace ? @workspace = nil : open_swarm
               return
             end
@@ -709,7 +709,7 @@ module PWN
               return
             end
 
-            if key == "\u0018"
+            if ["\u0018", "\u0014"].include?(key)
               @menu = nil
               @focus = @focus == :session ? :mission : :session
               return
@@ -757,9 +757,18 @@ module PWN
               end
             when :page_up then @scroll = [(@scroll || (@total_rows.to_i - @page_size.to_i)) - @page_size.to_i, 0].max
             when :page_down
-              @scroll = [@scroll.to_i + @page_size.to_i, @total_rows.to_i].min
-              @scroll = nil if @scroll >= [@total_rows.to_i - @page_size.to_i, 0].max
-              @unseen = 0 unless @scroll
+              bottom = [@total_rows.to_i - @page_size.to_i, 0].max
+              # nil is the live end, not row 0. Treating it as 0 jumps upward, then later presses walk back down.
+              if @scroll.nil? || @scroll >= bottom
+                @scroll = nil
+                @unseen = 0
+              else
+                @scroll = [@scroll + @page_size.to_i, bottom].min
+                if @scroll >= bottom
+                  @scroll = nil
+                  @unseen = 0
+                end
+              end
             when "\t" then accept_completion
             when :home, :end
               if @focus == :session
@@ -1247,11 +1256,34 @@ module PWN
             end
           end
 
+          def header_content_limit
+            compose = @compose_height || 5
+            footer = @footer_height || 1
+            [@height.to_i - compose - footer - 6, 1].max
+          end
+
+          def footer_text
+            text = '/ menu · ^C=cancel · ^D=back · ^L=clear · ^T=toggle pane · ^S=swarm · ^R=search ^O=operations · ↑↓ history · Shift+Enter=newline · Enter=send'
+            @focus == :session ? text.sub('↑↓ history', '↑↓ scroll · HOME · PGUP · PGDN · END') : text
+          end
+
+          def footer_lines
+            wrap(footer_text, [@width.to_i - 2, 1].max)
+          end
+
+          def layout_chrome
+            footer = footer_lines
+            compose = 5
+            footer_height = footer.length
+            compose -= 1 while @height.to_i - 4 - compose - footer_height < 3 && compose > 3
+            [footer, compose, footer_height]
+          end
+
           def draw_header(engine, model)
             header_layout(engine, model)
             content = header_lines(engine, model, @header_text_width)
             # Reserve only the physical minimum: timeline (3), composer (6), footer (1).
-            visible = @header_spans.first([@height - 13, 1].max)
+            visible = @header_spans.first([header_content_limit, 1].max)
             overflow = visible.length < content.length ? ' · ^O full settings' : ''
             height = @header_pane_height || (visible.length + 3)
             left = @header_pane_height || 0
@@ -1303,11 +1335,14 @@ module PWN
             end
             engine = PWN::Env.dig(:ai, :active).to_s
             model = REPL.pwn_ai_engine_model(engine: engine)
+            footer, compose_height, footer_height = layout_chrome
+            @compose_height = compose_height
+            @footer_height = footer_height
             header_height = draw_header(engine, model)
             sidebar = @width >= 100 ? 27 : 0
             pane_width = @width - sidebar - 2
-            compose_height = 6
-            timeline_height = @height - compose_height - 1 - header_height
+            timeline_height = @height - compose_height - footer_height - header_height
+            timeline_height = 3 if timeline_height < 3
             @page_size = timeline_height - 2
             rows = timeline_rows(pane_width - 6)
             @total_rows = rows.length
@@ -1320,19 +1355,13 @@ module PWN
             start = @scroll || [rows.length - @page_size, 0].max
             rows.slice(start, @page_size).to_a.each_with_index { |(color, row), index| put(header_height + 1 + index, 2, row, color) }
             draw_sidebar(header_height, pane_width + 1, timeline_height) if sidebar.positive?
-            compose_y = @height - compose_height - 1
+            compose_y = @height - compose_height - footer_height
             mission_title = @focus == :session ? 'MISSION CONTROL' : 'MISSION CONTROL · active'
             box(compose_y, 0, compose_height, @width - 1, mission_title)
             mark_active(compose_y, 0, @width - 1, mission_title) if @focus != :session
-            draw_composer(compose_y)
-            hint = if @menu
-                     '↑↓/^P/^N select · Tab accept · Esc close'
-                   elsif @focus == :session
-                     '↑↓/Home/End scroll · ^X mission'
-                   else
-                     '↑↓ history · ^X session'
-                   end
-            put(@height - 1, 1, "^C cancel ^D back · #{hint} · ^G swarm ^L clear ^R search ^O status · Enter send", tone(:footer))
+            draw_composer(compose_y, height: compose_height)
+            footer_top = @height - footer_height
+            footer.first(footer_height).each_with_index { |line, index| put(footer_top + index, 1, line, tone(:footer)) }
             draw_menu if @menu
             draw_model_prompt if @model_prompt
             draw_details(engine, model) if @details
@@ -1346,30 +1375,29 @@ module PWN
             @screen.refresh
           end
 
-          def draw_composer(top)
-            return draw_search(top) if @editor.search
+          def draw_composer(top, height: 5)
+            return draw_search(top, height: height) if @editor.search
 
             chars = @editor.text.scan(/\X/)
             before = chars.take(@editor.cursor).join
             rows = wrap(@editor.text, @width - 8, words: false)
             prefix = wrap(before, @width - 8, words: false)
             cursor_row = prefix.length - 1
-            first = [cursor_row - 2, 0].max
+            interior = [height - 2, 1].max
+            first = [cursor_row - (interior - 1), 0].max
             put(top + 1, 2, '›', tone(:prompt)) if first.zero?
-            rows.slice(first, 3).to_a.each_with_index { |row, index| put(top + 1 + index, 4, row, tone(:composer)) }
-            hint = @menu ? 'Tab accept · ↑↓/^P/^N select · Esc close' : '^X pane · ^G swarm · Shift+Enter newline · / commands · ^O status'
-            put(top + 4, 4, fit(hint, @width - 7), tone(:footer))
+            rows.slice(first, interior).to_a.each_with_index { |row, index| put(top + 1 + index, 4, row, tone(:composer)) }
             @cursor_position = [top + 1 + cursor_row - first, [4 + width(prefix.last), @width - 3].min]
           end
 
-          def draw_search(top)
+          def draw_search(top, height: 5)
             search = @editor.search
             query = "reverse search: #{search[:query]}"
             query_rows = wrap(query, @width - 8, words: false)
             put(top + 1, 4, query_rows.last, tone(:category))
             match = search[:match] || '(no match)'
-            wrap(match, @width - 8).first(2).each_with_index { |row, index| put(top + 2 + index, 4, row, tone(:composer)) }
-            put(top + 4, 4, '^R older · Enter accept · Esc cancel', tone(:footer))
+            interior = [height - 2, 1].max
+            wrap(match, @width - 8).first([interior - 1, 1].max).each_with_index { |row, index| put(top + 2 + index, 4, row, tone(:composer)) }
             @cursor_position = [top + 1, [4 + width(query_rows.last), @width - 3].min]
           end
 
@@ -1566,9 +1594,9 @@ module PWN
               cursor = [bottom + 2, [3 + width(chars[first...editor.cursor].join), @width - 3].min]
             else
               swarm_put(bottom + 1, "DRAFT: #{@editor.text}", :composer)
-              swarm_put(bottom + 2, 'Esc/^G return to unchanged mission draft', :footer)
+              swarm_put(bottom + 2, 'Esc/^S/^G return to unchanged mission draft', :footer)
             end
-            put(@height - 1, 1, '^D back · ^G close · actions require Enter', tone(:footer))
+            put(@height - 1, 1, '^D back · ^S/^G close · actions require Enter', tone(:footer))
             @screen.setpos(*(cursor || [0, 2]))
           end
 
@@ -1623,7 +1651,7 @@ module PWN
         public_class_method def self.help
           puts "USAGE:
             # Ctrl+L clears only the session pane, including while busy.
-            # Ctrl+X switches the active pane between SESSION and MISSION CONTROL.
+            # Ctrl+T toggles the active pane between SESSION and MISSION CONTROL. Ctrl+S opens swarm.
             # Up/Down select in menus, recall ~/.pwn/pwn_history in the mission pane, and scroll the session pane when it is active.
             # Search: Enter accepts without sending; Esc restores the draft.
             # Launch the single-owner curses console; non-terminals return unavailable.

data/lib/pwn/plugins/repl/ai_console_usage.rb

@@ -3,7 +3,8 @@
 module PWN
   module Plugins
     module REPL
-      # Provider-reported token totals and explicitly configured USD estimates.
+      # Provider-reported token totals. USD comes from the active model's published
+      # prices, then from explicitly configured rates. Missing prices stay unavailable.
       module AIConsoleUsage
         # Accumulate one observer event per provider completion.
         class Tracker
@@ -18,11 +19,15 @@ module PWN
             @priced = 0.0
             @priced_calls = 0
             @unpriced_calls = 0
+            @catalog_priced = 0
+            @configured_priced = 0
           end
 
           def record(opts = {})
             usage = AIConsoleUsage.normalize(opts)
-            price = AIConsoleUsage.estimate(opts.merge(usage: usage))
+            rates = opts[:rates] || AIConsoleUsage.send(:rates_for, engine: opts[:engine], model: opts[:model])
+            price = AIConsoleUsage.estimate(usage: usage, rates: rates)
+            source = rates.is_a?(Hash) ? rates[:source].to_s : ''
             @lock.synchronize do
               @input += usage[:input_tokens]
               @output += usage[:output_tokens]
@@ -33,6 +38,11 @@ module PWN
               if price
                 @priced += price
                 @priced_calls += 1
+                if source == 'provider'
+                  @catalog_priced += 1
+                else
+                  @configured_priced += 1
+                end
               else
                 @unpriced_calls += 1
               end
@@ -44,10 +54,14 @@ module PWN
             @lock.synchronize do
               status = if @calls.zero?
                          'no provider usage yet'
+                       elsif @unpriced_calls.zero? && @catalog_priced.positive? && @configured_priced.zero?
+                         'estimated from provider model pricing'
+                       elsif @unpriced_calls.zero? && @catalog_priced.positive?
+                         'estimated from configured USD rates and provider model pricing'
                        elsif @unpriced_calls.zero?
                          'estimated from configured USD rates'
                        elsif @priced_calls.zero?
-                         'unavailable: no configured USD rate'
+                         'unavailable: no provider or configured USD rate'
                        else
                          "partial: #{@unpriced_calls} call(s) have no configured rate"
                        end
@@ -66,8 +80,8 @@ module PWN
         public_class_method def self.normalize(opts = {})
           raw = opts[:usage].is_a?(Hash) ? opts[:usage] : opts
           details = raw[:input_tokens_details] || raw[:prompt_tokens_details] || {}
-          cached = integer(value: details[:cached_tokens] || details[:cache_read_input_tokens] || raw[:cache_read_input_tokens])
-          written = integer(value: details[:cache_creation_input_tokens] || raw[:cache_creation_input_tokens])
+          cached = integer(value: details[:cached_tokens] || details[:cache_read_input_tokens] || raw[:cache_read_input_tokens] || raw[:cached_tokens])
+          written = integer(value: details[:cache_creation_input_tokens] || raw[:cache_creation_input_tokens] || raw[:cache_write_tokens])
           input = integer(value: raw[:input_tokens] || raw[:prompt_tokens])
           output = integer(value: raw[:output_tokens] || raw[:completion_tokens])
           reasoning = integer(value: (raw[:output_tokens_details] || {})[:reasoning_tokens] || raw[:reasoning_tokens])
@@ -79,10 +93,12 @@ module PWN
 
         # Price only when every used component has an explicit finite USD rate.
         public_class_method def self.estimate(opts = {})
-          usage = opts[:usage] || normalize(opts)
+          raw = opts[:usage].is_a?(Hash) ? opts[:usage] : opts
+          usage = normalize(usage: raw)
           rates = opts[:rates] || rates_for(engine: opts[:engine], model: opts[:model])
           return nil unless rates.is_a?(Hash)
 
+          rates = apply_long_context(rates: rates, usage: usage)
           components = [
             [usage[:input_tokens] - usage[:cached_tokens] - usage[:cache_write_tokens], rates[:input_per_million]],
             [usage[:cached_tokens], rates[:cache_read_per_million] || rates[:input_per_million]],
@@ -106,12 +122,13 @@ module PWN
               usage: 'required - provider usage hash'
             )
 
-            # Estimate USD only from explicit nonnegative rates; nil means unavailable, never zero.
+            # Estimate USD from the active model's published prices, then configured rates.
+            # nil means unavailable, never a fabricated zero.
             #{self}.estimate(
               usage: 'required - normalized or provider usage hash',
               rates: 'optional - input_per_million, output_per_million, cache_read_per_million, cache_write_per_million',
-              engine: 'optional - provider used to read configured rates',
-              model: 'optional - model key under that provider pricing hash'
+              engine: 'optional - provider whose get_model record publishes prices',
+              model: 'optional - model id passed to that provider get_model'
             )
 
             # Return module authors.
@@ -129,15 +146,184 @@ module PWN
         end
 
         private_class_method def self.rates_for(opts = {})
+          catalog = catalog_rates(opts)
+          return catalog.merge(source: 'provider') if catalog
+
+          configured = configured_rates(opts)
+          configured&.merge(source: 'configured')
+        rescue StandardError
+          configured_rates(opts)&.merge(source: 'configured')
+        end
+
+        private_class_method def self.configured_rates(opts = {})
           engine = opts[:engine].to_s.to_sym
           model = opts[:model].to_s
           pricing = PWN::Env.dig(:ai, engine, :pricing) if defined?(PWN::Env)
           return nil unless pricing.is_a?(Hash)
 
-          pricing[model.to_sym] || pricing[model]
+          found = pricing[model.to_sym] || pricing[model]
+          found.is_a?(Hash) ? found : nil
+        rescue StandardError
+          nil
+        end
+
+        private_class_method def self.catalog_rates(opts = {})
+          rates = extract_rates(row: model_record(opts))
+          return nil unless rates.is_a?(Hash)
+          return nil unless rate?(value: rates[:input_per_million]) && rate?(value: rates[:output_per_million])
+          return nil unless rates[:input_per_million].positive? && rates[:output_per_million].positive?
+
+          rates
+        end
+
+        private_class_method def self.model_record(opts = {})
+          engine = opts[:engine].to_s
+          model = opts[:model].to_s
+          return nil if engine.empty? || model.empty?
+
+          key = "#{engine}\0#{model}"
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          hit = catalog_lock.synchronize { catalog_cache[key] }
+          return hit[:row] if hit && hit[:until] > now
+
+          klass = provider_class(engine: engine)
+          row = klass.get_model(name: model, timeout: 8, fallback: false, non_interactive: true) if klass.respond_to?(:get_model)
+          catalog_lock.synchronize do
+            catalog_cache[key] = { until: now + (row.is_a?(Hash) ? 300 : 30), row: row }
+          end
+          row
         rescue StandardError
           nil
         end
+
+        private_class_method def self.provider_class(opts = {})
+          name = {
+            'anthropic' => :Anthropic, 'gemini' => :Gemini, 'grok' => :Grok,
+            'ollama' => :Ollama, 'openai' => :OpenAI, 'openwebui' => :OpenWebUI
+          }[opts[:engine].to_s.downcase]
+          return nil if name.nil? || !defined?(PWN::AI) || !PWN::AI.const_defined?(name)
+
+          PWN::AI.const_get(name)
+        end
+
+        private_class_method def self.extract_rates(opts = {})
+          row = opts[:row]
+          return nil unless row.is_a?(Hash)
+
+          xai = xai_rates(row: row)
+          return xai if xai
+
+          hashes = pricing_hashes(row: row)
+          input = pick_rate(hashes: hashes, keys: %i[input_per_million input_per_1m input_per_mtok input prompt prompt_price input_cost_per_token input_token_cost])
+          output = pick_rate(hashes: hashes, keys: %i[output_per_million output_per_1m output_per_mtok output completion completion_price output_cost_per_token output_token_cost])
+          return nil unless input && output
+
+          {
+            input_per_million: input,
+            output_per_million: output,
+            cache_read_per_million: pick_rate(hashes: hashes, keys: %i[cache_read_per_million cached_input cached_input_per_million cache_read cached_prompt input_cache_read]),
+            cache_write_per_million: pick_rate(hashes: hashes, keys: %i[cache_write_per_million cache_write cache_creation cache_creation_input_tokens])
+          }.compact
+        end
+
+        # xAI publishes integer USD cents per 100 million tokens. Zero is unpublished, not free.
+        private_class_method def self.xai_rates(opts = {})
+          row = opts[:row]
+          return nil unless row.key?(:prompt_text_token_price) || row.key?('prompt_text_token_price')
+
+          input = xai_usd(value: row[:prompt_text_token_price] || row['prompt_text_token_price'])
+          output = xai_usd(value: row[:completion_text_token_price] || row['completion_text_token_price'])
+          return nil unless input && output
+
+          rates = {
+            input_per_million: input,
+            output_per_million: output,
+            cache_read_per_million: xai_usd(value: row[:cached_prompt_text_token_price] || row['cached_prompt_text_token_price'])
+          }
+          threshold = numeric_value(value: row[:long_context_threshold] || row[:prompt_token_price_threshold])
+          if threshold&.positive?
+            rates[:long_context_tokens] = threshold
+            rates[:long_input_per_million] = xai_usd(value: row[:prompt_text_token_price_long_context])
+            rates[:long_output_per_million] = xai_usd(value: row[:completion_text_token_price_long_context])
+            rates[:long_cache_read_per_million] = xai_usd(value: row[:cached_prompt_text_token_price_long_context])
+          end
+          rates.compact
+        end
+
+        private_class_method def self.xai_usd(opts = {})
+          number = numeric_value(value: opts[:value])
+          return nil unless number&.finite? && number.positive?
+
+          number / 10_000.0
+        end
+
+        private_class_method def self.apply_long_context(opts = {})
+          rates = opts[:rates]
+          threshold = rates[:long_context_tokens]
+          return rates unless threshold.is_a?(Numeric) && threshold.positive?
+          return rates if opts[:usage][:input_tokens].to_i < threshold
+
+          swapped = rates.dup
+          swapped[:input_per_million] = rates[:long_input_per_million] if rate?(value: rates[:long_input_per_million])
+          swapped[:output_per_million] = rates[:long_output_per_million] if rate?(value: rates[:long_output_per_million])
+          swapped[:cache_read_per_million] = rates[:long_cache_read_per_million] if rate?(value: rates[:long_cache_read_per_million])
+          swapped
+        end
+
+        private_class_method def self.pricing_hashes(opts = {})
+          row = opts[:row]
+          nested = [
+            row, row[:pricing], row['pricing'], row[:price], row[:costs],
+            row.dig(:info, :pricing), row.dig(:info, :meta, :pricing), row.dig(:info, 'meta', 'pricing'),
+            row.dig(:metadata, :pricing), row.dig(:details, :pricing)
+          ]
+          nested.grep(Hash)
+        end
+
+        private_class_method def self.pick_rate(opts = {})
+          opts[:hashes].each do |hash|
+            opts[:keys].each do |key|
+              value = hash[key] || hash[key.to_s]
+              rate = money_per_million(value: value, key: key)
+              return rate if rate
+            end
+          end
+          nil
+        end
+
+        private_class_method def self.money_per_million(opts = {})
+          value = opts[:value]
+          if value.is_a?(Hash)
+            unit = (value[:unit] || value['unit'] || value[:per] || value['per']).to_s
+            value = value[:usd] || value['usd'] || value[:amount] || value['amount'] || value[:price] || value['price']
+            opts = opts.merge(value: value, key: unit.empty? ? opts[:key] : unit)
+          end
+          number = numeric_value(value: opts[:value])
+          return nil unless number&.finite? && number.positive?
+
+          key = opts[:key].to_s
+          per_million = key.match?(/per_million|per_1m|per_mtok/)
+          per_token = key.match?(/per_token|token_cost|cost_per_token/) || (!per_million && number < 0.001)
+          per_token ? number * 1_000_000 : number
+        end
+
+        private_class_method def self.numeric_value(opts = {})
+          value = opts[:value]
+          return value if value.is_a?(Numeric)
+          return nil unless value.is_a?(String) && value.match?(/\A-?\d+(\.\d+)?\z/)
+
+          Float(value)
+        rescue StandardError
+          nil
+        end
+
+        private_class_method def self.catalog_lock
+          @catalog_lock ||= Mutex.new
+        end
+
+        private_class_method def self.catalog_cache
+          @catalog_cache ||= {}
+        end
       end
     end
   end

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.756'
+  VERSION = '0.5.758'
 end

data/spec/lib/pwn/ai/grok_spec.rb

@@ -13,6 +13,14 @@ describe PWN::AI::Grok do
     expect(help_response).to respond_to :help
   end
 
+  it 'loads one priced model without listing the catalog' do
+    allow(described_class).to receive(:grok_rest_call).and_return('{"id":"grok-4.7","prompt_text_token_price":20000,"completion_text_token_price":60000}')
+    row = described_class.get_model(name: 'grok-4.7')
+    expect(row[:id]).to eq('grok-4.7')
+    expect(described_class).to have_received(:grok_rest_call).once
+    expect { described_class.get_model(name: ' ') }.to raise_error(RuntimeError, /Model name is required/)
+  end
+
   it 'chat_with_tools sanitizes messages via Loop.openai_wire_messages' do
     src = File.read(described_class.method(:chat_with_tools).source_location.first)
     expect(src).to match(/openai_wire_messages/)