@gullabs/xai 0.4.1 → 0.5.1

package/README.md

@@ -14,26 +14,28 @@ xAI has no first-party TypeScript SDK. xAI's own quickstart recommends using the
 
 ## Key exports
 
-| Export                  | What it is                                                                                      |
-| ----------------------- | ----------------------------------------------------------------------------------------------- |
-| `xaiProvider(opts?)`    | `ProviderPlugin` factory — bundles the adapter, `grok-4.5` model descriptor, and pricing source |
-| `xaiAdapter(opts?)`     | Creates the `ProviderAdapter` for xAI                                                           |
-| `XaiAdapterOptions`     | `{ client?: XaiClientLike }` — inject a pre-built or fake client                                |
-| `XaiClientLike`         | Structural interface the adapter depends on (satisfied by real SDK and fakes)                   |
-| `buildXaiClient(auth)`  | Builds the real `openai`-SDK-backed client from `AuthMaterial`, pointed at xAI's base URL       |
-| `classifyXaiError(err)` | Classifies a raw thrown error into a typed `LlmError`, including xAI's 400-for-auth quirk       |
-| `grok45ModelDescriptor` | The `grok-4.5` `ModelDescriptor`                                                                |
-| `xaiModelDescriptors`   | Every model descriptor this package contributes (v1: just `grok45ModelDescriptor`)              |
-| `xaiRegistry`           | Pre-built `ModelRegistry` over `xaiModelDescriptors`                                            |
-| `xaiPricingSource()`    | Built-in xAI `PricingSource` port implementation, backed by `XAI_PRICING`                       |
-| `XAI_PRICING`           | Frozen xAI pricing snapshot (µUSD per million tokens)                                           |
-| `XaiModelRates`         | Per-model rate entry type (`inputPerM`, `cachedPerM`, `outputPerM`, optional `gt200k`)          |
-| `Grok45ConfigSchema`    | Strict Zod config schema for `grok-4.5`                                                         |
-| `XaiProviderOptions`    | `{ promptCacheKey? }` — typed `providerOptions.xai` extension shape                             |
-| `XaiFileStore`          | Files API store: upload (TTL), get, list, idempotent delete, content                            |
-| `XaiFileHandle`         | `{ id, filename?, bytes?, expiresAt?, … }` returned by the store                                |
-| `FileDeleteOptions`     | `{ failClosed?, signal? }` — opt-in fail-closed delete for durable release gates                |
-| `XAI_FILE_TTL_*`        | TTL bounds (`3600`…`2592000` seconds) and `XAI_FILE_MAX_BYTES` (48 MiB)                         |
+| Export                  | What it is                                                                                              |
+| ----------------------- | ------------------------------------------------------------------------------------------------------- |
+| `xaiProvider(opts?)`    | `ProviderPlugin` factory — bundles the adapter, `grok-4.5` / `grok-4.6` descriptors, and pricing source |
+| `xaiAdapter(opts?)`     | Creates the `ProviderAdapter` for xAI                                                                   |
+| `XaiAdapterOptions`     | `{ client?: XaiClientLike }` — inject a pre-built or fake client                                        |
+| `XaiClientLike`         | Structural interface the adapter depends on (satisfied by real SDK and fakes)                           |
+| `buildXaiClient(auth)`  | Builds the real `openai`-SDK-backed client from `AuthMaterial`, pointed at xAI's base URL               |
+| `classifyXaiError(err)` | Classifies a raw thrown error into a typed `LlmError`, including xAI's 400-for-auth quirk               |
+| `grok45ModelDescriptor` | The `grok-4.5` `ModelDescriptor`                                                                        |
+| `grok46ModelDescriptor` | The `grok-4.6` `ModelDescriptor`                                                                        |
+| `xaiModelDescriptors`   | Every model descriptor this package contributes (`grok-4.5`, `grok-4.6`)                                |
+| `xaiRegistry`           | Pre-built `ModelRegistry` over `xaiModelDescriptors`                                                    |
+| `xaiPricingSource()`    | Built-in xAI `PricingSource` port implementation, backed by `XAI_PRICING`                               |
+| `XAI_PRICING`           | Frozen xAI pricing snapshot (µUSD per million tokens)                                                   |
+| `XaiModelRates`         | Per-model rate entry type (`inputPerM`, `cachedPerM`, `outputPerM`, optional `gt200k`)                  |
+| `Grok45ConfigSchema`    | Strict Zod config schema for `grok-4.5`                                                                 |
+| `Grok46ConfigSchema`    | Strict Zod config schema for `grok-4.6`                                                                 |
+| `XaiProviderOptions`    | `{ promptCacheKey? }` — typed `providerOptions.xai` extension shape                                     |
+| `XaiFileStore`          | Files API store: upload (TTL), get, list, idempotent delete, content                                    |
+| `XaiFileHandle`         | `{ id, filename?, bytes?, expiresAt?, … }` returned by the store                                        |
+| `FileDeleteOptions`     | `{ failClosed?, signal? }` — opt-in fail-closed delete for durable release gates                        |
+| `XAI_FILE_TTL_*`        | TTL bounds (`3600`…`2592000` seconds) and `XAI_FILE_MAX_BYTES` (48 MiB)                                 |
 
 ## Quick example
 
@@ -49,23 +51,25 @@ const client = createClient({
 const result = await client.generate(
   {
     provider: 'xai',
-    model: 'grok-4.5',
+    model: 'grok-4.6',
     messages: [{ role: 'user', parts: [{ kind: 'text', text: 'Hello' }] }],
   },
   { auth: { apiKey: 'YOUR_XAI_API_KEY' } },
 )
 ```
 
-## grok-4.5
+## grok-4.5 and grok-4.6
 
-The default registry ships exactly one model: `grok-4.5` (500k token context window). It routes through this adapter and supports:
+The default registry ships two canonical models (500k token context window each). They route through this adapter and support:
 
-- **Reasoning** — level-api (`reasoningApi: 'level'`), mapped to the Responses API `reasoning.effort` field. `admittedReasoningEfforts: ['low', 'high']` — this is deliberately narrower than Gemini's effort vocabulary: `'none'` and `'medium'` are **rejected by the live xAI API**, not merely unsupported by this library. The config schema (`Grok45ConfigSchema`) enforces `reasoning.effort` as `'low' | 'high'` only, and there is no `budgetTokens` field at all (xAI uses level-style reasoning, not token budgets) — passing it throws `bad_request`. The schema does not set a default effort; if `reasoning` is omitted, no `reasoning` field is sent and xAI's own server-side default applies.
+- **Reasoning** — level-api (`reasoningApi: 'level'`), mapped to the Responses API `reasoning.effort` field. There is no `budgetTokens` field (xAI uses level-style reasoning) — passing it throws `bad_request`. The schema does not set a default effort; if `reasoning` is omitted, no `reasoning` field is sent and xAI's own server-side default (`high`) applies.
+  - `grok-4.5`: `admittedReasoningEfforts: ['low', 'high']`. `'none'`, `'medium'`, and `'xhigh'` are rejected by `Grok45ConfigSchema` (frozen 2026-07-09 live probe; do not silently widen).
+  - `grok-4.6`: `admittedReasoningEfforts: ['low', 'medium', 'high', 'xhigh']` (live-verified 2026-08-12). `'none'` is rejected by the live API.
 - **Structured output** — native. `output.jsonSchema` maps to the Responses API's `text.format` field with `{ type: 'json_schema', name, schema, strict: true }`, **not** `response_format` — this differs from OpenAI's own convention for the same underlying concept.
 - **`strict: true` performs no OpenAI-style compile-time schema validation, as of the 2026-07-09 live probes.** 2026-07-09 live verification against the real xAI Responses API — 13 single-variant probes plus 1 combined probe (14 calls total, all accepted HTTP 200; the combined probe is recorded as fixture `10-non-strict-schema-accepted.json`) — verified that `text.format` with `strict: true` accepted every one of the following schema shapes that OpenAI's own strict mode rejects at compile time: schemas (root and nested) missing `additionalProperties: false`; properties omitted from `required` (optional properties); `format`, `minLength`, `pattern`, and `default` keywords; `anyOf`; `$defs`/`$ref`; `enum`/`const`; and nullable unions (`type: [T, 'null']`). `strict: false` on the same surface showed no observed behavioral divergence from `strict: true`. This adapter forwards schemas to xAI verbatim — no rewriting, no preflight validation, and no injection of `additionalProperties: false` or `required` completion — so OpenAI-strict schema rewriting (including `@gullabs/codex-cli`'s `toOpenAiStrictOutputSchema` helper) is unnecessary for xai as of that verification date. (Reject-don't-map still applies to genuinely invalid input the xai schema/types layer itself rejects; this note is only about strict-mode compile-time schema-shape enforcement.) `packages/xai/src/__fixtures__/10-non-strict-schema-accepted.json` records one live example combining three of these — missing root `additionalProperties: false`, an optional property, and a `format` keyword — in a single accepted call.
 - **Sampling** — `temperature` and `topP` are forwarded verbatim. No `topK`.
 - **No penalties/stop** — `presence_penalty`, `frequency_penalty`, and `stop` are not in the config schema at all; xAI hard-rejects these on reasoning models, so the schema never admits them (reject-don't-map).
-- **No service tiers** — xAI has no service-tier concept for `grok-4.5`; setting `serviceTier` on the request throws `bad_request`.
+- **Service tiers** — `grok-4.5` admits none; setting `serviceTier` throws `bad_request`. `grok-4.6` admits `serviceTier: 'priority'` only (Responses `service_tier: "priority"`, live-verified 2026-08-12). `'flex'` / `'standard'` / `'batch'` are rejected — xAI silently remaps unknown tiers to `default`, so this library never forwards them.
 
 ## Files store (`XaiFileStore`)
 
@@ -118,7 +122,7 @@ try {
 
 ## Vision constraints
 
-`grok-4.5` accepts image input as an `inline-media` or `file-uri` `Part`, and document attachments as a `file-ref` `Part`:
+Both models accept image input as an `inline-media` or `file-uri` `Part`, and document attachments as a `file-ref` `Part`:
 
 - **`inline-media`** — only `image/jpeg` and `image/png` are accepted; anything else throws `bad_request`. The decoded payload must be at most 20 MiB (xAI's documented inline-image ceiling); larger images throw `bad_request` before the request is sent.
 - **`file-uri`** — only accepted when the URI is a public `http(s)://` URL **and** the declared `mimeType` is jpg/png. A provider-hosted URI from another provider — for example a Gemini Files API URI (`https://generativelanguage.googleapis.com/...`) — is technically `https://` but is not dereferenceable by xAI and is not portable across providers. The adapter rejects it rather than trying to map or proxy it (reject-don't-map).
@@ -131,14 +135,16 @@ xAI caching is automatic — there is no explicit cache-create/cache-store API c
 
 ## Pricing
 
-`XAI_PRICING` is a frozen, versioned snapshot (`xaiPricingVersion: 'xai-2026-07-09'`) — a point-in-time capture, not a live lookup, following the same frozen-snapshot precedent as Gemini pricing (ADR-005). Rates are in µUSD per million tokens:
+`XAI_PRICING` is a frozen, versioned snapshot (`xaiPricingVersion: 'xai-2026-08-12'`) — a point-in-time capture from `/v1/models`, not a live lookup (ADR-005). Rates are in µUSD per million tokens:
 
 | Model      | Tier                         | Input   | Cached input | Output   |
 | ---------- | ---------------------------- | ------- | ------------ | -------- |
-| `grok-4.5` | standard (≤200k gross input) | $2.00/M | $0.50/M      | $6.00/M  |
-| `grok-4.5` | `gt200k` (>200k gross input) | $4.00/M | $1.00/M      | $12.00/M |
+| `grok-4.5` | standard (≤200k gross input) | $2.00/M | $0.30/M      | $6.00/M  |
+| `grok-4.5` | `gt200k` (>200k gross input) | $4.00/M | $0.60/M      | $12.00/M |
+| `grok-4.6` | standard (≤200k gross input) | $2.00/M | $0.50/M      | $6.00/M  |
+| `grok-4.6` | `gt200k` (>200k gross input) | $4.00/M | $1.00/M      | $12.00/M |
 
-The `gt200k` long-context tier is selected by **gross** `inputTokens` (including cached), not billable input — strictly greater than 200,000 tokens, mirroring core's `selectRates` convention. `grok-4.5` has no service-tier concept; a defined `tier` argument to `xaiPricingSource().price()` always resolves to unpriced (`microUsd: null`) rather than guessing a multiplier.
+The `gt200k` long-context tier is selected by **gross** `inputTokens` (including cached), not billable input — strictly greater than 200,000 tokens, mirroring core's `selectRates` convention. The adapter now surfaces the echoed Responses `service_tier` (`'default'` or `'priority'`), so `price()` receives that served value instead of `undefined`. Custom xAI `PricingSource` implementations must price `'default'` at the standard list. Built-in `xaiPricingSource().price()` prices `grok-4.6` + `tier: 'priority'` at 2× every token type after the cache discount: uncached standard-list 2× is confirmed by fixture `12-grok-4-6-xhigh-priority.json` `cost_in_usd_ticks`; cached and `gt200k` legs follow the official 2×-after-cache-discount rule. Any other defined tier (including `priority` on `grok-4.5`) is unpriced (`microUsd: null`). Standard list rates are pinned to `packages/xai/src/__fixtures__/14-v1-models-pricing.json` (live `GET /v1/models` 2026-08-12).
 
 ## EU unavailability
 
@@ -146,7 +152,7 @@ xAI has no EU region at launch — its documented regions are `us-east-1` and `u
 
 ## Aliases are not registered
 
-xAI's own `/v1/models` listing surfaces `grok-4.5-latest` and `grok-build-latest` as aliases of `grok-4.5`. Neither is registered as a separate `ModelDescriptor` or `XAI_PRICING` key. Callers must use the canonical id `grok-4.5` verbatim — passing an alias resolves to "model not found" in the registry, not to `grok-4.5`'s config or pricing (reject-don't-map).
+xAI's own `/v1/models` listing surfaces `grok-4.5-latest` and `grok-build-latest` as aliases of `grok-4.5`. `grok-4.6` has no aliases as of 2026-08-12. Aliases are not registered as `ModelDescriptor`s or `XAI_PRICING` keys. Callers must use the canonical id verbatim — passing an alias resolves to "model not found" (reject-don't-map).
 
 ## Explicitly deferred (not built in v1)
 
@@ -159,10 +165,11 @@ xAI's own `/v1/models` listing surfaces `grok-4.5-latest` and `grok-build-latest
 ## What it maps
 
 - `providerOptions.xai.promptCacheKey` → `prompt_cache_key`
-- `reasoning.effort` → `reasoning.effort` (`'low' | 'high'` only)
+- `reasoning.effort` → `reasoning.effort` (per-model admitted set)
+- `serviceTier: 'priority'` → `service_tier: 'priority'` (`grok-4.6` only)
 - `output.jsonSchema` → `text.format: { type: 'json_schema', name, schema, strict: true }`
 - Usage: `usage.input_tokens` → `inputTokens`, `usage.output_tokens` → `outputTokens` (both already GROSS on xAI, unlike Gemini's sub-field summation); numeric extras (`num_sources_used`, `cost_in_usd_ticks`, etc.) surface into `usage.details` under their raw names, and the full raw payload is always in `usage.raw`
-- Errors: xAI's Responses API returns **HTTP 400 (not 401) for an invalid API key**. `classifyXaiError` special-cases the exact structured error-body signature (`code: 'invalid-argument'` with message prefix `"Incorrect API key provided"`, taken verbatim from a recorded live fixture) and reclassifies it as `invalid_auth`. It only inspects the STRUCTURED parsed error body — never free-form `Error.message` text — so a 400 that merely _mentions_ an API key (e.g. a schema-validation error echoing user content) stays `bad_request`. Any other 400, `429`→`rate_limited`, `5xx`→`server`, and timeouts fall through to `@gullabs/core`'s generic `classifyError`.
+- Errors: HTTP status is a hint. `classifyXaiError` inspects the STRUCTURED parsed body only — never free-form `Error.message`. Two recorded overlays: HTTP **400** whose body starts with `"Incorrect API key provided"` (prefix only; the SDK may drop `code`) → `invalid_auth`; HTTP **403** whose body starts with `"Content violates usage guidelines"` (e.g. `SAFETY_CHECK_TYPE_*`) → `content_filter`. A bare 403 without that body stays `invalid_auth`. Any other 400, `429`→`rate_limited`, `5xx`→`server`, and timeouts fall through to `@gullabs/core`'s generic `classifyError`.
 
 ## Learn more
 

package/dist/index.cjs

@@ -173,6 +173,11 @@ function isXaiAuthFailureBody(rawErr) {
   const text = extractXaiErrorBodyText(rawErr);
   return text !== void 0 && text.startsWith(XAI_AUTH_ERROR_MESSAGE_PREFIX);
 }
+var XAI_SAFETY_CHECK_MESSAGE_PREFIX = "Content violates usage guidelines";
+function isXaiSafetyCheckBody(rawErr) {
+  const text = extractXaiErrorBodyText(rawErr);
+  return text !== void 0 && text.startsWith(XAI_SAFETY_CHECK_MESSAGE_PREFIX);
+}
 var XAI_TRANSPORT_ERROR_PATTERN = /connection error|econnreset|econnrefused|etimedout|eai_again|epipe|socket hang up|fetch failed/i;
 function matchesXaiTransportSignature(err) {
   if (!(err instanceof Error)) return false;
@@ -211,6 +216,16 @@ function classifyXaiError(rawErr) {
       cause: base.cause ?? rawErr
     });
   }
+  if (base.httpStatus === 403 && isXaiSafetyCheckBody(rawErr)) {
+    const bodyText = extractXaiErrorBodyText(rawErr);
+    return new core.LlmError(bodyText ?? base.message, {
+      kind: "content_filter",
+      retryable: false,
+      httpStatus: base.httpStatus,
+      provider: "xai",
+      cause: base.cause ?? rawErr
+    });
+  }
   if (base.kind === "unknown" && isXaiTransportError(rawErr)) {
     return new core.LlmError(base.message, {
       kind: "server",
@@ -262,10 +277,19 @@ function xaiAdapter(opts) {
       if (genConfig.maxOutputTokens !== void 0) {
         params.max_output_tokens = genConfig.maxOutputTokens;
       }
+      const admittedTiers = req.modelDescriptor?.capabilities?.serviceTiers;
       if (genConfig.serviceTier !== void 0) {
-        throw badXaiRequest(
-          `serviceTier is not supported for xai models (got "${genConfig.serviceTier}").`
-        );
+        if (admittedTiers === void 0 || !admittedTiers.includes(genConfig.serviceTier)) {
+          throw badXaiRequest(
+            `serviceTier is not supported for xai model "${model}" (got "${genConfig.serviceTier}").`
+          );
+        }
+        if (genConfig.serviceTier !== "priority") {
+          throw badXaiRequest(
+            `serviceTier "${genConfig.serviceTier}" is not supported for xai model "${model}" (only "priority" is admitted).`
+          );
+        }
+        params.service_tier = "priority";
       }
       const reasoning = genConfig.reasoning;
       if (reasoning !== void 0) {
@@ -276,13 +300,13 @@ function xaiAdapter(opts) {
         }
         if (reasoning.effort !== void 0) {
           const effort = reasoning.effort;
-          if (effort !== "low" && effort !== "high") {
+          if (effort === "none") {
             throw badXaiRequest(
-              `reasoning.effort "${effort}" is not supported for xai model "${model}" (only "low" and "high" are admitted).`
+              `reasoning.effort "none" is not supported for xai model "${model}".`
             );
           }
           const admitted = req.modelDescriptor?.capabilities?.admittedReasoningEfforts;
-          if (admitted !== void 0 && !admitted.includes(effort)) {
+          if (admitted === void 0 || !admitted.includes(effort)) {
             throw badXaiRequest(
               `reasoning.effort "${effort}" is not supported for xai model "${model}".`
             );
@@ -360,6 +384,7 @@ function xaiAdapter(opts) {
       if (isPlainRecord(response.metadata)) {
         providerMeta["metadata"] = response.metadata;
       }
+      const servedServiceTier = typeof response.service_tier === "string" && response.service_tier.length > 0 ? response.service_tier : void 0;
       const result = {
         model: response.model,
         usage,
@@ -369,6 +394,7 @@ function xaiAdapter(opts) {
         ...text.length > 0 ? { text } : {},
         ...reasoningText !== void 0 ? { reasoningText } : {},
         ...rawStructured !== void 0 ? { rawStructured } : {},
+        ...servedServiceTier !== void 0 ? { servedServiceTier } : {},
         ...Object.keys(providerMeta).length > 0 ? { providerMetadata: providerMeta } : {}
       };
       return result;
@@ -875,6 +901,55 @@ var Grok45ConfigSchema = zod.z.strictObject({
   description: "Strict Responses API config for model grok-4.5. Level reasoning (low/high only), tunable sampling, no service tiers, structured output, vision, priced.",
   examples: [{ reasoning: { effort: "high" } }]
 });
+var Grok46ConfigSchema = zod.z.strictObject({
+  temperature: zod.z.number().optional().meta({
+    title: "Temperature",
+    description: "Sampling temperature forwarded verbatim to grok-4.6."
+  }),
+  topP: zod.z.number().optional().meta({
+    title: "Top P",
+    description: "Nucleus sampling parameter forwarded verbatim to grok-4.6."
+  }),
+  maxOutputTokens: zod.z.number().int().positive().optional().meta({
+    title: "Max Output Tokens",
+    description: "Maximum output token cap for grok-4.6. No artificial ceiling \u2014 xAI accepts arbitrarily large values; truncation surfaces as finishReason:'length', not an error."
+  }),
+  reasoning: zod.z.strictObject({
+    effort: zod.z.enum(["low", "medium", "high", "xhigh"]).meta({
+      title: "Reasoning Effort",
+      description: 'Reasoning effort for grok-4.6. Live-verified 2026-08-12: "low", "medium", "high", and "xhigh" are accepted; "none" is rejected. Vendor default when omitted is "high".'
+    })
+  }).optional().meta({
+    title: "Reasoning",
+    description: "grok-4.6 effort-level reasoning configuration. No budgetTokens field \u2014 xAI uses level-style reasoning, not token budgets."
+  }),
+  serviceTier: zod.z.literal("priority").optional().meta({
+    title: "Service Tier",
+    description: 'xAI priority processing for grok-4.6 (Responses `service_tier: "priority"`). Echo live-verified 2026-08-12. Bills at 2\xD7 after the cache discount (uncached standard-list 2\xD7 confirmed by live ticks; cached/long-context legs follow the official 2\xD7 rule). Omitted requests stay on xAI default. "flex"/"standard"/"batch" are rejected.'
+  }),
+  timeoutMs: zod.z.number().int().positive().optional().meta({
+    title: "Timeout",
+    description: "Logical request timeout in milliseconds."
+  }),
+  providerOptions: zod.z.strictObject({
+    xai: zod.z.strictObject({
+      promptCacheKey: zod.z.string().min(1).optional().meta({
+        title: "Prompt Cache Key",
+        description: "xAI conversation-routing cache key \u2014 maps to Responses API `prompt_cache_key`."
+      })
+    }).optional().meta({
+      title: "xAI Provider Options",
+      description: "Allowlisted xAI provider options for grok-4.6."
+    })
+  }).optional().meta({
+    title: "Provider Options",
+    description: "Provider-specific options accepted for grok-4.6."
+  })
+}).meta({
+  title: "Grok46Config",
+  description: "Strict Responses API config for model grok-4.6. Level reasoning (low/medium/high/xhigh), optional priority service tier, tunable sampling, structured output, vision, priced.",
+  examples: [{ reasoning: { effort: "high" } }]
+});
 
 // src/models.ts
 var grok45ModelDescriptor = {
@@ -892,20 +967,55 @@ var grok45ModelDescriptor = {
     sampling: "tunable",
     caching: { explicit: false, minTokens: 0 },
     grounding: false
-    // No serviceTiers key — xai has no service-tier concept.
+    // No serviceTiers key — grok-4.5 has no admitted service-tier vocabulary.
   },
   configSchema: Grok45ConfigSchema,
   configJsonSchema: core.toConfigJsonSchema(Grok45ConfigSchema),
   validateConfig: core.zodToStandardSchema(Grok45ConfigSchema)
 };
-var xaiModelDescriptors = [grok45ModelDescriptor];
+var grok46ModelDescriptor = {
+  model: "grok-4.6",
+  provider: "xai",
+  pricingFamily: "grok-4.6",
+  capabilities: {
+    reasoning: true,
+    reasoningApi: "level",
+    admittedReasoningEfforts: ["low", "medium", "high", "xhigh"],
+    structuredOutput: true,
+    nativeStructuredOutput: true,
+    vision: true,
+    audioInput: false,
+    sampling: "tunable",
+    caching: { explicit: false, minTokens: 0 },
+    grounding: false,
+    serviceTiers: ["priority"]
+  },
+  configSchema: Grok46ConfigSchema,
+  configJsonSchema: core.toConfigJsonSchema(Grok46ConfigSchema),
+  validateConfig: core.zodToStandardSchema(Grok46ConfigSchema)
+};
+var xaiModelDescriptors = [
+  grok45ModelDescriptor,
+  grok46ModelDescriptor
+];
 var xaiRegistry = core.createModelRegistry(xaiModelDescriptors);
 
 // src/pricing.ts
-var xaiPricingVersion = "xai-2026-07-09";
+var xaiPricingVersion = "xai-2026-08-12";
 var XAI_PRICING = Object.freeze({
-  // ── grok-4.5 ──  $2.00/$6.00 (≤200k), $4.00/$12.00 (>200k); cached $0.50/$1.00
+  // ── grok-4.5 ──  $2.00/$6.00 (≤200k), $4.00/$12.00 (>200k); cached $0.30/$0.60
   "grok-4.5": {
+    inputPerM: 2e6,
+    cachedPerM: 3e5,
+    outputPerM: 6e6,
+    gt200k: {
+      inputPerM: 4e6,
+      cachedPerM: 6e5,
+      outputPerM: 12e6
+    }
+  },
+  // ── grok-4.6 ──  $2.00/$6.00 (≤200k), $4.00/$12.00 (>200k); cached $0.50/$1.00
+  "grok-4.6": {
     inputPerM: 2e6,
     cachedPerM: 5e5,
     outputPerM: 6e6,
@@ -913,7 +1023,9 @@ var XAI_PRICING = Object.freeze({
       inputPerM: 4e6,
       cachedPerM: 1e6,
       outputPerM: 12e6
-    }
+    },
+    // Confirmed 2026-08-12 by fixture 12 cost_in_usd_ticks (2× list).
+    priorityFactor: 2
   }
 });
 var LONG_CONTEXT_THRESHOLD = 2e5;
@@ -942,22 +1054,29 @@ function computeXaiCost(model, usage, tier) {
       unpricedReason: `Unknown model "${model}"; no pricing entry found.`
     };
   }
-  if (tier !== void 0) {
-    return {
-      microUsd: null,
-      usd: null,
-      pricingVersion: xaiPricingVersion,
-      confidence: "estimated",
-      details: { input: 0, cached: 0, output: 0 },
-      unpricedReason: `Unknown service tier "${tier}"; xai has no service tiers, refusing to guess a pricing multiplier.`
-    };
+  let factor = 1;
+  if (tier !== void 0 && tier !== "default") {
+    if (tier === "priority" && rates.priorityFactor !== void 0) {
+      factor = rates.priorityFactor;
+    } else {
+      return {
+        microUsd: null,
+        usd: null,
+        pricingVersion: xaiPricingVersion,
+        confidence: "estimated",
+        details: { input: 0, cached: 0, output: 0 },
+        unpricedReason: `Unknown service tier "${tier}"; xai model "${model}" has no such tier, refusing to guess a pricing multiplier.`
+      };
+    }
   }
   const base = selectRates(rates, usage.inputTokens);
   const cached = usage.cachedInputTokens ?? 0;
   const billableInput = Math.max(0, usage.inputTokens - cached);
-  const inputCost = Math.round(billableInput * base.inputPerM / 1e6);
-  const cachedCost = Math.round(cached * base.cachedPerM / 1e6);
-  const outputCost = Math.round(usage.outputTokens * base.outputPerM / 1e6);
+  const inputCost = Math.round(billableInput * base.inputPerM * factor / 1e6);
+  const cachedCost = Math.round(cached * base.cachedPerM * factor / 1e6);
+  const outputCost = Math.round(
+    usage.outputTokens * base.outputPerM * factor / 1e6
+  );
   const microUsd = inputCost + cachedCost + outputCost;
   return {
     microUsd,
@@ -996,6 +1115,7 @@ function xaiProvider(opts) {
 }
 
 exports.Grok45ConfigSchema = Grok45ConfigSchema;
+exports.Grok46ConfigSchema = Grok46ConfigSchema;
 exports.XAI_FILES_DEFAULT_BASE_URL = XAI_FILES_DEFAULT_BASE_URL;
 exports.XAI_FILE_MAX_BYTES = XAI_FILE_MAX_BYTES;
 exports.XAI_FILE_TTL_MAX_SECONDS = XAI_FILE_TTL_MAX_SECONDS;
@@ -1006,6 +1126,7 @@ exports.buildXaiClient = buildXaiClient;
 exports.classifyXaiError = classifyXaiError;
 exports.computeXaiCost = computeXaiCost;
 exports.grok45ModelDescriptor = grok45ModelDescriptor;
+exports.grok46ModelDescriptor = grok46ModelDescriptor;
 exports.requireApiKey = requireApiKey;
 exports.xaiAdapter = xaiAdapter;
 exports.xaiModelDescriptors = xaiModelDescriptors;