@gajae-code/ai 0.8.2 → 0.9.1

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [0.9.1] - 2026-07-08
+
+### Fixed
+
+- Unified the Cursor client version used across provider requests and discovery.
+- Detected ZAI weekly limit exhaustion as a structured rate-limit condition.
+- Pointed Sakana Fugu OAuth/login guidance at the Sakana platform console and documented the `fish_` key prefix expectation.
+
+## [0.9.0] - 2026-07-07
+
+### Fixed
+
+- Capped OpenCode Go Kimi reasoning efforts that the Go chat-completions endpoint rejects (`kimi-k2.5:minimal` → `low`, `kimi-k2.7-code:xhigh|max` → `high`) and degraded forced `tool_choice` for those models so Kimi Go sessions and title-generation turns no longer fail with generic upstream 400s.
+
 ## [0.8.2] - 2026-07-06
 
 ### Fixed

package/dist/types/providers/cursor/client-version.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The Cursor client version reported to api2.cursor.sh.
+ *
+ * Every call against the Cursor backend must send the same
+ * x-cursor-client-version: the backend gates features and minimum versions on
+ * it, so a drift between the agent Run path and model discovery makes one of
+ * them fail while the other keeps working. Keep this as the single source of
+ * truth for the header value.
+ */
+export declare const CURSOR_CLIENT_VERSION = "cli-2026.02.13-41ac335";

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

@@ -1,7 +1,8 @@
 import { type JsonValue } from "@bufbuild/protobuf";
 import type { CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, StreamFunction, StreamOptions, ToolResultMessage } from "../types";
+import { CURSOR_CLIENT_VERSION } from "./cursor/client-version";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
-export declare const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+export { CURSOR_CLIENT_VERSION };
 /** Drop all cached state + blob bytes for a conversation (F15 bound + session-teardown hook). */
 export declare function disposeCursorConversation(conversationId: string): void;
 export interface CursorOptions extends StreamOptions {

package/dist/types/providers/openai-bounded-rate-limits.d.ts

@@ -0,0 +1,3 @@
+import type { FetchImpl } from "../types";
+export declare function isOpenAIUsageExhaustionResponse(bodyText: string, retryAfterMs: number | undefined, retryDelayCapMs: number): boolean;
+export declare function wrapOpenAIFetchForBoundedRateLimits(baseFetch: FetchImpl, maxRetryDelayMs: number | undefined): FetchImpl;

package/package.json

@@ -1,13 +1,10 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.8.2",
+	"version": "0.9.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
-	"author": "Yeachan-Heo",
-	"contributors": [
-		"Mario Zechner"
-	],
+	"author": "Yeachan-Heo and Gajae Code Contributors",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -43,7 +40,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/utils": "0.8.2",
+		"@gajae-code/utils": "0.9.1",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

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

@@ -35,6 +35,7 @@ import {
 	markToolChoiceIncapability,
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
+import { wrapOpenAIFetchForBoundedRateLimits } from "./openai-bounded-rate-limits";
 import { normalizeOpenAIResponsesPromptCacheKey, supportsDeveloperRole } from "./openai-responses";
 import {
 	appendResponsesToolResultMessages,
@@ -272,7 +273,7 @@ function createClient(model: Model<"azure-openai-responses">, apiKey: string, op
 
 	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
 
-	const baseFetch = options?.fetch ?? fetch;
+	const baseFetch = wrapOpenAIFetchForBoundedRateLimits(options?.fetch ?? fetch, options?.maxRetryDelayMs);
 	const onSseEvent = options?.onSseEvent;
 	return new AzureOpenAI({
 		apiKey,

package/src/providers/cursor/client-version.ts

@@ -0,0 +1,10 @@
+/**
+ * The Cursor client version reported to api2.cursor.sh.
+ *
+ * Every call against the Cursor backend must send the same
+ * x-cursor-client-version: the backend gates features and minimum versions on
+ * it, so a drift between the agent Run path and model discovery makes one of
+ * them fail while the other keeps working. Keep this as the single source of
+ * truth for the header value.
+ */
+export const CURSOR_CLIENT_VERSION = "cli-2026.02.13-41ac335";

package/src/providers/cursor.ts

@@ -31,6 +31,7 @@ import { parseStreamingJson } from "../utils/json-parse";
 import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
 import { flattenToolRootCombinators, toolWireSchema } from "../utils/schema";
 import { COMPOSER_EDIT_DISCIPLINE_PROMPT, isComposerHarnessModel } from "./composer-discipline";
+import { CURSOR_CLIENT_VERSION } from "./cursor/client-version";
 import type { McpToolDefinition } from "./cursor/gen/agent_pb";
 import {
 	AgentClientMessageSchema,
@@ -131,7 +132,7 @@ import {
 } from "./cursor/gen/agent_pb";
 
 export const CURSOR_API_URL = "https://api2.cursor.sh";
-export const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+export { CURSOR_CLIENT_VERSION };
 
 const conversationStateCache = new Map<string, ConversationStateStructure>();
 const conversationBlobStores = new Map<string, Map<string, Uint8Array>>();

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-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-completions.ts

@@ -72,6 +72,7 @@ import {
 	hasCopilotVisionInput,
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
+import { wrapOpenAIFetchForBoundedRateLimits } from "./openai-bounded-rate-limits";
 import { detectOpenAICompat, type ResolvedOpenAICompat, resolveOpenAICompat } from "./openai-completions-compat";
 import {
 	applyOpenAIRequestTransformBody,
@@ -454,6 +455,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				options?.authCredentialType,
 				options?.requestMaxRetries,
 				options?.sessionId,
+				options?.maxRetryDelayMs,
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			getCapturedErrorResponse = captureErrorResponse;
@@ -956,6 +958,7 @@ async function createClient(
 	authCredentialType?: OpenAICompletionsOptions["authCredentialType"],
 	requestMaxRetries?: number,
 	sessionId?: string,
+	maxRetryDelayMs?: number,
 ): Promise<{
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
@@ -1063,8 +1066,9 @@ async function createClient(
 		},
 		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
 	);
+	const boundedFetch = wrapOpenAIFetchForBoundedRateLimits(wrappedFetch, maxRetryDelayMs);
 	const transformedFetch = wrapFetchForOpenAIRequestTransform(
-		wrappedFetch,
+		boundedFetch,
 		model.requestTransform,
 		`Gajae-Code/${packageJson.version}`,
 	);

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,
 		`Gajae-Code/${packageJson.version}`,
 	);

package/src/rate-limit-utils.ts

@@ -13,7 +13,7 @@ export type RateLimitReason =
 const QUOTA_EXHAUSTED_BACKOFF_MS = 30 * 60 * 1000; // 30 min
 const RATE_LIMIT_EXCEEDED_BACKOFF_MS = 30 * 1000; // 30s
 const MODEL_CAPACITY_BASE_MS = 45 * 1000; // 45s base
-const MODEL_CAPACITY_JITTER_MS = 30 * 1000; // ±15s
+const MODEL_CAPACITY_JITTER_MS = 30 * 1000; // uniform +0–30s above base → 45–75s total
 const SERVER_ERROR_BACKOFF_MS = 20 * 1000; // 20s
 
 /**
@@ -93,8 +93,10 @@ export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
 }
 
 /** Detect usage/quota limit errors in error messages (persistent, requires credential switch). */
+// ZAI reports durable token exhaustion as "[1310][Weekly/Monthly Limit Exhausted...]".
+// Keep this explicit so generic "rate limit exhausted, retry..." throttles remain retryable.
 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|out_of_credits|request would exceed your account.?s rate limit|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|weekly\/monthly\s+limit\s+exhausted|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/discovery/cursor.ts

@@ -2,11 +2,11 @@ import * as http2 from "node:http2";
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import * as z from "zod/v4";
 import { getBundledModels } from "../../models";
+import { CURSOR_CLIENT_VERSION } from "../../providers/cursor/client-version";
 import { GetUsableModelsRequestSchema, GetUsableModelsResponseSchema } from "../../providers/cursor/gen/agent_pb";
 import type { Model } from "../../types";
 
 const CURSOR_DEFAULT_BASE_URL = "https://api2.cursor.sh";
-const CURSOR_DEFAULT_CLIENT_VERSION = "cli-2026.02.13-41ac335";
 const CURSOR_GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
 
 const DEFAULT_CONTEXT_WINDOW = 200_000;
@@ -91,7 +91,7 @@ function buildRequestHeaders(options: CursorModelDiscoveryOptions): Record<strin
 		te: "trailers",
 		authorization: `Bearer ${options.apiKey}`,
 		"x-ghost-mode": "true",
-		"x-cursor-client-version": options.clientVersion ?? CURSOR_DEFAULT_CLIENT_VERSION,
+		"x-cursor-client-version": options.clientVersion ?? CURSOR_CLIENT_VERSION,
 		"x-cursor-client-type": "cli",
 	};
 }

package/src/utils/oauth/fugu.ts

@@ -3,10 +3,10 @@ import { createApiKeyLogin } from "./api-key-login";
 
 export const loginFugu = createApiKeyLogin({
 	providerLabel: "Sakana Fugu",
-	authUrl: "https://fugu.sakana.ai/",
+	authUrl: "https://console.sakana.ai/api-keys",
 	instructions: "Create or copy your Sakana Fugu API key",
 	promptMessage: "Paste your Sakana Fugu API key",
-	placeholder: "fugu_...",
+	placeholder: "fish_...",
 	validation: {
 		kind: "models-endpoint",
 		provider: "Sakana Fugu",

package/src/utils.ts

@@ -215,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);
 	}
@@ -231,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;