@gajae-code/ai 0.16.3 → 0.16.6

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [0.16.6] - 2026-09-07
+
+## [0.16.5] - 2026-09-07
+
+- Documented `GJC_OPENAI_CODE_WEBSOCKET_V2` as a switch that enables a websocket v2 path. No code read it under that name, under the legacy `PI_CODEX_WEBSOCKET_V2`, or under the `PI_OPENAI_CODE_WEBSOCKET_V2` the historical entry records; the v2 beta header has been unconditional for websocket transport. The documentation row is removed rather than reintroducing a knob, and the test that claimed to gate on it no longer writes an environment variable nothing reads.
+- Maintenance reasoning now fails closed for Anthropic models routed through an unverified custom endpoint and for raw reasoning-enabled models without thinking metadata. This prevents unsupported thinking controls and avoids a synchronous missing-metadata crash before provider wire transformation.
+
+## [0.16.4] - 2026-09-05
+
+### Added
+
+- Bundled `openai-codex/gpt-6-astra` from the authenticated Codex catalog so eligible ChatGPT accounts can select Astra before a live discovery refresh. The reviewed snapshot records Codex's 272K prompt budget, 128K output cap, text-and-image input, websocket preference, low-through-max reasoning efforts, freeform `apply_patch`, and published tiered OpenAI pricing.
+
+### Fixed
+
+- OpenAI Codex HTTP failures with an empty response body and empty status text now include the HTTP status in the surfaced message instead of the opaque `Request failed`, while structured provider errors retain their existing messages and classification.
+- Direct xAI reasoning effort now requires the exact production HTTPS `api.x.ai` origin: HTTP, userinfo, query/fragment components, and explicit non-default ports fail closed. Bedrock Claude cache-pricing metadata now shares the request prompt-caching generation policy, retaining only Claude 3.5 Haiku, Claude 3.7 Sonnet, and Claude 4+ support.
+
+- OpenCode Go requests across chat completions, Responses, and Anthropic-compatible models now send the provider-required `x-opencode-session` header at their exact canonical Go endpoints using the coding-agent's existing opaque provider session id. The provider-owned identity is typed separately from generic cache affinity, so auth-gateway prompt-derived cache keys cannot become the header. The value remains stable across turns and every retry layer in one conversation, differs with the conversation lifecycle, cannot be injected or replaced by caller/model request headers or transforms on unauthorized routes, and is never added to OpenCode Zen or unrelated compatible endpoints (#5295).
+- Bedrock prompt caching is now gated on the Claude generation parsed from the model id instead of version-literal fragments (`-4-`/`-4.`, `claude-haiku`, and two 3.x literals). A future generation's Bedrock id (`us.anthropic.claude-opus-5-…`, or a new model kind) matched none of the literals, so cache points were silently omitted and every request re-paid full input pricing. Behavior for the documented support set — 3.5 Haiku, 3.7 Sonnet, and 4.x naming including `us.`/`eu.`/`au.`/`jp.`/`global.` inference profiles — is unchanged, per AWS's prompt-caching support matrix. A bundled-catalog tripwire now fails when a regenerated catalog introduces a Claude id shape the parser cannot read, so shape drift is loud instead of silently disabling caching.
+
+- Direct-xAI `reasoning_effort` support is now derived from a strictly parsed canonical grok generation (4.5+) instead of the exact ids `grok-4.5`/`grok-4.6` in the compat layer and the coding-agent thinking-choice gate; a future grok release failed the id list, so `supportsReasoningEffort` stayed `false` and the user's thinking level was silently dropped from requests with no error. The generated-policy `reasoning` pin stays scoped to the two rows whose upstream metadata shipped stale — a per-row data correction, not a family rule — so catalog `reasoning: false` flags (including the bundled grok `-non-reasoning` variants) remain authoritative for everything else. Direct capability requires the official xAI origin; private and proxy OpenAI-compatible origins fail closed unless explicitly configured, while reseller routes such as OpenRouter keep their existing audited transport behavior.
+
+- Cursor payload hooks now receive protobuf requests as JSON-safe values, await asynchronous inspection or replacement, and validate replacement payloads before transport. Checkpoint state containing 64-bit protobuf fields no longer makes hook-side `JSON.stringify` fail on JavaScript `bigint` values.
+- The OpenAI Codex GPT-5.6 Sol entitlement preflight no longer rejects Business, Enterprise, or Team ChatGPT OAuth accounts. Eligibility was decided by `plan_type.includes("pro")`, so a `business`/`enterprise`/`team` plan (which is entitled to Sol on the backend) failed credential selection before dispatch with a spurious "cannot use model" error, even though a direct request to the ChatGPT Codex backend succeeds for those plans. A shared classifier now recognizes exact Pro/Business/Enterprise/Team tier names and known Free/Plus denials. Missing or unfamiliar plan names remain unknown and reach the provider instead of gaining entitlement through a substring match or being rejected by a client-side guess.
+
 ## [0.16.3] - 2026-09-04
 
 ## [0.16.2] - 2026-09-04

package/dist/types/auth-gateway/server.d.ts

@@ -18,8 +18,8 @@
  *   POST /v1/responses                     → OpenAI Responses in/out
  */
 import type { AuthStorage } from "../auth-storage";
-import type { Api, AssistantMessageEventStream, Model, Provider } from "../types";
-import type { AuthGatewayServerHandle, AuthGatewayServerOptions } from "./types";
+import type { Api, AssistantMessageEventStream, Model, Provider, SimpleStreamOptions } from "../types";
+import type { AuthGatewayServerHandle, AuthGatewayServerOptions, AuthGatewayParsedRequest as ParsedFormatRequest } from "./types";
 export type ModelResolver = (modelId: string) => Model<Api> | undefined;
 export interface AuthGatewayBootOptions extends AuthGatewayServerOptions {
     /** Source of credentials. Caller wires this to a broker-backed AuthStorage. */
@@ -66,5 +66,7 @@ export declare function isAuthGatewayModelBrokerConsumable(model: Pick<Model<Api
  */
 export declare function createAuthGatewayModelCatalog(provider: Provider, models: Iterable<Model<Api>>): AuthGatewayModelCatalog;
 export declare function releaseGatewayCredentialLeaseOnAdmission(events: Pick<AssistantMessageEventStream, "result">, release: () => void, signal?: AbortSignal): void;
+/** Test seam for verifying translated gateway requests never acquire agent-owned provider identity. */
+export declare function buildAuthGatewayStreamOptionsForTest(parsed: ParsedFormatRequest, api: Api): SimpleStreamOptions;
 export declare function startAuthGateway(opts: AuthGatewayBootOptions): AuthGatewayServerHandle;
 export declare function isSafeProviderScope(provider: unknown): provider is string;

package/dist/types/bedrock-claude-cache-policy.d.ts

@@ -0,0 +1,21 @@
+export type BedrockClaudeGeneration = {
+    generation: {
+        major: number;
+        minor: number;
+    };
+    kind: string;
+};
+/**
+ * Bedrock Claude ids come in two shapes:
+ *  - family-first (3.x era): anthropic.claude-3-5-haiku-20241022-v1:0
+ *  - kind-first (4+ era):    anthropic.claude-opus-4-20250514-v1:0,
+ *                            anthropic.claude-haiku-4-5-20251001-v1:0
+ * Cross-region profiles (us./eu./au./jp./apac./global. prefixes) and inference-profile
+ * ARNs keep the canonical model id as their final path segment.
+ */
+export declare function parseBedrockClaudeGeneration(id: string): BedrockClaudeGeneration | undefined;
+/**
+ * Returns undefined for non-Claude ids, false for malformed or unsupported
+ * Claude ids, and true only for AWS's documented cache-capable generations.
+ */
+export declare function supportsBedrockClaudePromptCaching(id: string): boolean | undefined;

package/dist/types/openai-completions-compat.d.ts

@@ -1,10 +1,32 @@
 import type { Model, OpenAICompat } from "./types";
 type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+export type GrokGeneration = {
+    major: number;
+    minor: number;
+};
 /** Returns whether the request endpoint is an audited reasoning-control transport. */
 export declare function isAuditedOpenAIReasoningTransport(model: {
     provider: string;
     baseUrl?: string;
 }, resolvedBaseUrl?: string): boolean;
+/**
+ * xAI's first-party API accepts `reasoning_effort` on Grok 4.5 and later.
+ * Provider labels are user-configurable, so both the provider and the official
+ * API origin must match. Unknown variants fail closed instead of inheriting a
+ * capability from a loose model-id prefix.
+ */
+export declare function parseDirectXaiReasoningEffortGeneration(model: {
+    provider: string;
+    id: string;
+    api?: string;
+    baseUrl?: string;
+}, resolvedBaseUrl?: string): GrokGeneration | undefined;
+export declare function isDirectXaiReasoningEffortModel(model: {
+    provider: string;
+    id: string;
+    api?: string;
+    baseUrl?: string;
+}, resolvedBaseUrl?: string): boolean;
 export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "reservedToolNames">> & {
     openRouterRouting?: OpenAICompat["openRouterRouting"];
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];

package/dist/types/providers/amazon-bedrock.d.ts

@@ -6,8 +6,9 @@
  * No `@aws-sdk/*`, no `@smithy/*`, no `proxy-agent`. Proxies are honored via
  * Bun's native `HTTPS_PROXY` support.
  */
+import { parseBedrockClaudeGeneration } from "../bedrock-claude-cache-policy";
 import type { Effort } from "../model-thinking";
-import type { StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
+import type { Model, StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 export interface BedrockOptions extends StreamOptions {
     region?: string;
@@ -51,10 +52,24 @@ interface WireToolConfig {
     toolChoice?: WireToolChoice;
 }
 export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;
+/**
+ * Check if the model supports prompt caching.
+ * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, and every later Claude
+ * generation:
+ * https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
+ *
+ * For base models and system-defined inference profiles the model ID / ARN
+ * contains the model name, so we can decide locally.
+ *
+ * For application inference profiles (whose ARNs don't contain the model name),
+ * set AWS_BEDROCK_FORCE_CACHE=1 to enable cache points.  Amazon Nova models
+ * have automatic caching and don't need explicit cache points.
+ */
+export declare function supportsPromptCaching(model: Model<"bedrock-converse-stream">): boolean;
+export { parseBedrockClaudeGeneration };
 export declare function stripBedrockForcedToolChoiceForRetry<T extends {
     toolConfig?: {
         toolChoice?: unknown;
     };
 }>(body: T): T;
 export declare function convertToolConfig(tools: Tool[] | undefined, toolChoice: BedrockOptions["toolChoice"]): WireToolConfig | undefined;
-export {};

package/dist/types/providers/anthropic.d.ts

@@ -203,6 +203,7 @@ export type AnthropicClientOptionsArgs = {
     maxRetryDelayMs?: number;
     streamFirstEventTimeoutMs?: number;
     streamIdleTimeoutMs?: number;
+    providerSessionId?: string;
 };
 export type AnthropicClientOptionsResult = {
     isOAuthToken: boolean;

package/dist/types/providers/openai-completions-compat.d.ts

@@ -3,4 +3,4 @@
  * the core-safe module so model metadata can use it without loading provider
  * implementations during startup.
  */
-export { detectOpenAICompat, type ResolvedOpenAICompat, resolveOpenAICompat } from "../openai-completions-compat";
+export { detectOpenAICompat, type GrokGeneration, isDirectXaiReasoningEffortModel, parseDirectXaiReasoningEffortGeneration, type ResolvedOpenAICompat, resolveOpenAICompat, } from "../openai-completions-compat";

package/dist/types/providers/opencode-go-session.d.ts

@@ -0,0 +1,5 @@
+import type { FetchImpl, Model } from "../types";
+export type OpenCodeGoApiFamily = "openai" | "anthropic";
+export declare function resolveOpenCodeGoSessionId(model: Pick<Model, "provider">, baseUrl: string | undefined, providerSessionId: string | undefined, apiFamily: OpenCodeGoApiFamily): string | undefined;
+export declare function applyOpenCodeGoSessionHeader(headers: Record<string, string>, sessionId: string | undefined): Record<string, string>;
+export declare function wrapFetchForOpenCodeGoSession(baseFetch: FetchImpl, sessionId: string | undefined): FetchImpl;

package/dist/types/types.d.ts

@@ -239,6 +239,13 @@ export interface StreamOptions {
      * session-aware features. Ignored by providers that don't support it.
      */
     sessionId?: string;
+    /**
+     * Opaque conversation identity owned by the calling agent/session lifecycle.
+     * Unlike `sessionId`, this MUST NOT be synthesized from prompts, credentials,
+     * paths, cache keys, or other request content. Providers with a dedicated
+     * conversation header may use this only when their endpoint policy permits it.
+     */
+    providerSessionId?: string;
     /**
      * Provider-scoped mutable state store for this agent session.
      * Providers can use this to persist transport/session state between turns.
@@ -249,12 +256,12 @@ export interface StreamOptions {
      * Return undefined to keep the payload unchanged.
      * The `scope` parameter carries the per-attempt identity for execution attribution.
      */
-    onPayload?: (payload: unknown, model?: Model<Api>, scope?: AttemptScopeRef) => unknown | undefined | Promise<unknown | undefined>;
+    onPayload?: (payload: unknown, model?: Model<Api>, scope?: AttemptScopeRef, signal?: AbortSignal) => unknown | undefined | Promise<unknown | undefined>;
     /**
      * Optional callback for provider response metadata after headers are received.
      * The `scope` parameter carries the per-attempt identity for execution attribution.
      */
-    onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>, scope?: AttemptScopeRef) => void | Promise<void>;
+    onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>, scope?: AttemptScopeRef, signal?: AbortSignal) => void | Promise<void>;
     /**
      * Internal dispatch-admission hook. Providers invoke this immediately before
      * submitting an outbound request; stream forwarding retains a first-response

package/dist/types/utils/codex-entitlement.d.ts

@@ -6,6 +6,16 @@
  * authority for the account tier; this module only names the model policy and
  * keeps the provider's deterministic rejection wording in one place.
  */
+export type OpenAICodexProEntitlement = "entitled" | "denied" | "unknown";
+/**
+ * Classify a ChatGPT `plan_type` for strict Pro-tier Codex models.
+ *
+ * The usage endpoint remains authoritative: only exact, documented tier names
+ * are classified. Known Free/Plus tiers can be rejected locally, while missing
+ * or unfamiliar values stay unknown and reach the provider instead of being
+ * guessed from a substring.
+ */
+export declare function classifyOpenAICodexProEntitlement(planType: string | undefined): OpenAICodexProEntitlement;
 export declare function requiresOpenAICodexProModel(provider: string, modelId: string | undefined): boolean;
 export declare function requiresStrictOpenAICodexProModel(provider: string, modelId: string | undefined): boolean;
 export declare function isOpenAICodexChatGPTEntitlementError(message: string | undefined, code?: string): boolean;

package/dist/types/utils/provider-response.d.ts

@@ -3,4 +3,5 @@ export declare function normalizeProviderResponse(response: Response, requestId?
 export declare function notifyProviderResponse(options: {
     onResponse?: StreamOptions["onResponse"];
     attemptScope?: AttemptScopeRef;
+    signal?: AbortSignal;
 } | undefined, response: Response, model?: Model<Api>, requestId?: string | null, metadata?: Record<string, unknown>): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.16.3",
+	"version": "0.16.6",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -40,8 +40,8 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/natives": "0.16.3",
-		"@gajae-code/utils": "0.16.3",
+		"@gajae-code/natives": "0.16.6",
+		"@gajae-code/utils": "0.16.6",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/auth-gateway/server.ts

@@ -469,6 +469,11 @@ function buildStreamOptions(parsed: ParsedFormatRequest, api: Api, signal: Abort
 	return opts;
 }
 
+/** Test seam for verifying translated gateway requests never acquire agent-owned provider identity. */
+export function buildAuthGatewayStreamOptionsForTest(parsed: ParsedFormatRequest, api: Api): SimpleStreamOptions {
+	return buildStreamOptions(parsed, api, new AbortController().signal);
+}
+
 /**
  * Classify an upstream / gateway-internal error into a status code and a
  * provider-style error type tag. Used by `handleFormatEndpoint` /

package/src/auth-storage.ts

@@ -27,6 +27,7 @@ import type {
 } from "./usage";
 
 import {
+	classifyOpenAICodexProEntitlement,
 	formatOpenAICodexChatGPTEntitlementError,
 	requiresOpenAICodexProModel,
 	requiresStrictOpenAICodexProModel,
@@ -1153,13 +1154,18 @@ function getUsagePlanType(report: UsageReport | null): string | undefined {
 }
 
 function getOpenAICodexPlanPriority(report: UsageReport | null): number {
-	const planType = getUsagePlanType(report);
-	if (!planType) return 1;
-	return planType.includes("pro") ? 0 : 2;
+	const entitlement = classifyOpenAICodexProEntitlement(getUsagePlanType(report));
+	if (entitlement === "entitled") return 0;
+	if (entitlement === "denied") return 2;
+	return 1;
 }
 
 function hasOpenAICodexProPlan(report: UsageReport | null): boolean {
-	return getUsagePlanType(report)?.includes("pro") === true;
+	return classifyOpenAICodexProEntitlement(getUsagePlanType(report)) === "entitled";
+}
+
+function hasKnownOpenAICodexNonProPlan(report: UsageReport | null): boolean {
+	return classifyOpenAICodexProEntitlement(getUsagePlanType(report)) === "denied";
 }
 
 function resolveDefaultRankingStrategy(provider: Provider): CredentialRankingStrategy | undefined {
@@ -1621,6 +1627,7 @@ export class AuthStorage {
 	 */
 	setRuntimeApiKey(provider: string, apiKey: string): void {
 		const storageProvider = resolveOAuthStorageProvider(provider);
+		if (this.#runtimeOverrides.get(storageProvider) === apiKey) return;
 		this.#runtimeOverrides.set(storageProvider, apiKey);
 		this.#bumpGeneration("set-runtime-api-key", storageProvider);
 	}
@@ -1937,6 +1944,8 @@ export class AuthStorage {
 			throw new Error(`Preferred credential selector cannot be combined with a credential selector for ${provider}`);
 		}
 		this.#assertPreferredCredentialSelectorUsable(storageProvider, selector);
+		const existing = this.#runtimePreferredCredentialSelectors.get(storageProvider);
+		if (existing?.kind === selector.kind && existing.value === selector.value) return;
 		this.#runtimePreferredCredentialSelectors.set(storageProvider, selector);
 		this.#bumpGeneration("set-runtime-preferred-credential-selector", provider);
 	}
@@ -4957,15 +4966,15 @@ export class AuthStorage {
 		const enforceProRequirement =
 			requiresProModel && candidates.some(candidate => hasOpenAICodexProPlan(candidate.usage));
 		// Spark retains its historical Plus fallback for grandfathered accounts.
-		// Sol is different: a confirmed non-Pro plan cannot call it, so reject the
+		// Sol is different: confirmed Free/Plus plans cannot call it, so reject the
 		// model before returning an OAuth bearer and letting the turn fail remotely.
+		// Unknown plan names still reach the provider because the usage endpoint is
+		// authoritative and future tiers must not be denied by a client-side guess.
 		const strictProRequirement = requiresStrictOpenAICodexProModel(provider, options?.modelId);
 		if (
 			strictProRequirement &&
 			candidates.length > 0 &&
-			candidates.every(
-				candidate => getUsagePlanType(candidate.usage) !== undefined && !hasOpenAICodexProPlan(candidate.usage),
-			)
+			candidates.every(candidate => hasKnownOpenAICodexNonProPlan(candidate.usage))
 		) {
 			throw new Error(formatOpenAICodexChatGPTEntitlementError(options?.modelId));
 		}

package/src/bedrock-claude-cache-policy.d.ts

@@ -0,0 +1,21 @@
+export type BedrockClaudeGeneration = {
+    generation: {
+        major: number;
+        minor: number;
+    };
+    kind: string;
+};
+/**
+ * Bedrock Claude ids come in two shapes:
+ *  - family-first (3.x era): anthropic.claude-3-5-haiku-20241022-v1:0
+ *  - kind-first (4+ era):    anthropic.claude-opus-4-20250514-v1:0,
+ *                            anthropic.claude-haiku-4-5-20251001-v1:0
+ * Cross-region profiles (us./eu./au./jp./apac./global. prefixes) and inference-profile
+ * ARNs keep the canonical model id as their final path segment.
+ */
+export declare function parseBedrockClaudeGeneration(id: string): BedrockClaudeGeneration | undefined;
+/**
+ * Returns undefined for non-Claude ids, false for malformed or unsupported
+ * Claude ids, and true only for AWS's documented cache-capable generations.
+ */
+export declare function supportsBedrockClaudePromptCaching(id: string): boolean | undefined;

package/src/bedrock-claude-cache-policy.ts

@@ -0,0 +1,68 @@
+export type BedrockClaudeGeneration = {
+	generation: { major: number; minor: number };
+	kind: string;
+};
+
+function extractBedrockModelId(id: string): string | undefined {
+	if (id !== id.toLowerCase()) return undefined;
+	if (id.startsWith("arn:")) {
+		const arn =
+			/^arn:(?:aws|aws-us-gov|aws-cn|aws-iso|aws-iso-b|aws-eusc):bedrock:[a-z0-9-]+:(?:\d{12})?:(?:foundation-model|inference-profile)\/([^/]+)$/.exec(
+				id,
+			);
+		return arn?.[1];
+	}
+	return id.includes("/") ? undefined : id;
+}
+
+/**
+ * Bedrock Claude ids come in two shapes:
+ *  - family-first (3.x era): anthropic.claude-3-5-haiku-20241022-v1:0
+ *  - kind-first (4+ era):    anthropic.claude-opus-4-20250514-v1:0,
+ *                            anthropic.claude-haiku-4-5-20251001-v1:0
+ * Cross-region profiles (us./eu./au./jp./apac./global. prefixes) and inference-profile
+ * ARNs keep the canonical model id as their final path segment.
+ */
+export function parseBedrockClaudeGeneration(id: string): BedrockClaudeGeneration | undefined {
+	const modelId = extractBedrockModelId(id);
+	if (modelId === undefined) return undefined;
+	const prefix = "(?:(?:us|eu|au|jp|apac|global)\\.)?anthropic\\.claude-";
+	const component = "(?:0|[1-9]\\d?)";
+	const suffix = "(?:-(?:[a-z][a-z0-9]*(?::[a-z0-9]+)?|\\d{8}))*";
+	const familyFirst = new RegExp(`^${prefix}([1-9]\\d?)(?:-(${component}))?-([a-z][a-z0-9]*)${suffix}$`).exec(modelId);
+	if (familyFirst) {
+		return {
+			generation: {
+				major: Number(familyFirst[1]),
+				minor: familyFirst[2] === undefined ? 0 : Number(familyFirst[2]),
+			},
+			kind: familyFirst[3]!,
+		};
+	}
+	const kindFirst = new RegExp(`^${prefix}([a-z][a-z0-9]*)-([1-9]\\d?)(?:[.-](${component}))?${suffix}$`).exec(
+		modelId,
+	);
+	if (kindFirst) {
+		return {
+			generation: { major: Number(kindFirst[2]), minor: kindFirst[3] === undefined ? 0 : Number(kindFirst[3]) },
+			kind: kindFirst[1]!,
+		};
+	}
+	return undefined;
+}
+
+/**
+ * Returns undefined for non-Claude ids, false for malformed or unsupported
+ * Claude ids, and true only for AWS's documented cache-capable generations.
+ */
+export function supportsBedrockClaudePromptCaching(id: string): boolean | undefined {
+	if (!id.toLowerCase().includes("anthropic.claude")) return undefined;
+	const claude = parseBedrockClaudeGeneration(id);
+	if (claude === undefined) return false;
+	if (claude.generation.major >= 4) return true;
+	if (claude.generation.major !== 3) return false;
+	return (
+		(claude.generation.minor === 5 && claude.kind === "haiku") ||
+		(claude.generation.minor === 7 && claude.kind === "sonnet")
+	);
+}

package/src/model-pricing.ts

@@ -15,8 +15,19 @@ const GPT_5_6_SOL_PRICING: TieredPricing = {
 	},
 };
 
+// GPT-6 Astra: $10/$50 standard, cache read $1, cache write $12.50; inputs past
+// 272K apply 2x to input/cache and 1.5x to output.
+const GPT_6_ASTRA_PRICING: TieredPricing = {
+	cost: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
+	longContextPricing: {
+		threshold: LONG_CONTEXT_THRESHOLD,
+		cost: { input: 20, output: 75, cacheRead: 2, cacheWrite: 25 },
+	},
+};
+
 // OpenAI Standard pricing: https://developers.openai.com/api/docs/pricing
 const OPENAI_GPT_5_6_PRICING: ReadonlyMap<string, TieredPricing> = new Map([
+	["gpt-6-astra", GPT_6_ASTRA_PRICING],
 	["gpt-5.6", GPT_5_6_SOL_PRICING],
 	["gpt-5.6-sol", GPT_5_6_SOL_PRICING],
 	[

package/src/model-thinking.ts

@@ -1,3 +1,4 @@
+import { supportsBedrockClaudePromptCaching } from "./bedrock-claude-cache-policy";
 import {
 	CODEX_GENERIC_CONTEXT_WINDOW,
 	CODEX_GPT_5_6_CONTEXT_CAP,
@@ -5,7 +6,11 @@ import {
 	isCodexProductTransport,
 } from "./context-cap-policy";
 import { applyOpenAIModelPricing } from "./model-pricing";
-import { isAuditedOpenAIReasoningTransport, resolveOpenAICompat } from "./openai-completions-compat";
+import {
+	isAuditedOpenAIReasoningTransport,
+	parseDirectXaiReasoningEffortGeneration,
+	resolveOpenAICompat,
+} from "./openai-completions-compat";
 import type { Api, Model as ApiModel, ThinkingConfig } from "./types";
 import { isClaudeForcedToolChoiceIncapableModelId } from "./utils/tool-choice-capability";
 
@@ -63,6 +68,12 @@ const KIMI_K3_EFFORTS: readonly Effort[] = [Effort.Low, Effort.High, Effort.Max]
 const DEEPSEEK_V4_FLASH_0731_EFFORTS: readonly Effort[] = [Effort.Low, Effort.High, Effort.Max];
 const GROK_4_5_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Effort.High];
 const GROK_4_6_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Effort.High, Effort.XHigh];
+const GROK_4_20_EFFORTS: readonly Effort[] = [Effort.Minimal, Effort.Low, Effort.Medium, Effort.High];
+const GROK_4_20_REASONING_MODEL_IDS = new Set([
+	"grok-4.20-0309-reasoning",
+	"grok-4.20-beta-latest-reasoning",
+	"grok-4.20-multi-agent-beta-latest",
+]);
 
 const GPT_5_1_CODEX_MINI_EFFORTS: readonly Effort[] = [Effort.Medium, Effort.High];
 const CLOUDFLARE_AI_GATEWAY_BASE_URL = "https://gateway.ai.cloudflare.com/v1/<account>/<gateway>/anthropic";
@@ -76,6 +87,7 @@ type SemVer = {
 type GeminiKind = "pro" | "flash";
 type AnthropicKind = "opus" | "sonnet" | "fable";
 type OpenAIVariant =
+	| "astra"
 	| "base"
 	| "codex"
 	| "codex-max"
@@ -230,7 +242,6 @@ export function modelSupportsReasoningControl<TApi extends Api>(
 	resolvedBaseUrl?: string,
 ): boolean {
 	if (!model.reasoning) return false;
-
 	if (model.api === "openai-completions") {
 		const completionsModel = model as ApiModel<"openai-completions">;
 		const explicitSupport = completionsModel.compat?.supportsReasoningEffort;
@@ -354,6 +365,18 @@ export function clampThinkingLevelForModel<TApi extends Api>(
 	if (!modelSupportsReasoningControl(model) || requested === undefined) {
 		return undefined;
 	}
+	if (model.api === "anthropic-messages" && model.provider === "anthropic") {
+		const baseUrl = model.baseUrl;
+		try {
+			const url = new URL(baseUrl || "https://api.anthropic.com");
+			if (url.protocol !== "https:" || url.hostname !== "api.anthropic.com") return undefined;
+		} catch {
+			return undefined;
+		}
+	}
+	if (!model.thinking) {
+		return undefined;
+	}
 
 	const levels = getSupportedEfforts(model);
 	if (levels.includes(requested)) {
@@ -539,6 +562,13 @@ function applyGeneratedModelPolicy(model: ApiModel<Api>): void {
 	if (parsedModel.family === "openai") {
 		applyOpenAICatalogPolicy(model, parsedModel);
 	}
+	if (model.provider === "amazon-bedrock" && model.api === "bedrock-converse-stream") {
+		const cacheSupport = supportsBedrockClaudePromptCaching(model.id);
+		if (cacheSupport === false) {
+			model.cost.cacheRead = 0;
+			model.cost.cacheWrite = 0;
+		}
+	}
 	// GLM-5.2 (Zhipu/ZAI): ships a 1M lossless context window, but the bundled
 	// catalog copied GLM-5.1's 200K and that stale value survives generate-models
 	// (provider-scoped models bypass the models.dev refresh in applyGlobalModelsDevFallback).
@@ -655,7 +685,10 @@ function inferGeneratedApplyPatchToolType(
 	model: ApiModel<Api>,
 	parsedModel: ParsedModel,
 ): ApiModel<Api>["applyPatchToolType"] {
-	if (parsedModel.family !== "openai" || parsedModel.version.major !== 5) {
+	if (
+		parsedModel.family !== "openai" ||
+		(parsedModel.version.major !== 5 && !(parsedModel.version.major === 6 && parsedModel.variant === "astra"))
+	) {
 		return undefined;
 	}
 	if (model.provider === "openai" && model.api === "openai-responses") {
@@ -808,12 +841,14 @@ function expandEffortRange(thinking: ThinkingConfig): readonly Effort[] {
 }
 
 function inferSupportedEfforts<TApi extends Api>(parsedModel: ParsedModel, model: ApiModel<TApi>): readonly Effort[] {
-	if (model.provider === "xai" && model.id === "grok-4.5") {
+	const grokGeneration = parseDirectXaiReasoningEffortGeneration(model);
+	if (grokGeneration !== undefined) {
+		if (grokGeneration.major === 4 && grokGeneration.minor === 6) return GROK_4_6_EFFORTS;
+		if (GROK_4_20_REASONING_MODEL_IDS.has(model.id)) {
+			return GROK_4_20_EFFORTS;
+		}
 		return GROK_4_5_EFFORTS;
 	}
-	if (model.provider === "xai" && model.id === "grok-4.6") {
-		return GROK_4_6_EFFORTS;
-	}
 	if (model.provider === "kimi-code" && model.id === "k3") {
 		return KIMI_K3_EFFORTS;
 	}
@@ -1002,7 +1037,7 @@ function parseAnthropicModel(modelId: string): AnthropicModel | null {
 
 function parseOpenAIModel(modelId: string): OpenAIModel | null {
 	const match =
-		/gpt-(\d+(?:\.\d+){0,2})(?:-(codex-spark|codex-mini|codex-max|codex|luna|mini|max|nano|sol|terra))?$/.exec(
+		/gpt-(\d+(?:\.\d+){0,2})(?:-(astra|codex-spark|codex-mini|codex-max|codex|luna|mini|max|nano|sol|terra))?$/.exec(
 			modelId,
 		);
 	if (!match) {

package/src/models.json

@@ -65461,6 +65461,43 @@
 			},
 			"applyPatchToolType": "freeform"
 		},
+		"gpt-6-astra": {
+			"id": "gpt-6-astra",
+			"name": "GPT-6-Astra",
+			"api": "openai-codex-responses",
+			"provider": "openai-codex",
+			"baseUrl": "https://chatgpt.com/backend-api",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 10,
+				"output": 50,
+				"cacheRead": 1,
+				"cacheWrite": 12.5
+			},
+			"contextWindow": 272000,
+			"maxTokens": 128000,
+			"preferWebsockets": true,
+			"priority": 1,
+			"thinking": {
+				"mode": "effort",
+				"minLevel": "low",
+				"maxLevel": "max"
+			},
+			"longContextPricing": {
+				"threshold": 272000,
+				"cost": {
+					"input": 20,
+					"output": 75,
+					"cacheRead": 2,
+					"cacheWrite": 25
+				}
+			},
+			"applyPatchToolType": "freeform"
+		},
 		"gpt-daybreak-blue-latest": {
 			"id": "gpt-daybreak-blue-latest",
 			"name": "Daybreak Blue",

package/src/openai-completions-compat.d.ts

@@ -1,10 +1,32 @@
 import type { Model, OpenAICompat } from "./types";
 type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+export type GrokGeneration = {
+    major: number;
+    minor: number;
+};
 /** Returns whether the request endpoint is an audited reasoning-control transport. */
 export declare function isAuditedOpenAIReasoningTransport(model: {
     provider: string;
     baseUrl?: string;
 }, resolvedBaseUrl?: string): boolean;
+/**
+ * xAI's first-party API accepts `reasoning_effort` on Grok 4.5 and later.
+ * Provider labels are user-configurable, so both the provider and the official
+ * API origin must match. Unknown variants fail closed instead of inheriting a
+ * capability from a loose model-id prefix.
+ */
+export declare function parseDirectXaiReasoningEffortGeneration(model: {
+    provider: string;
+    id: string;
+    api?: string;
+    baseUrl?: string;
+}, resolvedBaseUrl?: string): GrokGeneration | undefined;
+export declare function isDirectXaiReasoningEffortModel(model: {
+    provider: string;
+    id: string;
+    api?: string;
+    baseUrl?: string;
+}, resolvedBaseUrl?: string): boolean;
 export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "reservedToolNames">> & {
     openRouterRouting?: OpenAICompat["openRouterRouting"];
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];