Add GPT-6 Astra, and price long prompts the way vendors actually bill them

Astra's API access opened today. Capabilities are verified live against
api.openai.com rather than taken from the docs: vision, native PDF, and the
low/medium/high/xhigh/max reasoning range all confirmed on real calls.

Two of its facts don't fit the old catalog shape, and neither is specific to
Astra, so both go in as general mechanism:

Prompt-size pricing. Astra bills 2x input and 1.5x output for the WHOLE
request once the prompt passes 272K. Gemini has long charged a similar bend.
price_tiers expresses this as ordered multiplier data — any threshold, any
vendor, any number of bands, highest one wins, an omitted multiplier meaning
1x. The threshold counts the whole prompt including cached tokens, because a
280K prompt is a 280K prompt to the vendor no matter how much of it was a
cache read. Rates live in the shared catalog, so the CLI ledger, the gateway
ledger and www's calculateCost all read one rule instead of three.

Effort floors. Astra rejects reasoning effort "none", which is exactly what a
classifier turn sends. min_reasoning_effort states the bottom of a model's
range as data, so the adapter clamps up to it and the next model with a
different floor needs no Go change.

ModelPricing still returns the base card for estimates and displays; CostUSD
now goes through ModelPricingAt so a real request prices under the right band.

Author: timothyerwin

catalog/catalog.go

@@ -43,6 +43,22 @@ type CatalogModel struct {
 	PriceOut       float64 `json:"price_out,omitempty"`
 	PriceCacheRead float64 `json:"price_cache_read,omitempty"` // optional override (default in×0.1)
 
+	// PriceTiers bends the rate card by PROMPT SIZE. Several vendors now price a
+	// long prompt differently from a short one (GPT-6 Astra doubles input and
+	// adds half again to output past 272K), and that is a per-request fact, not a
+	// per-model one. Expressing it as ordered multiplier data — rather than a
+	// special case in Go — keeps the rule where every consumer already reads it:
+	// this file is shared verbatim with the gateway and with apps/www's own
+	// calculateCost, and only one of those three can run Go.
+	PriceTiers []PriceTier `json:"price_tiers,omitempty"`
+
+	// MinReasoningEffort is the LOWEST reasoning effort this model accepts, in the
+	// vendor's own vocabulary. Vendors disagree about the bottom of the range —
+	// GPT-5.6 takes "none", GPT-6 Astra's floor is "low" and 400s below it — and
+	// that is a model fact, so it lives here rather than as another adapter bool.
+	// Empty means "no floor": send whatever the effort maps to.
+	MinReasoningEffort string `json:"min_reasoning_effort,omitempty"`
+
 	// Fallback is the model's mid-turn failure chain, in LABELS: who covers
 	// when this model errors after transport retries, walked IN ORDER by the
 	// CLI's recovery executor (availability/billing filtering happens at walk
@@ -56,12 +72,13 @@ type CatalogModel struct {
 // tier word to its vendor, e.g. gemini+flash-lite). First matching rule that
 // DECLARES a field wins for that field.
 type familyRule struct {
-	Match          []string `json:"match,omitempty"`
-	MatchAll       []string `json:"match_all,omitempty"`
-	Window         int      `json:"window,omitempty"`
-	PriceIn        float64  `json:"price_in,omitempty"`
-	PriceOut       float64  `json:"price_out,omitempty"`
-	PriceCacheRead float64  `json:"price_cache_read,omitempty"`
+	Match          []string    `json:"match,omitempty"`
+	MatchAll       []string    `json:"match_all,omitempty"`
+	Window         int         `json:"window,omitempty"`
+	PriceIn        float64     `json:"price_in,omitempty"`
+	PriceOut       float64     `json:"price_out,omitempty"`
+	PriceCacheRead float64     `json:"price_cache_read,omitempty"`
+	PriceTiers     []PriceTier `json:"price_tiers,omitempty"`
 }
 
 func (r familyRule) matches(model string) bool {
@@ -217,37 +234,109 @@ func MaxOutputTokens(model string) int {
 	return 0
 }
 
+// MinReasoningEffort returns the lowest reasoning effort a model accepts, or ""
+// when the catalog declares no floor. Adapters clamp against it so a cheap
+// classifier turn can't 400 on a model whose range starts above "none".
+func MinReasoningEffort(model string) string {
+	if m, ok := LookupModel(model); ok {
+		return m.MinReasoningEffort
+	}
+	return ""
+}
+
 // Pricing is APPROXIMATE per-model rates in USD per MILLION tokens. Cache write ≈
 // 1.25× base input; cache read ≈ 0.1× base input unless the catalog overrides it.
 type Pricing struct{ Input, Output, CacheWrite, CacheRead float64 }
 
+// PriceTier is one prompt-size pricing band: once a request's prompt exceeds
+// AbovePromptTokens, every rate on the card is multiplied for the WHOLE request
+// (not just the tokens past the line — that is how vendors actually bill it).
+//
+// A multiplier left at 0 means 1× (unchanged), so a tier states only what it
+// bends. Tiers are independent: the highest threshold a prompt clears wins, so
+// order in JSON doesn't matter and a vendor can declare as many bands as it likes.
+type PriceTier struct {
+	AbovePromptTokens int     `json:"above_prompt_tokens"`
+	In                float64 `json:"in,omitempty"`
+	Out               float64 `json:"out,omitempty"`
+	CacheRead         float64 `json:"cache_read,omitempty"`
+	CacheWrite        float64 `json:"cache_write,omitempty"`
+}
+
+// scale applies one multiplier, treating 0 (absent) as 1×.
+func scale(v, mult float64) float64 {
+	if mult == 0 {
+		return v
+	}
+	return v * mult
+}
+
+// apply bends a base card by every tier the prompt clears, highest threshold winning.
+func applyTiers(p Pricing, tiers []PriceTier, promptTokens int) Pricing {
+	var win *PriceTier
+	for i := range tiers {
+		t := &tiers[i]
+		if promptTokens > t.AbovePromptTokens && (win == nil || t.AbovePromptTokens > win.AbovePromptTokens) {
+			win = t
+		}
+	}
+	if win == nil {
+		return p
+	}
+	return Pricing{
+		Input:      scale(p.Input, win.In),
+		Output:     scale(p.Output, win.Out),
+		CacheWrite: scale(p.CacheWrite, win.CacheWrite),
+		CacheRead:  scale(p.CacheRead, win.CacheRead),
+	}
+}
+
 func makePricing(in, out, cacheRead float64) Pricing {
 	if cacheRead == 0 {
 		cacheRead = in * 0.1
 	}
 	return Pricing{Input: in, Output: out, CacheWrite: in * 1.25, CacheRead: cacheRead}
 }
 
-// ModelPricing returns the rate card for a model id or label: the catalog entry
-// if it declares one, else the first matching family rule, else the default.
-// Both ledgers price against this (the CLI's and the gateway's), so every id
-// that can serve must resolve to a non-zero card — the family floor guarantees
-// Fireworks-served ids are never $0.
-func ModelPricing(model string) Pricing {
+// rateCard resolves the BASE card plus any prompt-size tiers for a model id or
+// label: the catalog entry if it declares one, else the first matching family
+// rule, else the default. Both ledgers price against this (the CLI's and the
+// gateway's), so every id that can serve must resolve to a non-zero card — the
+// family floor guarantees Fireworks-served ids are never $0.
+func rateCard(model string) (Pricing, []PriceTier) {
 	if m, ok := LookupModel(model); ok && m.PriceIn > 0 {
-		return makePricing(m.PriceIn, m.PriceOut, m.PriceCacheRead)
+		return makePricing(m.PriceIn, m.PriceOut, m.PriceCacheRead), m.PriceTiers
 	}
 	for _, r := range modelCatalog.file.Families {
 		if r.PriceIn > 0 && r.matches(model) {
-			return makePricing(r.PriceIn, r.PriceOut, r.PriceCacheRead)
+			return makePricing(r.PriceIn, r.PriceOut, r.PriceCacheRead), r.PriceTiers
 		}
 	}
-	return makePricing(modelCatalog.file.Defaults.PriceIn, modelCatalog.file.Defaults.PriceOut, 0)
+	return makePricing(modelCatalog.file.Defaults.PriceIn, modelCatalog.file.Defaults.PriceOut, 0), nil
+}
+
+// ModelPricing returns a model's BASE rate card — the short-prompt rates, before
+// any prompt-size tier applies. Estimates and rate displays want this; anything
+// billing a real request must use ModelPricingAt so a long prompt prices right.
+func ModelPricing(model string) Pricing {
+	p, _ := rateCard(model)
+	return p
+}
+
+// ModelPricingAt returns the rate card that actually governs a request whose
+// prompt is promptTokens long — base card with the winning tier's multipliers
+// folded in. promptTokens is the WHOLE prompt: fresh input plus cache reads plus
+// cache writes, since vendors measure the threshold against everything they read.
+func ModelPricingAt(model string, promptTokens int) Pricing {
+	p, tiers := rateCard(model)
+	return applyTiers(p, tiers, promptTokens)
 }
 
-// CostUSD prices one response's token usage under its model's rate card.
+// CostUSD prices one response's token usage under its model's rate card. Token
+// counts here are cache-EXCLUSIVE (see compat.applyUsage), so the prompt that
+// decides the tier is the sum of all three input components.
 func CostUSD(model string, inTok, outTok, cacheRead, cacheWrite int) float64 {
-	p := ModelPricing(model)
+	p := ModelPricingAt(model, inTok+cacheRead+cacheWrite)
 	return (float64(inTok)*p.Input + float64(outTok)*p.Output +
 		float64(cacheRead)*p.CacheRead + float64(cacheWrite)*p.CacheWrite) / 1e6
 }

catalog/models.json

@@ -197,6 +197,42 @@
         "luna"
       ]
     },
+    {
+      "id": "gpt-6-astra",
+      "label": "astra",
+      "vendor": "openai",
+      "window": 1050000,
+      "vision": true,
+      "reasoning": true,
+      "price_in": 10.0,
+      "price_out": 50.0,
+      "price_tiers": [
+        {
+          "above_prompt_tokens": 272000,
+          "in": 2.0,
+          "out": 1.5,
+          "cache_read": 2.0,
+          "cache_write": 2.0
+        }
+      ],
+      "min_reasoning_effort": "low",
+      "_note": "GPT-6 Astra (OpenAI, GA 2026-09-03; API access opened 2026-09-05). Frontier tier. Responses API. 1.05M context, 128K max output, vision, PDF, reasoning (low/medium/high/xhigh/max) - note the floor is \"low\", NOT \"none\": a classifier turn sending none gets a 400, hence min_reasoning_effort. Cached input $1/M = the default in*0.1, so no price_cache_read override. Prompts over 272K bill 2x input/cache and 1.5x output for the WHOLE request; that is the price_tiers entry. Capabilities verified live against api.openai.com, not from docs alone.",
+      "pinnable": true,
+      "group": "OpenAI",
+      "desc": "Strongest reasoning",
+      "name": "GPT-6 Astra",
+      "pdf": true,
+      "www": {
+        "chat": true,
+        "order": 105,
+        "description": "OpenAI frontier GPT-6 Astra. Top-tier intelligence for coding, computer use and professional work, with a 1.05M context window."
+      },
+      "max_output": 128000,
+      "fallback": [
+        "opus",
+        "sol"
+      ]
+    },
     {
       "id": "gpt-5.6-sol",
       "label": "sol",

catalog/pricing_test.go

@@ -169,3 +169,92 @@ func TestSonnet5Pricing(t *testing.T) {
 		t.Fatalf("claude-sonnet-5 = %.2f/%.2f, want 2.00/10.00", p.Input, p.Output)
 	}
 }
+
+// Prompt-size tiers are generic mechanism, not an Astra special case: the base
+// card holds under the threshold, every declared multiplier applies over it, and
+// the bend covers the WHOLE request rather than the tokens past the line.
+func TestPriceTiers(t *testing.T) {
+	base := Pricing{Input: 10, Output: 50, CacheWrite: 12.5, CacheRead: 1}
+	tiers := []PriceTier{{AbovePromptTokens: 272000, In: 2, Out: 1.5, CacheRead: 2, CacheWrite: 2}}
+
+	if got := applyTiers(base, tiers, 272000); got != base {
+		t.Errorf("at the threshold = %+v, want base %+v (strictly ABOVE bends)", got, base)
+	}
+	want := Pricing{Input: 20, Output: 75, CacheWrite: 25, CacheRead: 2}
+	if got := applyTiers(base, tiers, 272001); got != want {
+		t.Errorf("over the threshold = %+v, want %+v", got, want)
+	}
+	if got := applyTiers(base, nil, 10_000_000); got != base {
+		t.Errorf("no tiers = %+v, want base %+v", got, base)
+	}
+}
+
+// An omitted multiplier means 1x, so a tier states only what it bends.
+func TestPriceTierPartialMultipliers(t *testing.T) {
+	base := Pricing{Input: 10, Output: 50, CacheWrite: 12.5, CacheRead: 1}
+	got := applyTiers(base, []PriceTier{{AbovePromptTokens: 100, Out: 3}}, 200)
+	want := Pricing{Input: 10, Output: 150, CacheWrite: 12.5, CacheRead: 1}
+	if got != want {
+		t.Errorf("partial tier = %+v, want %+v", got, want)
+	}
+}
+
+// Several bands are allowed and independent: the highest one the prompt clears
+// wins, regardless of the order they appear in JSON.
+func TestPriceTierHighestWinsRegardlessOfOrder(t *testing.T) {
+	base := Pricing{Input: 10}
+	tiers := []PriceTier{{AbovePromptTokens: 1_000_000, In: 4}, {AbovePromptTokens: 200_000, In: 2}}
+	for _, c := range []struct {
+		prompt int
+		want   float64
+	}{{100_000, 10}, {300_000, 20}, {2_000_000, 40}} {
+		if got := applyTiers(base, tiers, c.prompt).Input; got != c.want {
+			t.Errorf("prompt %d = %v, want %v", c.prompt, got, c.want)
+		}
+	}
+}
+
+// The catalog's Astra entry must actually carry the 272K band, and CostUSD must
+// route a long request through it — this is the money path, not just the struct.
+func TestAstraLongPromptCost(t *testing.T) {
+	if p := ModelPricing("gpt-6-astra"); p.Input != 10 || p.Output != 50 || p.CacheRead != 1 {
+		t.Fatalf("base card = %+v, want 10/50 with cache read 1", p)
+	}
+	// 300K prompt clears 272K: input 2x, output 1.5x.
+	got := CostUSD("gpt-6-astra", 300_000, 1_000, 0, 0)
+	want := (300_000*20.0 + 1_000*75.0) / 1e6
+	if math.Abs(got-want) > 1e-9 {
+		t.Errorf("long-prompt cost = %v, want %v", got, want)
+	}
+	// Same model, short prompt, base rates.
+	short := CostUSD("gpt-6-astra", 1_000, 1_000, 0, 0)
+	if wantShort := (1_000*10.0 + 1_000*50.0) / 1e6; math.Abs(short-wantShort) > 1e-9 {
+		t.Errorf("short-prompt cost = %v, want %v", short, wantShort)
+	}
+}
+
+// The threshold measures the whole prompt, so cache reads and writes count
+// toward it — billing a 280K prompt at base rates just because most of it was
+// cached is exactly the underbill this mechanism exists to prevent.
+func TestPriceTierThresholdCountsCachedPrompt(t *testing.T) {
+	// 10K fresh + 280K cache read = 290K prompt → over the line.
+	got := CostUSD("gpt-6-astra", 10_000, 0, 280_000, 0)
+	want := (10_000*20.0 + 280_000*2.0) / 1e6
+	if math.Abs(got-want) > 1e-9 {
+		t.Errorf("cached long prompt = %v, want %v", got, want)
+	}
+}
+
+// The effort floor is a catalog FACT, not an adapter special case: Astra rejects
+// "none", GPT-5.6 accepts it, and a model that declares no floor reports "".
+func TestMinReasoningEffort(t *testing.T) {
+	if got := MinReasoningEffort("gpt-6-astra"); got != "low" {
+		t.Errorf("astra floor = %q, want \"low\"", got)
+	}
+	if got := MinReasoningEffort("gpt-5.6-sol"); got != "" {
+		t.Errorf("sol floor = %q, want \"\" (no floor)", got)
+	}
+	if got := MinReasoningEffort("some-model-nobody-added"); got != "" {
+		t.Errorf("unknown floor = %q, want \"\"", got)
+	}
+}

models.json

@@ -197,6 +197,42 @@
         "luna"
       ]
     },
+    {
+      "id": "gpt-6-astra",
+      "label": "astra",
+      "vendor": "openai",
+      "window": 1050000,
+      "vision": true,
+      "reasoning": true,
+      "price_in": 10.0,
+      "price_out": 50.0,
+      "price_tiers": [
+        {
+          "above_prompt_tokens": 272000,
+          "in": 2.0,
+          "out": 1.5,
+          "cache_read": 2.0,
+          "cache_write": 2.0
+        }
+      ],
+      "min_reasoning_effort": "low",
+      "_note": "GPT-6 Astra (OpenAI, GA 2026-09-03; API access opened 2026-09-05). Frontier tier. Responses API. 1.05M context, 128K max output, vision, PDF, reasoning (low/medium/high/xhigh/max) - note the floor is \"low\", NOT \"none\": a classifier turn sending none gets a 400, hence min_reasoning_effort. Cached input $1/M = the default in*0.1, so no price_cache_read override. Prompts over 272K bill 2x input/cache and 1.5x output for the WHOLE request; that is the price_tiers entry. Capabilities verified live against api.openai.com, not from docs alone.",
+      "pinnable": true,
+      "group": "OpenAI",
+      "desc": "Strongest reasoning",
+      "name": "GPT-6 Astra",
+      "pdf": true,
+      "www": {
+        "chat": true,
+        "order": 105,
+        "description": "OpenAI frontier GPT-6 Astra. Top-tier intelligence for coding, computer use and professional work, with a 1.05M context window."
+      },
+      "max_output": 128000,
+      "fallback": [
+        "opus",
+        "sol"
+      ]
+    },
     {
       "id": "gpt-5.6-sol",
       "label": "sol",