@gajae-code/ai 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -2,9 +2,15 @@
 
 ## [Unreleased]
 
+## [0.13.2] - 2026-08-13
+
+## [0.13.1] - 2026-08-11
+
 ### Fixed
 
 - Anthropic thinking-replay repairs caused by a deterministic rejection now stay in force for the rest of the session instead of being released as soon as the repaired retry succeeds. `thinking`/`redacted_thinking` blocks that draw a 400 (`blocks ... cannot be modified`, `Invalid \`signature\` in \`thinking\` block`) stay in the session history, so releasing the repair made the very next turn replay the same blocks and spend another rejected round trip — every turn, indefinitely. Observed against a proxied Claude Code session as a sustained ~50% 400 rate that never converged. The speculative masked-`api_error` probe is still released on the first completed stream, since that one may have been a transient blip (#4011).
+- Anthropic requests no longer spend a rejected round trip discovering that the latest assistant turn cannot replay its thinking block. Anthropic streams a `thinking` block as a start/stop pair with no `thinking_delta` and no `signature_delta` when it withholds reasoning, which lands in history empty and unsigned; `convertAnthropicMessages` then dropped it, and the turn went back carrying only its `tool_use`. Anthropic validates the latest assistant message against the turn it produced and rejects the missing block with 400 `blocks ... cannot be modified`. A captured production request showed exactly this shape — 1214 messages, 29 signed-but-empty thinking blocks preserved, and the latest assistant turn reduced to a bare `tool_use`. The condition is visible locally, so the replay now degrades during the first build instead of after the rejection.
+- The unreplayable-thinking detection now correctly excludes non-signing endpoints (DeepSeek, Z.AI), which replay unsigned blocks verbatim and never validate thinking presence, and signed-but-empty blocks, which `convertAnthropicMessages` forwards natively via the signed-thinking path. The original detection treated empty text as always unreplayable, which degraded valid reasoning on non-signing endpoints and dropped natively replayable signed-empty blocks (#4172).
 
 ## [0.12.21] - 2026-08-09
 

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

@@ -1,11 +1,12 @@
 import type { Model, OpenAICompat } from "./types";
 type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
-export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "reservedToolNames">> & {
+export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "reservedToolNames">> & {
     openRouterRouting?: OpenAICompat["openRouterRouting"];
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
     toolStrictMode: ResolvedToolStrictMode;
     supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
+    supportsServiceTier?: OpenAICompat["supportsServiceTier"];
     /** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
     toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
 };

package/dist/types/providers/openai-responses-shared.d.ts

@@ -79,7 +79,7 @@ type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK"
  * Apply the common `StreamOptions` → Responses sampling-parameter mapping (max output tokens,
  * temperature, top-p/k, min-p, presence/repetition penalties, service tier). Mutates `params`.
  */
-export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string): void;
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string, supportsServiceTier?: boolean): void;
 type ReasoningOptions = {
     reasoning?: string;
     reasoningSummary?: "auto" | "detailed" | "concise" | null;

package/dist/types/types.d.ts

@@ -111,10 +111,16 @@ export type ResolvedServiceTier = Exclude<ServiceTier, "openai-only" | "claude-o
 export declare function resolveServiceTier(serviceTier: ServiceTier | null | undefined, provider: Provider | undefined): ResolvedServiceTier | undefined;
 /**
  * True when the (possibly scoped) tier should be sent as an OpenAI-compatible
- * `service_tier` request field for providers that support it. Unsupported tiers
- * (`"auto"`, `"default"`) and scope mismatches all return false.
+ * `service_tier` request field. Custom providers must explicitly opt in through
+ * `compat.supportsServiceTier`; unknown providers remain fail-closed.
  */
-export declare function shouldSendServiceTier(serviceTier: ServiceTier | null | undefined, provider: Provider | undefined): boolean;
+export declare function shouldSendServiceTier(serviceTier: ServiceTier | null | undefined, provider: Provider | undefined, supportsServiceTier?: boolean): boolean;
+/**
+ * True when a priority tier is realized as a fast-mode request on the provider's
+ * wire protocol. Custom OpenAI-compatible proxies opt in explicitly rather than
+ * inheriting support merely because their API shape resembles OpenAI.
+ */
+export declare function isFastModeEffectiveForProvider(serviceTier: ServiceTier | null | undefined, provider: Provider | undefined, supportsServiceTier?: boolean): boolean;
 /**
  * Premium-request weight contributed by sending priority to a provider
  * that supports it. Mirrors GitHub Copilot's `premiumRequests` accounting
@@ -718,6 +724,12 @@ export interface OpenAICompat extends ToolChoiceCompat {
      * HTTPS origin automatically; known non-OpenAI providers remain excluded.
      */
     supportsResponsesSessionAffinity?: boolean;
+    /**
+     * Whether an OpenAI-compatible endpoint accepts the `service_tier` request
+     * field. Disabled by default for custom providers; opt in only when the proxy
+     * preserves or intentionally realizes OpenAI priority processing.
+     */
+    supportsServiceTier?: boolean;
     /**
      * Tool names the provider reserves for its own built-ins and refuses to
      * accept as custom function declarations. A colliding tool is **dropped**
@@ -957,3 +969,5 @@ export interface Model<TApi extends Api = any> {
      */
     isOAuth?: boolean;
 }
+/** True when a model explicitly opts into OpenAI-compatible `service_tier` forwarding. */
+export declare function modelSupportsServiceTier(model: Pick<Model, "compat"> | undefined): boolean;

package/package.json

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

package/src/openai-completions-compat.ts

@@ -12,6 +12,7 @@ export type ResolvedOpenAICompat = Required<
 		| "toolStrictMode"
 		| "toolChoiceSupport"
 		| "supportsResponsesSessionAffinity"
+		| "supportsServiceTier"
 		| "reservedToolNames"
 	>
 > & {
@@ -20,6 +21,7 @@ export type ResolvedOpenAICompat = Required<
 	extraBody?: OpenAICompat["extraBody"];
 	toolStrictMode: ResolvedToolStrictMode;
 	supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
+	supportsServiceTier?: OpenAICompat["supportsServiceTier"];
 	/** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
 	toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
 };
@@ -282,6 +284,7 @@ export function resolveOpenAICompat(
 			("supportsResponsesSessionAffinity" in model.compat
 				? model.compat.supportsResponsesSessionAffinity
 				: undefined) ?? detected.supportsResponsesSessionAffinity,
+		supportsServiceTier: model.compat.supportsServiceTier ?? detected.supportsServiceTier,
 		supportsMultipleSystemMessages:
 			model.compat.supportsMultipleSystemMessages ?? detected.supportsMultipleSystemMessages,
 		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,

package/src/providers/anthropic.ts

@@ -2369,6 +2369,46 @@ function hasNativeThinkingBlocks(messages: MessageParam[]): boolean {
 	);
 }
 
+/**
+ * Would the latest assistant turn lose a thinking block on its way to the wire?
+ *
+ * `convertAnthropicMessages` can only replay a `thinking` block natively when it
+ * still carries the bytes Anthropic signed. A block that arrived as a bare
+ * start/stop pair — no `thinking_delta`, no `signature_delta` — has neither, so
+ * it is silently dropped, and Anthropic rejects the turn it produced for coming
+ * back without it. Same for a `redactedThinking` block whose opaque payload is
+ * gone. Only the latest assistant message is inspected because that is the turn
+ * Anthropic validates against its own output.
+ */
+function latestAssistantThinkingIsUnreplayable(messages: Message[], model: Model<"anthropic-messages">): boolean {
+	const index = messages.findLastIndex(message => message.role === "assistant");
+	if (index < 0) return false;
+
+	const assistant = messages[index] as AssistantMessage;
+	// Cross-API history degrades to text rather than replaying native blocks, so
+	// nothing is lost and nothing needs repairing.
+	if (assistant.api !== "anthropic-messages") return false;
+	// Endpoints that never sign thinking replay unsigned blocks verbatim.
+	const requiresSignature = !isNonSigningAnthropicEndpoint(model);
+
+	return assistant.content.some(block => {
+		if (block.type === "redactedThinking") return block.data.trim().length === 0;
+		if (block.type !== "thinking") return false;
+		// A block with empty text and no signature cannot go back on the wire:
+		// `convertAnthropicMessages` drops it, and Anthropic rejects the turn for
+		// arriving without it. A block with a valid signature AND non-empty text is
+		// replayable. But a signed block whose text was emptied — e.g. by
+		// clear_thinking_20251015 — carries a stale signature that signing endpoints
+		// reject on replay (issue #4247). Non-signing endpoints replay unsigned
+		// blocks verbatim, so only they treat a missing signature as unreplayable.
+		const hasSignature = !!block.thinkingSignature?.trim();
+		const isEmpty = !block.thinking.trim();
+		if (!hasSignature) return requiresSignature;
+		if (isEmpty && requiresSignature) return true;
+		return false;
+	});
+}
+
 function mapAnthropicToolChoice(
 	toolChoice: NonNullable<ResolveToolChoiceResult["resolvedChoice"]>,
 	isOAuthToken: boolean,
@@ -2727,6 +2767,27 @@ function buildParams(
 		});
 	}
 
+	// Anthropic compares the latest assistant message against the turn it actually
+	// produced, and rejects it when a `thinking`/`redacted_thinking` block that was
+	// in that response is missing. A block Anthropic streamed as a start/stop pair
+	// with no `thinking_delta` and no `signature_delta` lands in history empty and
+	// unsigned, and `convertAnthropicMessages` then drops it: the turn goes back
+	// carrying only its `tool_use`, and the request is rejected before a token
+	// streams. The rejection is recoverable — the repair drops native thinking from
+	// the whole replay — but only after a full round trip has been spent, and the
+	// condition is visible locally, so detect it here and degrade in the first
+	// build instead of paying for the 400 to discover it.
+	if (
+		!thinkingRepair?.repairAllAssistantThinking &&
+		latestAssistantThinkingIsUnreplayable(context.messages, model) &&
+		hasNativeThinkingBlocks(params.messages)
+	) {
+		params.messages = convertAnthropicMessages(context.messages, model, isOAuthToken, {
+			...thinkingRepair,
+			repairAllAssistantThinking: true,
+		});
+	}
+
 	const shouldInjectClaudeCodeInstruction = isOAuthToken && !model.id.startsWith("claude-3-5-haiku");
 	const billingSystemPrompts = normalizeSystemPrompts(context.systemPrompt);
 	const billingPayload = shouldInjectClaudeCodeInstruction

package/src/providers/openai-completions.ts

@@ -1335,7 +1335,7 @@ function buildParams(
 	if (options?.frequencyPenalty !== undefined) {
 		params.frequency_penalty = options.frequencyPenalty;
 	}
-	if (shouldSendServiceTier(options?.serviceTier, model.provider)) {
+	if (shouldSendServiceTier(options?.serviceTier, model.provider, compat.supportsServiceTier === true)) {
 		const resolved = resolveServiceTier(options?.serviceTier, model.provider);
 		if (resolved === "flex" || resolved === "scale" || resolved === "priority") {
 			params.service_tier = resolved;

package/src/providers/openai-opencodex-responses.ts

@@ -141,6 +141,7 @@ function normalizeModel(row: CatalogRow, endpoint: OpenCodexEndpoint): Model<"op
 		api: "openai-responses",
 		provider: "opencodex",
 		baseUrl: `${endpoint.baseUrl}/v1`,
+		compat: { supportsServiceTier: true },
 		reasoning: row.reasoning !== false,
 		input,
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },

package/src/providers/openai-responses-shared.ts

@@ -920,6 +920,7 @@ export function applyCommonResponsesSamplingParams<P extends CommonResponsesPara
 	params: P,
 	options: CommonSamplingOptions | undefined,
 	provider: string,
+	supportsServiceTier = false,
 ): void {
 	if (options?.maxTokens) params.max_output_tokens = options.maxTokens;
 	if (options?.temperature !== undefined) params.temperature = options.temperature;
@@ -928,7 +929,7 @@ export function applyCommonResponsesSamplingParams<P extends CommonResponsesPara
 	if (options?.minP !== undefined) params.min_p = options.minP;
 	if (options?.presencePenalty !== undefined) params.presence_penalty = options.presencePenalty;
 	if (options?.repetitionPenalty !== undefined) params.repetition_penalty = options.repetitionPenalty;
-	if (shouldSendServiceTier(options?.serviceTier, provider)) {
+	if (shouldSendServiceTier(options?.serviceTier, provider, supportsServiceTier)) {
 		const resolved = resolveServiceTier(options?.serviceTier, provider);
 		if (resolved === "flex" || resolved === "scale" || resolved === "priority") {
 			params.service_tier = resolved;

package/src/providers/openai-responses.ts

@@ -709,7 +709,7 @@ function buildParams(
 		stream_options: model.provider === "openai" ? { include_obfuscation: false } : undefined,
 	};
 
-	applyCommonResponsesSamplingParams(params, options, model.provider);
+	applyCommonResponsesSamplingParams(params, options, model.provider, model.compat?.supportsServiceTier === true);
 	// TODO: openai responses has no top-level `stop`/`stop_sequences`; surface via reasoning.stop?
 	// `StreamOptions.stopSequences` is intentionally dropped for this provider.
 	// TODO: openai responses has no top-level `frequency_penalty` field as of the current SDK;

package/src/providers/transform-messages.ts

@@ -98,8 +98,15 @@ export function transformMessages<TApi extends Api>(
 					if (dropAssistantThinkingForRepair && replaysAsNativeThinking) return [];
 					if (mustPreserveLatestAnthropicThinking) return sanitized;
 					// For same model: keep thinking blocks with signatures (needed for replay)
-					// even if the thinking text is empty (OpenAI encrypted reasoning)
-					if (isSameModel && sanitized.thinkingSignature) return sanitized;
+					// even if the thinking text is empty — but only for non-Anthropic APIs where
+					// the signature represents OpenAI encrypted reasoning. For anthropic-messages,
+					// a signed block with empty text means clear_thinking_20251015 stripped the
+					// content server-side while the stale signature remained; replaying it
+					// produces `thinking ... cannot be modified` 400s on every turn (#4247).
+					if (isSameModel && sanitized.thinkingSignature) {
+						if (sanitized.thinking.trim() === "" && model.api === "anthropic-messages") return [];
+						return sanitized;
+					}
 					// Skip empty thinking blocks, convert others to plain text
 					if (!sanitized.thinking || sanitized.thinking.trim() === "") return [];
 					if (isSameModel) return sanitized;

package/src/types.ts

@@ -257,19 +257,40 @@ export function resolveServiceTier(
 
 /**
  * True when the (possibly scoped) tier should be sent as an OpenAI-compatible
- * `service_tier` request field for providers that support it. Unsupported tiers
- * (`"auto"`, `"default"`) and scope mismatches all return false.
+ * `service_tier` request field. Custom providers must explicitly opt in through
+ * `compat.supportsServiceTier`; unknown providers remain fail-closed.
  */
 export function shouldSendServiceTier(
 	serviceTier: ServiceTier | null | undefined,
 	provider: Provider | undefined,
+	supportsServiceTier = false,
 ): boolean {
 	const resolved = resolveServiceTier(serviceTier, provider);
 	if (provider === "deepinfra") return resolved === "priority";
-	if (provider !== "openai" && provider !== "openai-codex") return false;
+	if (provider !== "openai" && provider !== "openai-codex" && !supportsServiceTier) return false;
 	return resolved === "flex" || resolved === "scale" || resolved === "priority";
 }
 
+/**
+ * True when a priority tier is realized as a fast-mode request on the provider's
+ * wire protocol. Custom OpenAI-compatible proxies opt in explicitly rather than
+ * inheriting support merely because their API shape resembles OpenAI.
+ */
+export function isFastModeEffectiveForProvider(
+	serviceTier: ServiceTier | null | undefined,
+	provider: Provider | undefined,
+	supportsServiceTier = false,
+): boolean {
+	if (resolveServiceTier(serviceTier, provider) !== "priority") return false;
+	return (
+		provider === "openai" ||
+		provider === "openai-codex" ||
+		provider === "anthropic" ||
+		provider === "deepinfra" ||
+		supportsServiceTier
+	);
+}
+
 /**
  * Premium-request weight contributed by sending priority to a provider
  * that supports it. Mirrors GitHub Copilot's `premiumRequests` accounting
@@ -282,12 +303,7 @@ export function getPriorityPremiumRequests(
 	serviceTier: ServiceTier | null | undefined,
 	provider: Provider | undefined,
 ): number {
-	if (resolveServiceTier(serviceTier, provider) !== "priority") return 0;
-	// Only providers that realize `priority` on the wire bill the user.
-	// Everywhere else, the field is silently dropped and nothing is charged.
-	return provider === "openai" || provider === "openai-codex" || provider === "anthropic" || provider === "deepinfra"
-		? 1
-		: 0;
+	return isFastModeEffectiveForProvider(serviceTier, provider) ? 1 : 0;
 }
 
 export interface ProviderSessionState {
@@ -887,6 +903,12 @@ export interface OpenAICompat extends ToolChoiceCompat {
 	 * HTTPS origin automatically; known non-OpenAI providers remain excluded.
 	 */
 	supportsResponsesSessionAffinity?: boolean;
+	/**
+	 * Whether an OpenAI-compatible endpoint accepts the `service_tier` request
+	 * field. Disabled by default for custom providers; opt in only when the proxy
+	 * preserves or intentionally realizes OpenAI priority processing.
+	 */
+	supportsServiceTier?: boolean;
 	/**
 	 * Tool names the provider reserves for its own built-ins and refuses to
 	 * accept as custom function declarations. A colliding tool is **dropped**
@@ -1148,3 +1170,8 @@ export interface Model<TApi extends Api = any> {
 	 */
 	isOAuth?: boolean;
 }
+
+/** True when a model explicitly opts into OpenAI-compatible `service_tier` forwarding. */
+export function modelSupportsServiceTier(model: Pick<Model, "compat"> | undefined): boolean {
+	return Boolean(model?.compat && "supportsServiceTier" in model.compat && model.compat.supportsServiceTier === true);
+}