@gajae-code/ai 0.12.21 → 0.13.0

package/src/context-cap-policy.ts

@@ -1,5 +1,34 @@
 import type { Api, Model } from "./types";
 
+/**
+ * Codex GPT-5.6 OAuth context-window policy.
+ *
+ * Authoritative source and ownership path
+ * ---------------------------------------
+ * The authenticated Codex backend discovery endpoint (`GET {base}/codex/models`
+ * with an OAuth bearer token) is the authoritative runtime source of Codex OAuth
+ * model context-window metadata (`models[].context_window`). OpenAI owns that
+ * value; GJC consumes it read-only via `fetchCodexModels` and must not silently
+ * invent a larger limit without upstream evidence.
+ *
+ * This bundled policy is a client-side conservative guard, not a primary source.
+ * It exists because OpenAI temporarily reverted the GPT-5.6 Sol product context
+ * limit from 372K to 272K on 2026-07-13 (staff announcement quoted in
+ * gajae-code issues #2240 / #2260), while planning to restore 372K later.
+ * `ceiling` must only be raised with an upstream evidence citation; an
+ * unverified report that "372K is live again" is not sufficient.
+ *
+ * Precedence (highest -> lowest)
+ * ------------------------------
+ * 1. Explicit user per-model override (`contextWindow` in `modelOverrides`).
+ *    The model registry merges it into `model.contextWindow` before this cap and
+ *    passes it here; it is honored when a positive finite number, with
+ *    diagnostics emitted at the registry. Never silently discarded.
+ * 2. Live OAuth discovery metadata (`context_window`), forced to the enforced
+ *    product window for the GPT-5.6 tier.
+ * 3. Bundled conservative generic window (`CODEX_GENERIC_CONTEXT_WINDOW`),
+ *    used when discovery metadata is absent or invalid.
+ */
 export interface CodexGpt56ContextCapPolicy {
 	/**
 	 * Usable prompt budget forced for the GPT-5.6 tier on the Codex product
@@ -37,6 +66,9 @@ export function isCodexProductTransport(model: Pick<Model<Api>, "api" | "provide
 export function isCodexGpt56Tier(model: Pick<Model<Api>, "id">): boolean {
 	return CODEX_GPT_5_6_MODEL_IDS.has(model.id.toLowerCase());
 }
+export function codexContextOverrideKey(provider: string, modelId: string): string {
+	return `${provider.toLowerCase()}:${modelId.toLowerCase()}`;
+}
 
 export function resolveCodexGpt56DiscoveryContext(
 	model: Pick<Model<Api>, "api" | "id" | "provider">,
@@ -54,14 +86,34 @@ export function resolveCodexGpt56DiscoveryContext(
 	return policy.enforced;
 }
 
+/**
+ * Applies the final Codex GPT-5.6 context ceiling, honoring explicit user
+ * overrides.
+ *
+ * `userContextWindowOverrides` maps provider-qualified composite keys
+ * (`provider:modelId`, both lowercased, built by
+ * {@link codexContextOverrideKey}) to the user's explicit `contextWindow` value
+ * (already merged into `model.contextWindow` by the model registry). A tier
+ * model present with a positive finite value keeps its value even above
+ * `enforced` — the user's explicit, diagnosed choice. Every other tier
+ * model is forced to `enforced`, so a stale larger live/cached observation
+ * (e.g. a pre-rollback 373K cache) cannot resurface without an override.
+ * Because the key is provider-qualified, an override only exempts the exact
+ * provider+model pair it was configured for.
+ */
 export function applyFinalCodexGpt56ContextCap<TApi extends Api>(
 	models: readonly Model<TApi>[],
 	policy: CodexGpt56ContextCapPolicy = CODEX_GPT_5_6_CONTEXT_CAP,
+	userContextWindowOverrides: ReadonlyMap<string, number> = new Map(),
 ): Model<TApi>[] {
 	return models.map(model => {
 		if (!isCodexGpt56Tier(model as Model<Api>) || !isCodexProductTransport(model as Model<Api>)) {
 			return model;
 		}
+		const userOverride = userContextWindowOverrides.get(codexContextOverrideKey(model.provider, model.id));
+		if (userOverride !== undefined && isPositiveFiniteNumber(userOverride)) {
+			return model;
+		}
 		return { ...model, contextWindow: policy.enforced };
 	});
 }

package/src/providers/anthropic.ts

@@ -68,6 +68,7 @@ import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } fr
 import {
 	FirstEventTimeoutError,
 	getProviderFirstEventTimeoutFallbackMs,
+	getProviderStreamIdleTimeoutFallbackMs,
 	getStreamFirstEventTimeoutMs,
 	getStreamIdleTimeoutMs,
 	iterateWithIdleTimeout,
@@ -1479,6 +1480,10 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			let thinkingReplayRepairScope: AnthropicThinkingReplayRepairScope =
 				providerSessionState?.thinkingReplayRepairScope ?? "none";
 			let thinkingReplayRepairAttempts = providerSessionState?.thinkingReplayRepairAttempts ?? 0;
+			// A scope inherited from an earlier turn can only have come from the
+			// deterministic branch below — the speculative masked-`api_error` probe is
+			// never persisted — so a completed stream must not release it.
+			let thinkingReplayRepairPersistent = thinkingReplayRepairScope !== "none";
 			let generatedCacheBudget: GeneratedCacheBudget = providerSessionState?.generatedCacheBudget ?? 2;
 			const prepareParams = async (): Promise<MessageCreateParamsStreaming> => {
 				// Degradation state is cumulative: every fallback rebuild must merge all
@@ -1579,7 +1584,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				truncatedToolCalls.clear();
 				sawTerminalStopReason = false;
 			};
-			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getStreamIdleTimeoutMs();
+			const idleTimeoutMs =
+				options?.streamIdleTimeoutMs ??
+				getStreamIdleTimeoutMs(getProviderStreamIdleTimeoutFallbackMs(model.provider));
 			const firstEventFallbackMs = getProviderFirstEventTimeoutFallbackMs(model.provider);
 			const firstEventTimeoutMs =
 				options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs, firstEventFallbackMs);
@@ -1915,7 +1922,17 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					// branch above fires on an error nobody can classify, so keeping its
 					// guess would silently strip native thinking replay from every later
 					// turn of the session over what may have been one transient blip.
-					if (providerSessionState && (thinkingReplayRepairScope !== "none" || thinkingReplayRepairAttempts > 0)) {
+					//
+					// A deterministic rejection ("cannot be modified" / invalid signature) is
+					// the opposite case: it cites blocks that stay in this session's history,
+					// so releasing the repair here makes the next turn replay the same blocks
+					// and spend another rejected round trip on every turn that follows. That
+					// repair has to outlive the stream it fixed.
+					if (
+						providerSessionState &&
+						!thinkingReplayRepairPersistent &&
+						(thinkingReplayRepairScope !== "none" || thinkingReplayRepairAttempts > 0)
+					) {
 						providerSessionState.thinkingReplayRepairScope = "none";
 						providerSessionState.thinkingReplayRepairAttempts = 0;
 					}
@@ -2004,6 +2021,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							error: streamFailure instanceof Error ? streamFailure.message : String(streamFailure),
 						});
 						thinkingReplayRepairScope = nextScope;
+						// Anything but the masked probe is caused by blocks that remain in
+						// history, so this repair must survive the stream it is about to fix.
+						if (!maskedProxyRejection) thinkingReplayRepairPersistent = true;
 						if (providerSessionState) {
 							providerSessionState.thinkingReplayRepairAttempts = thinkingReplayRepairAttempts;
 							if (!maskedProxyRejection) {

package/src/providers/mock.ts

@@ -87,6 +87,8 @@ export interface MockResponse {
 	usage?: Partial<Omit<Usage, "cost">> & { cost?: Partial<Usage["cost"]> };
 	/** Pre-set responseId. */
 	responseId?: string;
+	/** Optional typed provider failure metadata for retry/fallback tests. */
+	transportFailure?: AssistantMessage["transportFailure"];
 	/** If set, the stream emits a terminal error event instead of completing. */
 	throw?: string | Error;
 	/** Delay before any event is emitted. Honors the call's AbortSignal. */
@@ -363,6 +365,7 @@ async function runMock(
 		provider: model.provider,
 		model: model.id,
 		responseId: response.responseId,
+		transportFailure: response.transportFailure,
 		usage: emptyUsage(),
 		stopReason: "stop",
 		timestamp: startedAt,

package/src/providers/openai-responses.ts

@@ -36,7 +36,7 @@ import {
 } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
 import { AssistantMessageEventStream } from "../utils/event-stream";
-import { transportFailureFacts } from "../utils/fallback-transport";
+import { EMPTY_RESPONSE_PROVIDER_CODE, transportFailureFacts } from "../utils/fallback-transport";
 import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
 import {
 	FirstEventTimeoutError,
@@ -320,6 +320,26 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
 	stream_options?: { include_obfuscation?: boolean };
 };
 
+export function isOpenCodeGoEmptyCompletedResponse(
+	model: Model<"openai-responses">,
+	output: AssistantMessage,
+	nativeOutputItemCount: number,
+): boolean {
+	return (
+		model.provider === "opencode-go" &&
+		typeof output.responseId === "string" &&
+		output.responseId.length > 0 &&
+		output.stopReason === "stop" &&
+		output.content.length === 0 &&
+		nativeOutputItemCount === 0 &&
+		output.usage.input === 0 &&
+		output.usage.output === 0 &&
+		output.usage.cacheRead === 0 &&
+		output.usage.cacheWrite === 0 &&
+		output.usage.totalTokens === 0
+	);
+}
+
 /**
  * Generate function for OpenAI Responses API
  */
@@ -462,11 +482,23 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 			}
 
 			output.providerPayload = createOpenAIResponsesHistoryPayload(model.provider, nativeOutputItems);
+			if (isOpenCodeGoEmptyCompletedResponse(model, output, nativeOutputItems.length)) {
+				output.stopReason = "error";
+				output.errorMessage = "Provider returned an empty response with zero token usage";
+				output.transportFailure = {
+					kind: "transport",
+					providerCode: EMPTY_RESPONSE_PROVIDER_CODE,
+				};
+			}
 			if (providerSessionState) providerSessionState.nativeHistoryReplayWarmed = true;
 
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			stream.push({ type: "done", reason: output.stopReason, message: output });
+			if (output.stopReason === "error") {
+				stream.push({ type: "error", reason: "error", error: output });
+			} else {
+				stream.push({ type: "done", reason: output.stopReason, message: output });
+			}
 			stream.end();
 		} catch (error) {
 			for (const block of output.content) delete (block as { index?: number }).index;

package/src/utils/fallback-transport.ts

@@ -24,6 +24,8 @@ export interface FallbackTrigger {
 
 /** Stable code for streams that time out before producing semantic progress. */
 export const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
+/** Stable code for a nominally successful response with no content or token usage. */
+export const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
 
 export type TransportHeaders = Headers | Record<string, string | undefined>;
 
@@ -212,7 +214,8 @@ export function transportFailureFacts(
 		!isAuthCode(normalizedCode) &&
 		!isRateLimitCode(normalizedCode) &&
 		!isContextOverflowCode(normalizedCode) &&
-		normalizedCode !== STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE
+		normalizedCode !== STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE &&
+		normalizedCode !== EMPTY_RESPONSE_PROVIDER_CODE
 	) {
 		return undefined;
 	}
@@ -320,7 +323,7 @@ export function classifyFallbackTrigger(
 	);
 	const code = codes[0] ?? codes[1] ?? codes[2];
 	const triggerClass: FallbackTriggerClass =
-		code === STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE
+		code === STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE || code === EMPTY_RESPONSE_PROVIDER_CODE
 			? "server"
 			: isQuotaCode(code)
 				? "quota"

package/src/utils/idle-iterator.ts

@@ -6,6 +6,12 @@ const DEFAULT_STREAM_FIRST_EVENT_TIMEOUT_MS = 100_000;
 const ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS = 600_000;
 const KIMI_CODE_FIRST_EVENT_TIMEOUT_MS = 300_000;
 
+const ANTHROPIC_STREAM_IDLE_TIMEOUT_MS = 300_000;
+
+export function getProviderStreamIdleTimeoutFallbackMs(provider: string): number | undefined {
+	return provider === "anthropic" ? ANTHROPIC_STREAM_IDLE_TIMEOUT_MS : undefined;
+}
+
 export function getProviderFirstEventTimeoutFallbackMs(provider: string): number | undefined {
 	if (provider === "alibaba-token-plan") return ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS;
 	return provider === "kimi-code" ? KIMI_CODE_FIRST_EVENT_TIMEOUT_MS : undefined;

package/src/utils/overflow.ts

@@ -145,6 +145,7 @@ const NON_OVERFLOW_PROVIDER_CODES = new Set([
 	"rate_limit_error",
 	"rate_limit_exceeded",
 	"too_many_requests",
+	"empty_response",
 ]);
 
 function transportCodes(transportFailure: TransportFailureFacts | undefined): string[] {