@gullabs/xai 0.4.1 → 0.5.1

package/dist/index.js

@@ -171,6 +171,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;
@@ -209,6 +214,16 @@ function classifyXaiError(rawErr) {
       cause: base.cause ?? rawErr
     });
   }
+  if (base.httpStatus === 403 && isXaiSafetyCheckBody(rawErr)) {
+    const bodyText = extractXaiErrorBodyText(rawErr);
+    return new 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 LlmError(base.message, {
       kind: "server",
@@ -260,10 +275,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) {
@@ -274,13 +298,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}".`
             );
@@ -358,6 +382,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,
@@ -367,6 +392,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;
@@ -873,6 +899,55 @@ var Grok45ConfigSchema = 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 = z.strictObject({
+  temperature: z.number().optional().meta({
+    title: "Temperature",
+    description: "Sampling temperature forwarded verbatim to grok-4.6."
+  }),
+  topP: z.number().optional().meta({
+    title: "Top P",
+    description: "Nucleus sampling parameter forwarded verbatim to grok-4.6."
+  }),
+  maxOutputTokens: 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: z.strictObject({
+    effort: 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: 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: z.number().int().positive().optional().meta({
+    title: "Timeout",
+    description: "Logical request timeout in milliseconds."
+  }),
+  providerOptions: z.strictObject({
+    xai: z.strictObject({
+      promptCacheKey: 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 = {
@@ -890,20 +965,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: toConfigJsonSchema(Grok45ConfigSchema),
   validateConfig: 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: toConfigJsonSchema(Grok46ConfigSchema),
+  validateConfig: zodToStandardSchema(Grok46ConfigSchema)
+};
+var xaiModelDescriptors = [
+  grok45ModelDescriptor,
+  grok46ModelDescriptor
+];
 var xaiRegistry = 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,
@@ -911,7 +1021,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;
@@ -940,22 +1052,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,
@@ -993,6 +1112,6 @@ function xaiProvider(opts) {
   };
 }
 
-export { Grok45ConfigSchema, XAI_FILES_DEFAULT_BASE_URL, XAI_FILE_MAX_BYTES, XAI_FILE_TTL_MAX_SECONDS, XAI_FILE_TTL_MIN_SECONDS, XAI_PRICING, XaiFileStore, buildXaiClient, classifyXaiError, computeXaiCost, grok45ModelDescriptor, requireApiKey, xaiAdapter, xaiModelDescriptors, xaiPricingSource, xaiPricingVersion, xaiProvider, xaiRegistry };
+export { Grok45ConfigSchema, Grok46ConfigSchema, XAI_FILES_DEFAULT_BASE_URL, XAI_FILE_MAX_BYTES, XAI_FILE_TTL_MAX_SECONDS, XAI_FILE_TTL_MIN_SECONDS, XAI_PRICING, XaiFileStore, buildXaiClient, classifyXaiError, computeXaiCost, grok45ModelDescriptor, grok46ModelDescriptor, requireApiKey, xaiAdapter, xaiModelDescriptors, xaiPricingSource, xaiPricingVersion, xaiProvider, xaiRegistry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map