openclacky 1.5.19 → 1.5.21

data/lib/clacky/utils/model_pricing.rb

@@ -139,6 +139,29 @@ module Clacky
         }
       },
 
+      # Claude Haiku 5.5 (released 2026-10-07) — $0.10/MTok input and $0.50/MTok
+      # output for prompts up to 100K, then 5x those rates above it. Its
+      # breakpoint is the model's own, so the entry declares :tier_threshold and
+      # keys its tiered rates as over_100k; every other Claude entry keeps the
+      # global 200K tier.
+      "claude-haiku-5.5" => {
+        input: {
+          default: 0.10,              # $0.10/MTok for prompts ≤ 100K tokens
+          over_100k: 0.50             # $0.50/MTok for prompts > 100K tokens
+        },
+        output: {
+          default: 0.50,              # $0.50/MTok for prompts ≤ 100K tokens
+          over_100k: 2.50             # $2.50/MTok for prompts > 100K tokens
+        },
+        cache: {
+          write_default: 0.125,       # $0.125/MTok cache write (≤ 100K)
+          write_over_100k: 0.625,     # $0.625/MTok cache write (> 100K)
+          read_default: 0.01,         # $0.01/MTok cache read (≤ 100K)
+          read_over_100k: 0.05        # $0.05/MTok cache read (> 100K)
+        },
+        tier_threshold: 100_000
+      },
+
       "claude-haiku-4.5" => {
         input: {
           default: 1.00,              # $1/MTok
@@ -418,20 +441,107 @@ module Clacky
         }
       },
 
-      # MiniMax M2.7 served through the openclacky gateway (oc- prefix, TokHub
-      # upstream). Same list price as the BYOK minimax-m2.7 entry above.
-      "oc-minimax-m2.7" => {
+      # GPT-6.1 Sol served through the openclacky gateway (oc- prefix, TokHub
+      # gpt group) — the same model as abs-gpt-6.1-sol, which is served by
+      # Bedrock; the two aliases exist because the lanes are priced differently.
+      # OpenAI's own card, tiered at 272K prompt tokens (the model's breakpoint,
+      # not the global 200K): above it every bucket doubles.
+      "oc-gpt-6.1-sol" => {
         input: {
-          default: 0.30,                   # $0.30/MTok cache miss
-          over_200k: 0.30
+          default: 2.00,                   # $2.00/MTok
+          over_272k: 4.00                  # $4.00/MTok
         },
         output: {
-          default: 1.20,                   # $1.20/MTok
-          over_200k: 1.20
+          default: 10.00,                  # $10.00/MTok
+          over_272k: 20.00                 # $20.00/MTok
         },
         cache: {
-          write: 0.30,                     # no separate write charge; bill at miss rate
-          read: 0.06                       # $0.06/MTok cache hit
+          write_default: 2.50,             # $2.50/MTok cache write
+          write_over_272k: 5.00,
+          read_default: 0.10,              # $0.10/MTok cache hit
+          read_over_272k: 0.20
+        },
+        tier_threshold: 272_000
+      },
+
+      # GPT-6 Astra served through the openclacky gateway (oc- prefix, same
+      # ciyuan gpt group as oc-gpt-6.1-sol, hence the same 272K breakpoint and
+      # the same series discount). Its card is much higher than Sol's.
+      "oc-gpt-6-astra" => {
+        input: {
+          default: 10.00,                  # $10.00/MTok
+          over_272k: 20.00                 # $20.00/MTok
+        },
+        output: {
+          default: 50.00,                  # $50.00/MTok
+          over_272k: 75.00                 # $75.00/MTok
+        },
+        cache: {
+          write_default: 12.50,            # $12.50/MTok cache write
+          write_over_272k: 25.00,
+          read_default: 1.00,              # $1.00/MTok cache hit
+          read_over_272k: 2.00
+        },
+        tier_threshold: 272_000
+      },
+
+      # GPT-6 Sol rides the same ciyuan gpt group and 272K breakpoint, and opens
+      # at the same $2 / $10 as 6.1 Sol, but its long-context card is its own:
+      # output goes to $15 (1.5x, not 2x) while cache reads jump 4x to $0.40.
+      "oc-gpt-6-sol" => {
+        input: {
+          default: 2.00,                   # $2.00/MTok
+          over_272k: 4.00                  # $4.00/MTok
+        },
+        output: {
+          default: 10.00,                  # $10.00/MTok
+          over_272k: 15.00                 # $15.00/MTok
+        },
+        cache: {
+          write_default: 2.50,             # $2.50/MTok cache write
+          write_over_272k: 5.00,
+          read_default: 0.10,              # $0.10/MTok cache hit
+          read_over_272k: 0.40
+        },
+        tier_threshold: 272_000
+      },
+
+      # GPT-6 Luna rides the same ciyuan gpt group and 272K breakpoint as
+      # Sol/Astra, but sits at the cheap end: $0.10 in / $0.50 out.
+      "oc-gpt-6-luna" => {
+        input: {
+          default: 0.10,                   # $0.10/MTok
+          over_272k: 0.20                  # $0.20/MTok
+        },
+        output: {
+          default: 0.50,                   # $0.50/MTok
+          over_272k: 0.75                  # $0.75/MTok
+        },
+        cache: {
+          write_default: 0.125,            # $0.125/MTok cache write
+          write_over_272k: 0.25,
+          read_default: 0.01,              # $0.01/MTok cache hit
+          read_over_272k: 0.02
+        },
+        tier_threshold: 272_000
+      },
+
+      # Grok 4.7 served through the openclacky gateway (oc- prefix, TokHub
+      # upstream). Official xAI list price; the long-context surcharge xAI
+      # applies above 200K prompt tokens is not passed through, so both tiers
+      # bill the same here.
+      "oc-grok-4.7" => {
+        input: {
+          default: 2.00,                   # $2.00/MTok
+          over_200k: 2.00
+        },
+        output: {
+          default: 6.00,                   # $6.00/MTok
+          over_200k: 6.00
+        },
+        cache: {
+          write: 2.00,                     # no separate write charge; bill at miss rate
+          read: 0.50                       # $0.50/MTok cache hit
         }
       },
 
@@ -498,6 +608,26 @@ module Clacky
         cache:  { write: 0.06, read: 0.02 }
       },
 
+      # Google Gemini 4 Argon (GA 2026-10-13, via Vertex AI). Flat pricing,
+      # 1M context, 1M output ceiling. Price shown is the current official
+      # rate, which doubles on 2026-12-01 ($4.00/$20.00) — update both this
+      # table and vertexChatRoutes then. Cache write bills at the input rate:
+      # Vertex's OpenAI shim only exposes cache-hit (read) tokens.
+      "gemini-4-argon" => {
+        input: {
+          default: 2.00,
+          over_200k: 2.00
+        },
+        output: {
+          default: 10.00,
+          over_200k: 10.00
+        },
+        cache: {
+          write: 2.00,
+          read: 0.10
+        }
+      },
+
       # Google Gemini 3 series (via Vertex AI). Tiered at 200K input tokens
       # for Pro; Flash has flat pricing.
       "gemini-3.1-pro" => {
@@ -555,6 +685,8 @@ module Clacky
       # through 2026-12-31 before settling at $1.50/$7.50 (list price shown).
       # Cache write billed at input rate (Vertex doesn't expose a separate
       # cache-write charge in the OpenAI shim usage response).
+      # No longer offered through the gateway; the entry stays so records
+      # billed before the retirement still resolve to a price.
       "gemini-3.7-flash" => {
         input: {
           default: 1.50,
@@ -923,6 +1055,7 @@ module Clacky
       # rest of this file; normalize_model_name() lowercases incoming model
       # names before lookup.
 
+      # M2.x is retired on MiniMax's own API but still served via OpenRouter/Ollama — keep these rows.
       # M2.5 — high-throughput text model, optimised for coding and agent tasks
       # (40,960-token context window). Listed at Pay-as-You-Go prices.
       # Source: https://www.minimax.io/models/text (MiniMax-M2.5 product page).
@@ -932,19 +1065,25 @@ module Clacky
         cache:  { write: 0.30, read: 0.03 }
       },
 
-      # M3 (released 2026-06-01) is MiniMax's multimodal flagship (image +
-      # video input, 1,000,000-token context window). Official pricing is
-      # tiered by context length (≤512K vs 512K–1M); per the project's
-      # "displayed ≤ actual" convention we record only the lowest (≤512K)
-      # tier as a flat rate — the global TIERED_PRICING_THRESHOLD is 200K,
-      # so applying the 512K–1M rate to the 200K–512K band would over-charge.
-      # Listed at original (non-promotional) prices: input $0.60, output
-      # $2.40, cache read $0.12 per 1M tokens; cache write is billed at the
-      # input miss rate.
+      # M3.1-Flash (released 2026-10-19) — flat pricing, 1M context. Source:
+      # https://www.minimax.io/blog/minimax-m31f. No cache-write price is
+      # published; billed at the input rate per this table's convention.
+      "minimax-m3.1-flash" => {
+        input:  { default: 0.15, over_200k: 0.15 },
+        output: { default: 0.60, over_200k: 0.60 },
+        cache:  { write: 0.15, read: 0.015 }
+      },
+
+      # M3 — tiered at 512K input tokens; cache write billed at the input rate.
+      # Source: https://platform.minimax.io/docs/guides/pricing-paygo (Standard).
       "minimax-m3" => {
-        input:  { default: 0.60, over_200k: 0.60 },
-        output: { default: 2.40, over_200k: 2.40 },
-        cache:  { write: 0.60, read: 0.12 }
+        input:  { default: 0.30, over_512k: 0.60 },
+        output: { default: 1.20, over_512k: 2.40 },
+        cache:  {
+          write_default: 0.30, write_over_512k: 0.60,
+          read_default:  0.06, read_over_512k:  0.12
+        },
+        tier_threshold: 512_000
       },
 
       # M2.7 — text-only model (204,800-token context window). Listed at
@@ -1058,27 +1197,75 @@ module Clacky
     # platform-served "abs-claude-*" and a BYOK "claude-*" normalise to the
     # same PRICING_TABLE entry, so discounting the table itself would silently
     # cut the price for customers who bring their own credentials. The "oc-*"
-    # aliases exist only on the platform side, so their rules stay narrower than
-    # the BYOK ids leaning on the same list price.
+    # and "or-*" aliases exist only on the platform side, so their rules stay
+    # narrower than the BYOK ids leaning on the same list price.
+    #
+    # Rates follow what the ciyuan upstream bills us. Claude (cc-max group)
+    # costs 0.368x of list and Grok 4.7 (grok group) about 0.086x, so both
+    # carry a deep cut; Kimi K3 (self-hosted tier) costs 0.6x and covers 10%,
+    # while GLM still arrives at 0.8x under its own group and covers only 5%.
+    # Those four are "channel" discounts: they exist because a third-party
+    # channel serves the model below list, which is what the picker tooltip
+    # tells the user. The "or-*" lane is different - it is Google's own Vertex
+    # endpoint, billed at list, and its 20% launch promo lives in the
+    # gateway's VERTEX_DISCOUNT knob, which this table cannot read, so the two
+    # are kept in sync by hand. Vertex promos carry reason "promo" so the UI
+    # explains them as a limited-time offer instead of claiming the model is
+    # served through a third party.
     # The gateway mirrors this list - see seriesDiscount in llm_proxy.
     DISCOUNT_RULES = [
-      { match: /\Aabs-claude-/,   rate: 0.8 },  # Claude series - 20% off
-      { match: /\Aoc-glm-/,       rate: 0.95 }, # GLM via TokHub - 5% off
-      { match: /\Aoc-kimi-/,      rate: 0.95 }, # Kimi via TokHub - 5% off
-      { match: /\Aoc-minimax-/,   rate: 0.95 }  # MiniMax via TokHub - 5% off
+      { match: /\Aabs-claude-/,      rate: 0.6,  reason: "channel" }, # Claude via ciyuan cc-max - 40% off
+      { match: /\Aoc-glm-/,          rate: 0.95, reason: "channel" }, # GLM via ciyuan glm - 5% off
+      { match: /\Aoc-kimi-/,         rate: 0.9,  reason: "channel" }, # Kimi K3 via ciyuan - 10% off
+      { match: /\Aoc-grok-/,         rate: 0.3,  reason: "channel" }, # Grok 4.7 via ciyuan grok - 70% off
+      { match: /\Aoc-gpt-/,          rate: 0.3,  reason: "channel" }, # GPT-6.1 Sol via ciyuan gpt - 70% off
+      { match: /\Aor-(gemini|veo)-/, rate: 0.8,  reason: "promo" }    # Vertex Gemini/Veo launch promo - 20% off
+    ].freeze
+
+    # Lanes sold above the rates in PRICING_TABLE. Bedrock GPT is the only
+    # one: it bills at OpenAI list (Global CRIS carries no premium), so its
+    # 20% is a pricing decision on top of the standard 5% processing fee -
+    # mirrored by bedrockOpenAIMarkup in llm_proxy. BYOK callers hit Bedrock
+    # under their own account and keep the list price, so only the "abs-"
+    # alias matches.
+    MARKUP_RULES = [
+      { match: /\Aabs-gpt-/, rate: 1.2 }
     ].freeze
 
     class << self
+      # Matching promotion for a model alias, or nil when none applies.
+      #   rate   - multiplier applied to the list price
+      #   reason - "channel" when a third-party channel feeds the model below
+      #            list, "promo" when the vendor's own endpoint is discounted
+      def discount_info(model)
+        name = model.to_s.downcase
+        return nil if name.empty?
+
+        rule = DISCOUNT_RULES.find { |r| r[:match].match?(name) }
+        rule ? { rate: rule[:rate], reason: rule[:reason] } : nil
+      end
+
       # Multiplier applied to the final price for a model alias: 1.0 when no
       # promotion applies, otherwise the matching rule's rate.
       def discount_rate(model)
+        info = discount_info(model)
+        info ? info[:rate] : 1.0
+      end
+
+      # Multiplier applied to the list price by the lane serving this alias.
+      def markup_rate(model)
         name = model.to_s.downcase
         return 1.0 if name.empty?
 
-        rule = DISCOUNT_RULES.find { |r| r[:match].match?(name) }
+        rule = MARKUP_RULES.find { |r| r[:match].match?(name) }
         rule ? rule[:rate] : 1.0
       end
 
+      # What a token actually costs us: promotion and lane markup combined.
+      def effective_rate(model)
+        discount_rate(model) * markup_rate(model)
+      end
+
       # Calculate cost for the given model and usage
       #
       # @param model [String] Model identifier
@@ -1109,21 +1296,26 @@ module Clacky
         cache_write_tokens = usage[:cache_creation_input_tokens] || 0
         cache_read_tokens = usage[:cache_read_input_tokens] || 0
 
-        # Determine if we're in the over_200k tier
+        # Determine which tier applies. Haiku 5.5 breaks at 100K instead of the
+        # global 200K, so an entry may declare :tier_threshold and key its
+        # tiered rates as over_<n>k (100_000 → :over_100k) — any breakpoint
+        # works without touching this method.
         # Note: prompt_tokens includes cache_read_tokens but NOT cache_write_tokens
         # cache_write_tokens are additional tokens that were written to cache
+        threshold = pricing[:tier_threshold] || TIERED_PRICING_THRESHOLD
+        tier_key = pricing[:tier_threshold] ? :"over_#{threshold / 1000}k" : :over_200k
         total_input_tokens = prompt_tokens + cache_write_tokens
-        over_threshold = total_input_tokens > TIERED_PRICING_THRESHOLD
+        over_threshold = total_input_tokens > threshold
 
         # Calculate regular input cost (non-cached tokens)
         # prompt_tokens already includes cache_read_tokens, so we need to subtract them
         # cache_write_tokens are not part of prompt_tokens, so they're handled separately in cache_cost
         regular_input_tokens = prompt_tokens - cache_read_tokens
-        input_rate = over_threshold ? pricing[:input][:over_200k] : pricing[:input][:default]
+        input_rate = over_threshold ? pricing[:input][tier_key] : pricing[:input][:default]
         input_cost = (regular_input_tokens / 1_000_000.0) * input_rate
 
         # Calculate output cost
-        output_rate = over_threshold ? pricing[:output][:over_200k] : pricing[:output][:default]
+        output_rate = over_threshold ? pricing[:output][tier_key] : pricing[:output][:default]
         output_cost = (completion_tokens / 1_000_000.0) * output_rate
 
         # Calculate cache costs
@@ -1131,13 +1323,14 @@ module Clacky
           pricing: pricing,
           cache_write_tokens: cache_write_tokens,
           cache_read_tokens: cache_read_tokens,
-          over_threshold: over_threshold
+          over_threshold: over_threshold,
+          tier_key: tier_key
         )
 
         # Promotions are keyed on the requested alias, so apply them last: the
         # table above holds list prices shared with BYOK callers.
         {
-          cost: (input_cost + output_cost + cache_cost) * discount_rate(model),
+          cost: (input_cost + output_cost + cache_cost) * effective_rate(model),
           source: source
         }
       end
@@ -1222,6 +1415,10 @@ module Clacky
           "claude-opus-4.5"
         when /claude.*sonnet.*4[.-]?[5-9]/i
           "claude-sonnet-4.5"
+        # Claude Haiku 5.5 (released 2026-10-07) keeps its own breakpoint (100K)
+        # and its own rates, so it must not fall through to the 4.x branch below.
+        when /claude.*haiku-5[.-]5/i
+          "claude-haiku-5.5"
         when /claude.*haiku.*4[.-]?[5-9]/i
           "claude-haiku-4.5"
         when /claude-3-5-sonnet-20241022/i
@@ -1298,6 +1495,8 @@ module Clacky
           "glm-4.7"
         # MiniMax — model ids in providers.rb use capitalised "MiniMax-M*"
         # but we match case-insensitively and map to the lowercased table key.
+        when /^minimax-m3[.]1-flash$/i
+          "minimax-m3.1-flash"
         when /^minimax-m3$/i
           "minimax-m3"
         when /^minimax-m2\.7$/i
@@ -1331,6 +1530,8 @@ module Clacky
 
         # Google Gemini 3 series. Match the platform aliases (or-gemini-*)
         # and the bare upstream ids returned by Vertex.
+        when /^or-gemini-4-argon$/i, /^gemini-4-argon$/i
+          "gemini-4-argon"
         when /^or-gemini-3-1-pro$/i, /^gemini-3\.1-pro(-preview)?$/i
           "gemini-3.1-pro"
         when /^or-gemini-3-5-flash$/i, /^gemini-3\.5-flash$/i, /^gemini-3-flash(-preview)?$/i
@@ -1382,7 +1583,7 @@ module Clacky
       end
 
       # Calculate cache-related costs
-      def calculate_cache_cost(pricing:, cache_write_tokens:, cache_read_tokens:, over_threshold:)
+      def calculate_cache_cost(pricing:, cache_write_tokens:, cache_read_tokens:, over_threshold:, tier_key: :over_200k)
         cache_cost = 0.0
 
         # Cache write cost
@@ -1391,8 +1592,9 @@ module Clacky
                          # Simple pricing (Opus 4.5, Haiku 4.5)
                          pricing[:cache][:write]
                        elsif over_threshold
-                         # Tiered pricing (Sonnet 4.5)
-                         pricing[:cache][:write_over_200k]
+                         # Tiered pricing (Sonnet 4.5 and friends at 200K,
+                         # Haiku 5.5 at 100K)
+                         pricing[:cache][:"write_#{tier_key}"]
                        else
                          pricing[:cache][:write_default]
                        end
@@ -1406,8 +1608,9 @@ module Clacky
                         # Simple pricing (Opus 4.5, Haiku 4.5)
                         pricing[:cache][:read]
                       elsif over_threshold
-                        # Tiered pricing (Sonnet 4.5)
-                        pricing[:cache][:read_over_200k]
+                        # Tiered pricing (Sonnet 4.5 and friends at 200K,
+                        # Haiku 5.5 at 100K)
+                        pricing[:cache][:"read_#{tier_key}"]
                       else
                         pricing[:cache][:read_default]
                       end

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.5.19"
+  VERSION = "1.5.21"
 end