@sayknow-cli/ai 0.3.16 → 0.4.1

package/src/model-cache.ts

@@ -66,6 +66,16 @@ function getDb(dbPath?: string): Database {
 	return db;
 }
 
+/** Close the shared cache only when it owns the exact requested database path. */
+export function closeModelCache(dbPath?: string): boolean {
+	const resolvedPath = dbPath ?? getModelDbPath();
+	if (!sharedDb || sharedDbPath !== resolvedPath) return false;
+	sharedDb.close();
+	sharedDb = null;
+	sharedDbPath = null;
+	return true;
+}
+
 function migrateCacheSchema(db: Database): void {
 	const columns = db.prepare("PRAGMA table_info(model_cache)").all() as TableInfoRow[];
 	if (!columns.some(column => column.name === "static_fingerprint")) {

package/src/model-manager.ts

@@ -1,3 +1,4 @@
+import { applyFinalCodexGpt56ContextCap } from "./context-cap-policy";
 import { readModelCache, writeModelCache } from "./model-cache";
 import { isRetiredModel, isRetiredModelKey } from "./model-retirements";
 import { applyGeneratedModelPolicies, enrichModelThinking } from "./model-thinking";
@@ -40,6 +41,8 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
 	modelsDev?: ModelsDevFallback<TApi, TModelsDevPayload>;
 	/** Clock override for deterministic tests. */
 	now?: () => number;
+	/** Optional guard that must permit cache publication. Default: writes are permitted. */
+	canPublishCache?: () => boolean;
 }
 
 /**
@@ -98,7 +101,7 @@ function passModelList<TApi extends Api>(value: unknown): Model<TApi>[] {
 		out.push(enrichModelThinking(item as Model<TApi>));
 	}
 	applyGeneratedModelPolicies(out as Model<Api>[]);
-	return out;
+	return applyFinalCodexGpt56ContextCap(out);
 }
 
 /**
@@ -147,7 +150,9 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 			return { models: cachedModels, stale: false };
 		}
 		const repairedModels = mergeDynamicModels(staticModels, cachedModels);
-		writeModelCache(options.providerId, now(), repairedModels, true, staticFingerprint, dbPath);
+		if (options.canPublishCache?.() ?? true) {
+			writeModelCache(options.providerId, now(), repairedModels, true, staticFingerprint, dbPath);
+		}
 		return { models: repairedModels, stale: false };
 	}
 
@@ -161,27 +166,35 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	const cacheModels = dynamicFetchSucceeded ? [] : normalizeModelList<TApi>(cache?.models ?? []);
 	const dynamicModels = fetchedDynamicModels ?? [];
 	const mergedWithCache = mergeDynamicModels(mergeModelSources(staticModels, modelsDevModels), cacheModels);
-	const models = mergeDynamicModels(mergedWithCache, dynamicModels);
+	const models = applyFinalCodexGpt56ContextCap(mergeDynamicModels(mergedWithCache, dynamicModels));
 	const dynamicAuthoritative = !hasDynamicFetcher || dynamicFetchSucceeded || shouldUseFreshCacheAsAuthoritative;
 	if (shouldFetchFromNetwork) {
 		if (dynamicFetchSucceeded) {
-			const snapshotModels = mergeDynamicModels(mergeModelSources(staticModels, modelsDevModels), dynamicModels);
-			writeModelCache(options.providerId, now(), snapshotModels, true, staticFingerprint, dbPath);
+			const snapshotModels = applyFinalCodexGpt56ContextCap(
+				mergeDynamicModels(mergeModelSources(staticModels, modelsDevModels), dynamicModels),
+			);
+			if (options.canPublishCache?.() ?? true) {
+				writeModelCache(options.providerId, now(), snapshotModels, true, staticFingerprint, dbPath);
+			}
 		} else {
 			// Dynamic fetch failed — update cache with a non-authoritative snapshot so
 			// stale state remains visible while retry backoff still applies.
 			const latestCache = readModelCache<TApi>(options.providerId, ttlMs, now, dbPath);
-			writeModelCache(
-				options.providerId,
-				now(),
-				mergeDynamicModels(
-					mergeModelSources(staticModels, modelsDevModels),
-					normalizeModelList<TApi>(latestCache?.models ?? cache?.models ?? []),
-				),
-				false,
-				staticFingerprint,
-				dbPath,
-			);
+			if (options.canPublishCache?.() ?? true) {
+				writeModelCache(
+					options.providerId,
+					now(),
+					applyFinalCodexGpt56ContextCap(
+						mergeDynamicModels(
+							mergeModelSources(staticModels, modelsDevModels),
+							normalizeModelList<TApi>(latestCache?.models ?? cache?.models ?? []),
+						),
+					),
+					false,
+					staticFingerprint,
+					dbPath,
+				);
+			}
 		}
 	}
 	return {
@@ -393,7 +406,7 @@ function normalizeModelList<TApi extends Api>(value: unknown): Model<TApi>[] {
 			models.push(enrichModelThinking(item as Model<TApi>));
 		}
 	}
-	return models;
+	return applyFinalCodexGpt56ContextCap(models);
 }
 
 function isModelLike(value: unknown): value is Model<Api> {

package/src/model-thinking.ts

@@ -1,3 +1,4 @@
+import { CODEX_GPT_5_6_CONTEXT_CAP, isCodexGpt56Tier, isCodexProductTransport } from "./context-cap-policy";
 import { resolveOpenAICompat } from "./providers/openai-completions-compat";
 import type { Api, Model as ApiModel, ThinkingConfig } from "./types";
 import { isClaudeForcedToolChoiceIncapableModelId } from "./utils/tool-choice-capability";
@@ -49,6 +50,7 @@ const GEMINI_3_FLASH_EFFORTS: readonly Effort[] = [Effort.Minimal, Effort.Low, E
 const GPT_5_2_PLUS_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Effort.High, Effort.XHigh];
 const GPT_5_6_PLUS_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Effort.High, Effort.XHigh, Effort.Max];
 const GPT_5_5_DEFAULT_EFFORT = Effort.XHigh;
+const KIMI_K3_EFFORTS: readonly Effort[] = [Effort.Low, Effort.High, Effort.Max];
 
 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";
@@ -477,15 +479,13 @@ function applyGpt55ContextWindow(model: ApiModel<Api>, parsedModel: OpenAIModel)
 	}
 	return false;
 }
-const GPT_5_6_TIER_VARIANTS: ReadonlySet<OpenAIVariant> = new Set(["base", "sol", "terra", "luna"]);
-
-function applyGpt56ContextWindow(model: ApiModel<Api>, parsedModel: OpenAIModel): boolean {
-	if (!semverGte(parsedModel.version, "5.6") || !GPT_5_6_TIER_VARIANTS.has(parsedModel.variant)) {
+function applyGpt56ContextWindow(model: ApiModel<Api>): boolean {
+	if (!isCodexGpt56Tier(model) || !isCodexProductTransport(model)) {
 		return false;
 	}
-	// GPT-5.6 tiers enforce a ~373K usable prompt budget on both transports
-	// (matches the openai-codex live catalog), despite the 1M+ marketing window.
-	model.contextWindow = 373_000;
+	// Codex product metadata is bounded by the currently enforced prompt cap.
+	// Smaller observed limits remain authoritative; first-party OpenAI is untouched.
+	model.contextWindow = Math.min(model.contextWindow, CODEX_GPT_5_6_CONTEXT_CAP.ceiling);
 	return true;
 }
 
@@ -493,7 +493,7 @@ function applyOpenAICatalogPolicy(model: ApiModel<Api>, parsedModel: OpenAIModel
 	if (applyGpt55ContextWindow(model, parsedModel)) {
 		return;
 	}
-	if (applyGpt56ContextWindow(model, parsedModel)) {
+	if (applyGpt56ContextWindow(model)) {
 		return;
 	}
 	// OpenAI code backend models: 400K figure includes output budget; input window is 272K.
@@ -517,6 +517,9 @@ function applyOpenAICatalogPolicy(model: ApiModel<Api>, parsedModel: OpenAIModel
 }
 
 function inferDefaultEffort<TApi extends Api>(model: ApiModel<TApi>, parsedModel: ParsedModel): Effort | undefined {
+	if (model.provider === "kimi-code" && model.id === "k3") {
+		return Effort.High;
+	}
 	if (
 		parsedModel.family === "openai" &&
 		model.provider === "openai-codex" &&
@@ -592,6 +595,9 @@ function expandEffortRange(thinking: ThinkingConfig): readonly Effort[] {
 }
 
 function inferSupportedEfforts<TApi extends Api>(parsedModel: ParsedModel, model: ApiModel<TApi>): readonly Effort[] {
+	if (model.provider === "kimi-code" && model.id === "k3") {
+		return KIMI_K3_EFFORTS;
+	}
 	switch (parsedModel.family) {
 		case "openai":
 			return inferOpenAISupportedEfforts(parsedModel);

package/src/providers/amazon-bedrock.ts

@@ -30,6 +30,7 @@ import type {
 } from "../types";
 import { normalizeToolCallId, resolveCacheRetention, sanitizeJsonStrings } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
+import { transportFailureFacts } from "../utils/fallback-transport";
 import { appendRawHttpRequestDumpFor400, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
 import { parseStreamingJson } from "../utils/json-parse";
 import { resolveRetryBudget } from "../utils/retry-budget";
@@ -317,7 +318,12 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 					new Error(`Bedrock HTTP ${response.status}: ${errBody.slice(0, 1000)}`),
 					response.status,
 				);
-				if (firstTokenTime === undefined && !fallbackRan && isForcedToolChoiceUnsupportedError(error, true)) {
+				if (
+					firstTokenTime === undefined &&
+					!fallbackRan &&
+					!options.fallbackManaged &&
+					isForcedToolChoiceUnsupportedError(error, true)
+				) {
 					response = await retryWithoutForcedToolChoice(error.message);
 				} else {
 					throw error;
@@ -349,6 +355,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 							firstTokenTime === undefined &&
 							sentForcedToolChoice &&
 							!fallbackRan &&
+							!options.fallbackManaged &&
 							isForcedToolChoiceUnsupportedError(error, true)
 						) {
 							response = await retryWithoutForcedToolChoice(error.message);
@@ -432,6 +439,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 			}
 			output.stopReason = options.signal?.aborted ? "aborted" : "error";
 			output.errorStatus = extractHttpStatusFromError(error);
+			output.transportFailure = transportFailureFacts(error);
 			const baseMessage = error instanceof Error ? error.message : JSON.stringify(error);
 			// Enrich error with thinking block diagnostics for signature-related failures
 			let diagnostics = "";

package/src/providers/anthropic-messages-server.ts

@@ -417,6 +417,62 @@ function mapStopReasonOut(reason: StopReason): "end_turn" | "max_tokens" | "tool
 	}
 }
 
+/**
+ * True when `signature` is one of OUR serialized OpenAI Responses reasoning-item
+ * envelopes (produced by the Responses/Codex decoders as
+ * `JSON.stringify(reasoningItem)` with `type: "reasoning"`). Such an envelope is
+ * NOT a valid Anthropic thinking signature and may embed raw chain-of-thought in
+ * `content[]`, so it must never be forwarded on Anthropic egress. Genuine opaque
+ * Anthropic signatures and any non-envelope string return false (fail safe).
+ */
+function isSerializedResponsesReasoningItem(signature: string): boolean {
+	try {
+		const parsed: unknown = JSON.parse(signature);
+		return (
+			typeof parsed === "object" &&
+			parsed !== null &&
+			!Array.isArray(parsed) &&
+			(parsed as { type?: unknown }).type === "reasoning"
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * A thinking-block signature safe to emit on Anthropic egress: cross-protocol
+ * serialized Responses reasoning envelopes are omitted (they can carry raw CoT);
+ * genuine opaque Anthropic signatures round-trip unchanged.
+ */
+function safeThinkingSignature(signature: string | undefined): string | undefined {
+	if (!signature) return undefined;
+	if (isSerializedResponsesReasoningItem(signature)) return undefined;
+	return signature;
+}
+
+function isResponsesFamilyApi(api: AssistantMessage["api"]): boolean {
+	return api === "openai-responses" || api === "openai-codex-responses";
+}
+
+function safeThinkingText(content: ThinkingContent, api: AssistantMessage["api"]): string | undefined {
+	if (isResponsesFamilyApi(api) && content.provenance === undefined) return undefined;
+	if (content.provenance === "raw") return undefined;
+	if (content.provenance === "mixed") return content.summaryText;
+	if (content.provenance === "summary") return content.summaryText ?? content.thinking;
+	return content.thinking;
+}
+
+function hasRawOrMixedThinking(partial: AssistantMessage, contentIndex: number): boolean {
+	const content = partial.content[contentIndex];
+	return content?.type === "thinking" && (content.provenance === "raw" || content.provenance === "mixed");
+}
+
+/** Responses-family reasoning is untrusted until output_item.done assigns provenance. */
+function hasUnfinalizedResponsesThinking(partial: AssistantMessage, contentIndex: number): boolean {
+	const content = partial.content[contentIndex];
+	return content?.type !== "thinking" || (isResponsesFamilyApi(partial.api) && content.provenance === undefined);
+}
+
 function encodeContentBlocks(message: AssistantMessage): Record<string, unknown>[] {
 	const blocks: Record<string, unknown>[] = [];
 	for (const c of message.content) {
@@ -425,8 +481,11 @@ function encodeContentBlocks(message: AssistantMessage): Record<string, unknown>
 				blocks.push({ type: "text", text: c.text });
 				break;
 			case "thinking": {
-				const b: Record<string, unknown> = { type: "thinking", thinking: c.thinking };
-				if (c.thinkingSignature) b.signature = c.thinkingSignature;
+				const thinking = safeThinkingText(c, message.api);
+				if (thinking === undefined) break;
+				const b: Record<string, unknown> = { type: "thinking", thinking };
+				const sig = safeThinkingSignature(c.thinkingSignature);
+				if (sig) b.signature = sig;
 				blocks.push(b);
 				break;
 			}
@@ -495,6 +554,12 @@ export function encodeStream(
 			const messageId = newMessageId();
 			let started = false;
 			const open = new Map<number, OpenBlock>();
+			// contentIndexes that already streamed a reasoning summary delta, so a
+			// final-only reasoning_summary_end does not duplicate streamed summary text.
+			const summaryDeltaSeen = new Set<number>();
+			// Responses assigns reasoning provenance only at output_item.done. Keep its
+			// pre-classification bytes out of this public compatibility stream.
+			const pendingThinkingDeltas = new Map<number, string[]>();
 
 			const ensureStart = (partial: AssistantMessage) => {
 				if (started) return;
@@ -524,6 +589,30 @@ export function encodeStream(
 				open.delete(index);
 			};
 
+			const openThinking = (partial: AssistantMessage, index: number) => {
+				if (open.has(index)) return;
+				ensureStart(partial);
+				open.set(index, { index, kind: "thinking" });
+				controller.enqueue(
+					sseFrame("content_block_start", {
+						type: "content_block_start",
+						index,
+						content_block: { type: "thinking", thinking: "" },
+					}),
+				);
+			};
+
+			const writeThinkingDelta = (index: number, thinking: string) => {
+				if (thinking.length === 0) return;
+				controller.enqueue(
+					sseFrame("content_block_delta", {
+						type: "content_block_delta",
+						index,
+						delta: { type: "thinking_delta", thinking },
+					}),
+				);
+			};
+
 			try {
 				for await (const ev of events) {
 					switch (ev.type) {
@@ -555,18 +644,73 @@ export function encodeStream(
 							closeBlock(ev.contentIndex);
 							break;
 						case "thinking_start": {
-							ensureStart(ev.partial);
-							open.set(ev.contentIndex, { index: ev.contentIndex, kind: "thinking" });
-							controller.enqueue(
-								sseFrame("content_block_start", {
-									type: "content_block_start",
-									index: ev.contentIndex,
-									content_block: { type: "thinking", thinking: "" },
-								}),
-							);
+							if (hasRawOrMixedThinking(ev.partial, ev.contentIndex)) break;
+							if (hasUnfinalizedResponsesThinking(ev.partial, ev.contentIndex)) {
+								pendingThinkingDeltas.set(ev.contentIndex, []);
+								break;
+							}
+							openThinking(ev.partial, ev.contentIndex);
+							break;
+						}
+						case "thinking_delta": {
+							if (hasRawOrMixedThinking(ev.partial, ev.contentIndex)) break;
+							if (hasUnfinalizedResponsesThinking(ev.partial, ev.contentIndex)) {
+								const deltas = pendingThinkingDeltas.get(ev.contentIndex) ?? [];
+								deltas.push(ev.delta);
+								pendingThinkingDeltas.set(ev.contentIndex, deltas);
+								break;
+							}
+							writeThinkingDelta(ev.contentIndex, ev.delta);
+							break;
+						}
+						case "thinking_end": {
+							const unfinalized = hasUnfinalizedResponsesThinking(ev.partial, ev.contentIndex);
+							const rawOrMixed = hasRawOrMixedThinking(ev.partial, ev.contentIndex);
+							const pending = pendingThinkingDeltas.get(ev.contentIndex);
+							pendingThinkingDeltas.delete(ev.contentIndex);
+							if (rawOrMixed || unfinalized) {
+								closeBlock(ev.contentIndex);
+								break;
+							}
+							if (pending) {
+								openThinking(ev.partial, ev.contentIndex);
+								for (const delta of pending) writeThinkingDelta(ev.contentIndex, delta);
+							}
+							const c = ev.partial.content[ev.contentIndex];
+							const sig = c?.type === "thinking" ? safeThinkingSignature(c.thinkingSignature) : undefined;
+							if (sig) {
+								controller.enqueue(
+									sseFrame("content_block_delta", {
+										type: "content_block_delta",
+										index: ev.contentIndex,
+										delta: { type: "signature_delta", signature: sig },
+									}),
+								);
+							}
+							closeBlock(ev.contentIndex);
+							break;
+						}
+						case "reasoning_summary_start": {
+							// Provider-displayable summary reasoning surfaces as this format's
+							// native thinking channel. Open the thinking block if a thinking_start
+							// did not already (summary-only streams emit no thinking_start).
+							if (!open.has(ev.contentIndex)) {
+								ensureStart(ev.partial);
+								open.set(ev.contentIndex, { index: ev.contentIndex, kind: "thinking" });
+								controller.enqueue(
+									sseFrame("content_block_start", {
+										type: "content_block_start",
+										index: ev.contentIndex,
+										content_block: { type: "thinking", thinking: "" },
+									}),
+								);
+							}
 							break;
 						}
-						case "thinking_delta":
+						case "reasoning_summary_delta":
+							// Only a non-whitespace delta counts as a delivered summary; a bare
+							// separator ("\n\n") must not suppress a later final-only end content.
+							if (ev.delta.trim().length > 0) summaryDeltaSeen.add(ev.contentIndex);
 							controller.enqueue(
 								sseFrame("content_block_delta", {
 									type: "content_block_delta",
@@ -575,18 +719,31 @@ export function encodeStream(
 								}),
 							);
 							break;
-						case "thinking_end": {
-							const c = ev.partial.content[ev.contentIndex];
-							if (c?.type === "thinking" && c.thinkingSignature) {
+						case "reasoning_summary_end": {
+							// Final-only summary: text arrives only on the end event with no prior
+							// deltas. Ensure the thinking block is open, then surface the content as
+							// a thinking_delta (skip when deltas already streamed to avoid dup). The
+							// thinking block is closed by the subsequent thinking_end.
+							if (ev.content.length > 0 && !summaryDeltaSeen.has(ev.contentIndex)) {
+								if (!open.has(ev.contentIndex)) {
+									ensureStart(ev.partial);
+									open.set(ev.contentIndex, { index: ev.contentIndex, kind: "thinking" });
+									controller.enqueue(
+										sseFrame("content_block_start", {
+											type: "content_block_start",
+											index: ev.contentIndex,
+											content_block: { type: "thinking", thinking: "" },
+										}),
+									);
+								}
 								controller.enqueue(
 									sseFrame("content_block_delta", {
 										type: "content_block_delta",
 										index: ev.contentIndex,
-										delta: { type: "signature_delta", signature: c.thinkingSignature },
+										delta: { type: "thinking_delta", thinking: ev.content },
 									}),
 								);
 							}
-							closeBlock(ev.contentIndex);
 							break;
 						}
 						case "toolcall_start": {
@@ -621,6 +778,7 @@ export function encodeStream(
 							break;
 						case "done": {
 							for (const idx of [...open.keys()]) closeBlock(idx);
+							pendingThinkingDeltas.clear();
 							controller.enqueue(
 								sseFrame("message_delta", {
 									type: "message_delta",
@@ -636,6 +794,7 @@ export function encodeStream(
 						}
 						case "error": {
 							const msg = ev.error.errorMessage ?? "stream error";
+							pendingThinkingDeltas.clear();
 							controller.enqueue(
 								sseFrame("error", { type: "error", error: { type: "api_error", message: msg } }),
 							);
@@ -645,10 +804,12 @@ export function encodeStream(
 					}
 				}
 				// stream ended without explicit done; close gracefully
+				pendingThinkingDeltas.clear();
 				for (const idx of [...open.keys()]) closeBlock(idx);
 				controller.enqueue(sseFrame("message_stop", { type: "message_stop" }));
 				controller.close();
 			} catch (err) {
+				pendingThinkingDeltas.clear();
 				controller.enqueue(
 					sseFrame("error", {
 						type: "error",