@sayknow-cli/ai 0.3.6 → 0.3.8

package/src/providers/openai-bounded-rate-limits.ts

@@ -0,0 +1,57 @@
+import type { FetchImpl } from "../types";
+import { getRetryAfterMsFromHeaders } from "../utils/retry-after";
+
+const OPENAI_RETRY_DELAY_CAP_MS = 60_000;
+
+// Mirror of `wrapAnthropicFetchForBoundedRateLimits`: OpenAI-compatible providers
+// (e.g. opencode-go) return HTTP 429 for *permanent* usage/quota exhaustion — a
+// monthly-cap reset that can be days away. The OpenAI SDK treats 429 as transient
+// and retries up to `maxRetries`, honoring an out-of-range `Retry-After`; the
+// `create()` call then hangs before the error can surface to the agent loop, so
+// no assistant error is produced and the session-level retry/fallback never runs.
+// Detect exhaustion and set `x-should-retry: false` so the SDK gives up at once
+// and the session retry layer applies its own fail-fast (retry-after > maxDelayMs).
+//
+// Shared by every adapter that drives a raw OpenAI SDK client — openai-completions,
+// openai-responses, and azure-openai-responses. Adapters that route through
+// `fetchWithRetry` (codex, bedrock, ollama, gemini-cli) already bound 429 retries
+// themselves and do not need this wrapper.
+export function isOpenAIUsageExhaustionResponse(
+	bodyText: string,
+	retryAfterMs: number | undefined,
+	retryDelayCapMs: number,
+): boolean {
+	if (retryAfterMs !== undefined && retryAfterMs > retryDelayCapMs) return true;
+	return /monthly usage limit|usage limit reached|usage_limit_reached|out_of_credits|insufficient_quota|quota[ _]?exceeded/i.test(
+		bodyText,
+	);
+}
+
+export function wrapOpenAIFetchForBoundedRateLimits(
+	baseFetch: FetchImpl,
+	maxRetryDelayMs: number | undefined,
+): FetchImpl {
+	const retryDelayCapMs = maxRetryDelayMs ?? OPENAI_RETRY_DELAY_CAP_MS;
+	return Object.assign(
+		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+			const response = await baseFetch(input, init);
+			if (response.status !== 429 || retryDelayCapMs === 0) return response;
+
+			const headers = new Headers(response.headers);
+			const retryAfterMs = getRetryAfterMsFromHeaders(headers);
+			const bodyText = await response
+				.clone()
+				.text()
+				.catch(() => "");
+			if (!isOpenAIUsageExhaustionResponse(bodyText, retryAfterMs, retryDelayCapMs)) return response;
+
+			headers.set("x-should-retry", "false");
+			return new Response(bodyText, {
+				status: response.status,
+				statusText: response.statusText,
+				headers,
+			});
+		},
+		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
+	);
+}

package/src/providers/openai-chat-server.ts

@@ -19,6 +19,7 @@ import type {
 	ToolResultMessage,
 	TSchema,
 } from "../types";
+import { sanitizeJsonStrings } from "../utils";
 import {
 	type OpenAIChatContentPart,
 	type OpenAIChatMessage,
@@ -453,9 +454,9 @@ function isOnlyRaw(args: Record<string, unknown>): boolean {
 
 function stringifyArgs(args: Record<string, unknown>): string {
 	// `__raw` is our fallback marker for un-parseable inbound args; preserve it verbatim on the way out.
-	if (typeof args.__raw === "string" && isOnlyRaw(args)) return args.__raw;
+	if (typeof args.__raw === "string" && isOnlyRaw(args)) return args.__raw.toWellFormed();
 	try {
-		return JSON.stringify(args);
+		return JSON.stringify(sanitizeJsonStrings(args));
 	} catch {
 		return "{}";
 	}

package/src/providers/openai-codex/request-transformer.ts

@@ -1,6 +1,7 @@
 import type { Effort } from "../../model-thinking";
 import { requireSupportedEffort } from "../../model-thinking";
 import type { Api, Model } from "../../types";
+import { sanitizeJsonStrings } from "../../utils";
 
 export interface ReasoningConfig {
 	effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
@@ -109,6 +110,10 @@ function normalizeInputTextPartFields(input: InputItem[] | undefined): InputItem
 		}
 		if (normalizedItem.type === "message") {
 			normalizedItem.content = normalizeTextPartFields(normalizedItem.content, `input[${itemIndex}].content`);
+		} else if (normalizedItem.type === "function_call" && "arguments" in itemRecord) {
+			itemRecord.arguments = sanitizeJsonStrings(itemRecord.arguments);
+		} else if (normalizedItem.type === "custom_tool_call" && typeof itemRecord.input === "string") {
+			itemRecord.input = itemRecord.input.toWellFormed();
 		}
 		return normalizedItem;
 	});

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

@@ -104,6 +104,10 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		baseUrl.includes("opencode.ai");
 	const isOpenCodeProvider = provider === "opencode-go" || provider === "opencode-zen";
 	const isOpenCodeGoReasoning = provider === "opencode-go" && Boolean(model.reasoning);
+	const isOpenCodeGoKimiReasoning = provider === "opencode-go" && isKimiModel && Boolean(model.reasoning);
+	const isOpenCodeGoKimi25Reasoning = isOpenCodeGoKimiReasoning && model.id === "kimi-k2.5";
+	const isOpenCodeGoKimi27CodeReasoning = isOpenCodeGoKimiReasoning && model.id === "kimi-k2.7-code";
+	const needsOpenCodeGoKimiEffortMap = isOpenCodeGoKimi25Reasoning || isOpenCodeGoKimi27CodeReasoning;
 
 	const useMaxTokens =
 		provider === "mistral" ||
@@ -170,22 +174,31 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 					xhigh: "default",
 					max: "default",
 				} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
-			: isDeepseekFamily && model.reasoning
+			: needsOpenCodeGoKimiEffortMap
 				? ({
-						minimal: "high",
-						low: "high",
-						medium: "high",
-						high: "high",
-						xhigh: "max",
-						max: "max",
+						// Live Go probes (2026-07-06) showed model-specific effort gaps:
+						// kimi-k2.5 rejects "minimal", while kimi-k2.7-code rejects
+						// OpenAI-style "xhigh" and "max"; all other Kimi efforts tested
+						// successfully and should pass through unchanged.
+						...(isOpenCodeGoKimi25Reasoning ? { minimal: "low" } : {}),
+						...(isOpenCodeGoKimi27CodeReasoning ? { xhigh: "high", max: "high" } : {}),
 					} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
-				: isFireworks
+				: isDeepseekFamily && model.reasoning
 					? ({
-							// Fireworks' OpenAI-compatible endpoint rejects OpenAI's
-							// `minimal` literal but accepts `none` for the lowest setting.
-							minimal: "none",
+							minimal: "high",
+							low: "high",
+							medium: "high",
+							high: "high",
+							xhigh: "max",
+							max: "max",
 						} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
-					: {};
+					: isFireworks
+						? ({
+								// Fireworks' OpenAI-compatible endpoint rejects OpenAI's
+								// `minimal` literal but accepts `none` for the lowest setting.
+								minimal: "none",
+							} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+						: {};
 
 	return {
 		supportsStore: !isNonStandard,
@@ -198,7 +211,7 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel || isOpenCodeGoReasoning,
 		disableReasoningOnToolChoice: isDeepseekFamily && Boolean(model.reasoning) && !isOpenRouter,
 		supportsToolChoice: !isDirectDeepseekReasoning,
-		supportsForcedToolChoice: true,
+		supportsForcedToolChoice: !isOpenCodeGoKimiReasoning,
 		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
 		requiresToolResultName: isMistral,
 		requiresAssistantAfterToolResult: false,

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

@@ -22,6 +22,7 @@ import type {
 	Tool,
 	ToolCall,
 } from "../types";
+import { sanitizeJsonStrings } from "../utils";
 import {
 	type OpenAIResponsesFunctionCallItem,
 	type OpenAIResponsesFunctionCallOutputItem,
@@ -612,7 +613,8 @@ function buildOutputItems(message: AssistantMessage): OutputItem[] {
 		} else if (part.type === "toolCall") {
 			flushMessage();
 			if (part.customWireName) {
-				const rawInput = typeof part.arguments?.input === "string" ? (part.arguments.input as string) : "";
+				const rawInput =
+					typeof part.arguments?.input === "string" ? (part.arguments.input as string).toWellFormed() : "";
 				out.push({
 					type: "custom_tool_call",
 					id: part.thoughtSignature ?? makeCustomCallId(),
@@ -627,7 +629,7 @@ function buildOutputItems(message: AssistantMessage): OutputItem[] {
 					id: part.thoughtSignature ?? makeFuncCallId(),
 					call_id: part.id,
 					name: part.name,
-					arguments: JSON.stringify(part.arguments ?? {}),
+					arguments: JSON.stringify(sanitizeJsonStrings(part.arguments ?? {})),
 					status: "completed",
 				});
 			}
@@ -1085,7 +1087,8 @@ export function encodeStream(
 							} else {
 								// Standard JSON tool: arguments object on the skc side, the
 								// wire wants the JSON string the model emitted (= streamed deltas).
-								const argsJson = cur.argsText || JSON.stringify(tc.arguments ?? {});
+								const argsJson =
+									cur.argsText.toWellFormed() || JSON.stringify(sanitizeJsonStrings(tc.arguments ?? {}));
 								cur.argsText = argsJson;
 								emit("response.function_call_arguments.done", {
 									item_id: cur.itemId,

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

@@ -28,7 +28,7 @@ import {
 	type ToolCall,
 	type ToolResultMessage,
 } from "../types";
-import { normalizeResponsesToolCallId } from "../utils";
+import { normalizeResponsesToolCallId, sanitizeJsonStrings } from "../utils";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER, partitionVisionContent } from "./vision-guard";
@@ -275,7 +275,7 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 		}
 		knownCallIds.add(normalized.callId);
 		if (block.customWireName) {
-			const rawInput = typeof block.arguments?.input === "string" ? block.arguments.input : "";
+			const rawInput = typeof block.arguments?.input === "string" ? block.arguments.input.toWellFormed() : "";
 			customCallIds?.add(normalized.callId);
 			outputItems.push({
 				type: "custom_tool_call",
@@ -291,7 +291,7 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 			id: itemId,
 			call_id: normalized.callId,
 			name: block.name,
-			arguments: JSON.stringify(block.arguments),
+			arguments: JSON.stringify(sanitizeJsonStrings(block.arguments ?? {})),
 		});
 	}
 

package/src/providers/openai-responses.ts

@@ -71,6 +71,7 @@ import {
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
 import { compactGrammarDefinition } from "./grammar";
+import { wrapOpenAIFetchForBoundedRateLimits } from "./openai-bounded-rate-limits";
 import {
 	applyOpenAIRequestTransformBody,
 	applyOpenAIRequestTransformHeaders,
@@ -274,6 +275,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				options?.fetch,
 				options?.authCredentialType,
 				options?.requestMaxRetries,
+				options?.maxRetryDelayMs,
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			const providerSessionState = getOpenAIResponsesProviderSessionState(model, options?.providerSessionState);
@@ -400,6 +402,7 @@ function createClient(
 	fetchOverride?: FetchImpl,
 	authCredentialType?: OpenAIResponsesOptions["authCredentialType"],
 	requestMaxRetries?: number,
+	maxRetryDelayMs?: number,
 ): {
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
@@ -446,8 +449,9 @@ function createClient(
 		headers["x-client-request-id"] ??= sessionId;
 	}
 	const baseFetch = fetchOverride ?? fetch;
+	const boundedFetch = wrapOpenAIFetchForBoundedRateLimits(baseFetch, maxRetryDelayMs);
 	const transformedFetch = wrapFetchForOpenAIRequestTransform(
-		baseFetch,
+		boundedFetch,
 		model.requestTransform,
 		`Sayknow-CLI/${packageJson.version}`,
 	);

package/src/rate-limit-utils.ts

@@ -36,6 +36,14 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		return "MODEL_CAPACITY_EXHAUSTED";
 	}
 
+	if (
+		lower.includes("out_of_credits") ||
+		lower.includes("request would exceed your account's rate limit") ||
+		lower.includes("request would exceed your accounts rate limit")
+	) {
+		return "QUOTA_EXHAUSTED";
+	}
+
 	if (
 		lower.includes("per minute") ||
 		lower.includes("rate limit") ||
@@ -86,8 +94,7 @@ export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
 
 /** Detect usage/quota limit errors in error messages (persistent, requires credential switch). */
 const USAGE_LIMIT_PATTERN =
-	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|model.?limit|model_limit_reached|message.?limit|message_limit_reached|limit for this model|quota.?exceeded|resource has been exhausted[^\n]*(?:quota|limit)/i;
-
+	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|model.?limit|model_limit_reached|message.?limit|message_limit_reached|limit for this model|quota.?exceeded|out_of_credits|request would exceed your account.?s rate limit|resource has been exhausted[^\n]*(?:quota|limit)/i;
 export function isUsageLimitError(errorMessage: string): boolean {
 	return USAGE_LIMIT_PATTERN.test(errorMessage);
 }

package/src/utils.ts

@@ -11,6 +11,34 @@ export function normalizeSystemPrompts(systemPrompt: readonly string[] | string
 	return prompts.map(prompt => prompt.toWellFormed()).filter(prompt => prompt.length > 0);
 }
 
+export function sanitizeJsonStrings(value: unknown): unknown {
+	return sanitizeJsonStringsInner(value, new WeakMap<object, unknown>());
+}
+
+function sanitizeJsonStringsInner(value: unknown, seen: WeakMap<object, unknown>): unknown {
+	if (typeof value === "string") return value.toWellFormed();
+	if (!value || typeof value !== "object") return value;
+
+	const cached = seen.get(value);
+	if (cached !== undefined) return cached;
+
+	if (Array.isArray(value)) {
+		const sanitized: unknown[] = [];
+		seen.set(value, sanitized);
+		for (const item of value) {
+			sanitized.push(sanitizeJsonStringsInner(item, seen));
+		}
+		return sanitized;
+	}
+
+	const sanitized: Record<string, unknown> = {};
+	seen.set(value, sanitized);
+	for (const [key, nestedValue] of Object.entries(value)) {
+		sanitized[key.toWellFormed()] = sanitizeJsonStringsInner(nestedValue, seen);
+	}
+	return sanitized;
+}
+
 export function toNumber(value: unknown): number | undefined {
 	if (typeof value === "number" && Number.isFinite(value)) return value;
 	if (typeof value === "string" && value.trim()) {
@@ -187,7 +215,11 @@ function sanitizeOpenAIResponsesHistoryItemForReplay(
 	// providerPayload stores raw output items; replay strips fields that are output-only.
 	const { id: _id, ...itemWithoutId } = item;
 	const sanitizedItem =
-		item.type === "computer_call" ? sanitizeComputerCallForResponsesInput(itemWithoutId) : itemWithoutId;
+		item.type === "computer_call"
+			? sanitizeComputerCallForResponsesInput(itemWithoutId)
+			: item.type === "image_generation_call"
+				? sanitizeImageGenerationCallForResponsesInput(itemWithoutId)
+				: itemWithoutId;
 	if (typeof item.call_id === "string") {
 		sanitizedItem.call_id = normalizeReplayedResponsesHistoryCallId(item.call_id, normalizedCallIds);
 	}
@@ -203,6 +235,22 @@ function sanitizeComputerCallForResponsesInput(item: Record<string, unknown>): R
 	return inputSafeItem;
 }
 
+function sanitizeImageGenerationCallForResponsesInput(item: Record<string, unknown>): Record<string, unknown> {
+	// Image generation output items include request-time knobs that are not part of
+	// the Responses input replay schema. Replaying them verbatim makes OpenAI-compatible
+	// endpoints reject the next turn, e.g. `Unknown parameter: input[n].action`.
+	const {
+		action: _action,
+		background: _background,
+		output_format: _outputFormat,
+		quality: _quality,
+		revised_prompt: _revisedPrompt,
+		size: _size,
+		...inputSafeItem
+	} = item;
+	return inputSafeItem;
+}
+
 function normalizeReplayedResponsesHistoryCallId(value: string, normalizedValues: Map<string, string>): string {
 	const normalized = normalizedValues.get(value);
 	if (normalized) return normalized;