@gajae-code/ai 0.16.7 → 0.17.1

package/src/model-manager.ts

@@ -4,6 +4,7 @@ import { insertModelCacheIfAbsent, readModelCache, updateModelCacheIfUnchanged,
 import { isRetiredModel, isRetiredModelKey } from "./model-retirements";
 import { applyGeneratedModelPolicies, enrichModelThinking } from "./model-thinking";
 import { type GeneratedProvider, getBundledModels } from "./models";
+import { UNK_CONTEXT_WINDOW, UNK_MAX_TOKENS } from "./provider-models/openai-compat";
 import type { Api, Model, Provider } from "./types";
 import { isSafeCatalogModelId } from "./utils/discovery/openai-compatible";
 
@@ -552,6 +553,20 @@ function fingerprintStatic<TApi extends Api>(models: readonly Model<TApi>[]): st
 
 function mergeDynamicModel<TApi extends Api>(existingModel: Model<TApi>, dynamicModel: Model<TApi>): Model<TApi> {
 	const supportsImage = existingModel.input.includes("image") || dynamicModel.input.includes("image");
+	// Before this exact Go model was curated, ID-only discovery cached the
+	// non-reasoning Completions defaults. A fresh authoritative cache can skip
+	// discovery after an upgrade, so recover its limits from reviewed static
+	// Responses metadata here. Do not reinterpret individual numeric limits or
+	// apply this correction to reviewed discovery rows or other model IDs.
+	const hasPreReviewMuseLimits =
+		existingModel.provider === "opencode-go" &&
+		existingModel.id === "muse-spark-1.3-contributor" &&
+		existingModel.api === "openai-responses" &&
+		existingModel.reasoning &&
+		dynamicModel.api === "openai-completions" &&
+		!dynamicModel.reasoning &&
+		dynamicModel.contextWindow === UNK_CONTEXT_WINDOW &&
+		dynamicModel.maxTokens === UNK_MAX_TOKENS;
 	// The static catalog is authoritative for transport: `api` (and its
 	// api-specific `baseUrl`). Dynamic discovery enumerates ids via a single
 	// hardcoded api (e.g. fetchOpenAICompatibleModels always tags
@@ -579,8 +594,12 @@ function mergeDynamicModel<TApi extends Api>(existingModel: Model<TApi>, dynamic
 			cacheRead: preferDiscoveryCost(dynamicModel.cost.cacheRead, existingModel.cost.cacheRead),
 			cacheWrite: preferDiscoveryCost(dynamicModel.cost.cacheWrite, existingModel.cost.cacheWrite),
 		},
-		contextWindow: preferDiscoveryLimit(dynamicModel.contextWindow, existingModel.contextWindow),
-		maxTokens: preferDiscoveryLimit(dynamicModel.maxTokens, existingModel.maxTokens),
+		contextWindow: hasPreReviewMuseLimits
+			? existingModel.contextWindow
+			: preferDiscoveryLimit(dynamicModel.contextWindow, existingModel.contextWindow),
+		maxTokens: hasPreReviewMuseLimits
+			? existingModel.maxTokens
+			: preferDiscoveryLimit(dynamicModel.maxTokens, existingModel.maxTokens),
 		headers: dynamicModel.headers ? { ...existingModel.headers, ...dynamicModel.headers } : existingModel.headers,
 		compat: dynamicModel.compat ?? existingModel.compat,
 		contextPromotionTarget: dynamicModel.contextPromotionTarget ?? existingModel.contextPromotionTarget,

package/src/models.d.ts

@@ -18,4 +18,18 @@ export declare function calculateCost<TApi extends Api>(model: Model<TApi>, usag
  * Returns false if either model is null or undefined.
  */
 export declare function modelsAreEqual<TApi extends Api>(a: Model<TApi> | null | undefined, b: Model<TApi> | null | undefined): boolean;
+/**
+ * APIs backed by agent-level providers — currently Devin over ACP. An
+ * agent-level provider runs its own agent loop and owns the conversation
+ * history, so it refuses GJC maintenance calls (`maintenanceCall` requests such
+ * as compaction summaries, handoff generation, and branch summaries) instead of
+ * spending billed agent quota on work it cannot answer as a text model.
+ */
+export declare const AGENT_LEVEL_PROVIDER_APIS: ReadonlySet<Api>;
+/**
+ * Whether a model's provider can serve GJC maintenance calls at all. When this
+ * is false for every model a maintenance action can reach, the call can only
+ * report a guaranteed refusal, so callers should skip rather than surface it.
+ */
+export declare function modelSupportsMaintenanceCalls(model: Model<Api>): boolean;
 export {};

package/src/models.json

@@ -64677,6 +64677,52 @@
 			"provider": "openai",
 			"baseUrl": ""
 		},
+		"gpt-image-2.5-flare": {
+			"id": "gpt-image-2.5-flare",
+			"name": "GPT Image 2.5 Flare",
+			"reasoning": false,
+			"input": [
+				"text"
+			],
+			"output": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 128000,
+			"maxTokens": 16384,
+			"api": "openai-responses",
+			"provider": "openai",
+			"baseUrl": ""
+		},
+		"gpt-image-2.5-sunburst": {
+			"id": "gpt-image-2.5-sunburst",
+			"name": "GPT Image 2.5 Sunburst",
+			"reasoning": false,
+			"input": [
+				"text"
+			],
+			"output": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 128000,
+			"maxTokens": 16384,
+			"api": "openai-responses",
+			"provider": "openai",
+			"baseUrl": ""
+		},
 		"gpt-realtime-2.1": {
 			"id": "gpt-realtime-2.1",
 			"name": "GPT-Realtime-2.1",
@@ -65547,6 +65593,52 @@
 			"api": "openai-codex-responses",
 			"provider": "openai-codex",
 			"baseUrl": ""
+		},
+		"gpt-image-2.5-flare": {
+			"id": "gpt-image-2.5-flare",
+			"name": "GPT Image 2.5 Flare",
+			"reasoning": false,
+			"input": [
+				"text"
+			],
+			"output": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 128000,
+			"maxTokens": 16384,
+			"api": "openai-codex-responses",
+			"provider": "openai-codex",
+			"baseUrl": ""
+		},
+		"gpt-image-2.5-sunburst": {
+			"id": "gpt-image-2.5-sunburst",
+			"name": "GPT Image 2.5 Sunburst",
+			"reasoning": false,
+			"input": [
+				"text"
+			],
+			"output": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 128000,
+			"maxTokens": 16384,
+			"api": "openai-codex-responses",
+			"provider": "openai-codex",
+			"baseUrl": ""
 		}
 	},
 	"opencode": {
@@ -66470,6 +66562,31 @@
 				"maxLevel": "xhigh"
 			}
 		},
+		"muse-spark-1.3-contributor": {
+			"id": "muse-spark-1.3-contributor",
+			"name": "Muse Spark 1.3 Contributor",
+			"api": "openai-responses",
+			"provider": "opencode-go",
+			"baseUrl": "https://opencode.ai/zen/go/v1",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0.1,
+				"output": 0.2,
+				"cacheRead": 0.002,
+				"cacheWrite": 0
+			},
+			"contextWindow": 1048576,
+			"maxTokens": 131072,
+			"thinking": {
+				"mode": "effort",
+				"minLevel": "minimal",
+				"maxLevel": "xhigh"
+			}
+		},
 		"qwen3.8-flash": {
 			"id": "qwen3.8-flash",
 			"name": "Qwen3.8 Flash",

package/src/models.ts

@@ -124,3 +124,21 @@ export function modelsAreEqual<TApi extends Api>(
 	if (!a || !b) return false;
 	return a.id === b.id && a.provider === b.provider;
 }
+
+/**
+ * APIs backed by agent-level providers — currently Devin over ACP. An
+ * agent-level provider runs its own agent loop and owns the conversation
+ * history, so it refuses GJC maintenance calls (`maintenanceCall` requests such
+ * as compaction summaries, handoff generation, and branch summaries) instead of
+ * spending billed agent quota on work it cannot answer as a text model.
+ */
+export const AGENT_LEVEL_PROVIDER_APIS: ReadonlySet<Api> = new Set<Api>(["devin-acp"]);
+
+/**
+ * Whether a model's provider can serve GJC maintenance calls at all. When this
+ * is false for every model a maintenance action can reach, the call can only
+ * report a guaranteed refusal, so callers should skip rather than surface it.
+ */
+export function modelSupportsMaintenanceCalls(model: Model<Api>): boolean {
+	return !AGENT_LEVEL_PROVIDER_APIS.has(model.api);
+}

package/src/provider-models/descriptors.ts

@@ -53,6 +53,7 @@ import {
 } from "./openai-compat";
 import {
 	cursorModelManagerOptions,
+	devinModelManagerOptions,
 	glmZcodeModelManagerOptions,
 	jetbrainsJunieModelManagerOptions,
 	kiroModelManagerOptions,
@@ -364,6 +365,12 @@ export const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[] = [
 		catalog("GLM ZCode (unofficial)", ["GLM_ZCODE_API_KEY"], { oauthProvider: "glm-zcode" }),
 	),
 	descriptor("jetbrains-junie", "claude-sonnet-4-6", config => jetbrainsJunieModelManagerOptions(config)),
+	// `adaptive` is Devin's documented recommended default (docs.devin.ai/cli/adaptive).
+	// Enterprise organizations may disable it; the account's real model list comes from
+	// the ACP session's model config option.
+	descriptor("devin", "adaptive", () => devinModelManagerOptions(), {
+		allowUnauthenticated: true,
+	}),
 	descriptor("github-copilot", "gpt-4o", config => githubCopilotModelManagerOptions(config)),
 	descriptor("google", "gemini-2.5-pro", config => googleModelManagerOptions(config)),
 	catalogDescriptor(

package/src/provider-models/openai-compat.ts

@@ -2405,6 +2405,7 @@ const OPENCODE_GO_MESSAGES_MODEL_IDS = [
 const OPENCODE_GO_API_OVERRIDES: Readonly<Record<string, Api>> = {
 	...Object.fromEntries(OPENCODE_GO_CHAT_COMPLETIONS_MODEL_IDS.map(id => [id, "openai-completions"])),
 	...Object.fromEntries(OPENCODE_GO_MESSAGES_MODEL_IDS.map(id => [id, "anthropic-messages"])),
+	"muse-spark-1.3-contributor": "openai-responses",
 } as Record<string, Api>;
 // OpenCode Go has a provider-specific endpoint table at
 // https://opencode.ai/docs/go/#endpoints. Keep routing aligned with that table:
@@ -2873,6 +2874,19 @@ const OPENCODE_GO_OFFICIAL_MODELS: Readonly<Record<string, OpenCodeGoOfficialMod
 		reasoning: true,
 		cost: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite: 0 },
 	},
+	// Provisional models.dev contract, not a published Meta 1.3 specification:
+	// providers/opencode-go/models/muse-spark-1.3-contributor.toml
+	// blob df9405a4823feeaa5705558807515bdd2d930da2 explicitly inherits 1.2 capabilities.
+	// Its minimal..xhigh efforts match existing Responses inference. Advertise
+	// only GJC's supported text/image inputs; pricing is from opencode.ai/docs/go.
+	"muse-spark-1.3-contributor": {
+		name: "Muse Spark 1.3 Contributor",
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite: 0 },
+	},
 	"qwen3.8-flash": {
 		name: "Qwen3.8 Flash",
 		contextWindow: 1_000_000,

package/src/provider-models/special.ts

@@ -5,6 +5,7 @@ import type { ModelManagerOptions } from "../model-manager";
 import { buildZCodeSourceHeaders, resolveGlmZcodeAnthropicBaseUrl } from "../providers/anthropic";
 import { fetchKiroApiModels, isKiroApiKey, kiroApiStaticModels } from "../providers/kiro-api-key";
 import { fetchOpenCodexModels, OPENCODEX_MODEL_CACHE_TTL_MS } from "../providers/openai-opencodex-responses";
+import type { Model } from "../types";
 import { fetchCodexModels } from "../utils/discovery/codex";
 import { fetchOpenAICompatibleModels } from "../utils/discovery/openai-compatible";
 import { createBundledReferenceMap } from "./bundled-references";
@@ -16,6 +17,44 @@ export function openCodexModelManagerOptions(): ModelManagerOptions<"openai-resp
 	};
 }
 
+// ---------------------------------------------------------------------------
+// Devin CLI (ACP)
+// ---------------------------------------------------------------------------
+
+/**
+ * Lazy handle to the ACP provider module. The ACP SDK must stay out of the
+ * catalog/startup import graph, so it is only required when Devin model
+ * discovery actually runs.
+ */
+interface DevinAcpDiscoveryModule {
+	fetchDevinAcpModels: (config?: {
+		cliPath?: string;
+		cliArgs?: readonly string[];
+		cwd?: string;
+	}) => Promise<Model<"devin-acp">[] | null>;
+}
+
+const devinAcpDiscovery = once(() => require("../providers/devin-acp") as DevinAcpDiscoveryModule);
+
+export interface DevinModelManagerConfig {
+	cliPath?: string;
+	cliArgs?: readonly string[];
+	cwd?: string;
+}
+
+/**
+ * Devin models come from the ACP session's own `model` config option: the
+ * account and enterprise allowlists are authoritative there, and ACP is the
+ * documented programmatic surface (`devin acp`). Discovery fails closed to "no
+ * models" when the CLI is missing or unauthenticated.
+ */
+export function devinModelManagerOptions(config: DevinModelManagerConfig = {}): ModelManagerOptions<"devin-acp"> {
+	return {
+		providerId: "devin",
+		fetchDynamicModels: () => devinAcpDiscovery().fetchDevinAcpModels(config),
+	};
+}
+
 // ---------------------------------------------------------------------------
 // OpenAI code provider
 // ---------------------------------------------------------------------------

package/src/providers/anthropic.d.ts

@@ -107,7 +107,7 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
-export declare const claudeCodeVersion = "2.1.257";
+export declare const claudeCodeVersion = "2.1.273";
 export declare const claudeCodeEntrypoint = "sdk-cli";
 export declare const claudeToolPrefix: string;
 export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";

package/src/providers/anthropic.ts

@@ -833,7 +833,7 @@ function getCacheControl(
 }
 
 // Stealth mode: Mimic Anthropic Code headers and tool prefixing.
-export const claudeCodeVersion = "2.1.257";
+export const claudeCodeVersion = "2.1.273";
 export const claudeCodeEntrypoint = "sdk-cli";
 export const claudeToolPrefix: string = "proxy_";
 export const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";

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

@@ -50,6 +50,8 @@ import {
 	isOpenAIResponsesProgressEvent,
 	normalizeResponsesToolCallIdForTransform,
 	processResponsesStream,
+	responsesStreamFailureCode,
+	unexpectedResponsesStreamEndError,
 } from "./openai-responses-shared";
 import { transformMessages } from "./transform-messages";
 
@@ -177,7 +179,7 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs);
 			stream.push({ type: "start", partial: output });
 
-			await processResponsesStream(
+			const sawTerminalEvent = await processResponsesStream(
 				iterateWithIdleTimeout(openaiStream, {
 					firstItemTimeoutMs: firstEventTimeoutMs,
 					firstItemErrorMessage: AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE,
@@ -210,6 +212,11 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 				throw new Error(output.errorMessage ?? "An unknown error occurred");
 			}
 
+			// The Responses SSE contract always ends with a terminal event. A stream
+			// that closes without one is an interrupted upstream, not a completed
+			// turn, and must not surface as a content-free success.
+			if (!sawTerminalEvent) throw unexpectedResponsesStreamEndError();
+
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "done", reason: output.stopReason, message: output });
@@ -224,6 +231,8 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 			output.stopReason = abortTracker.wasCallerAbort() ? "aborted" : "error";
 			output.errorStatus = extractHttpStatusFromError(firstEventTimeoutError ?? normalizedError);
 			output.transportFailure = transportFailureFacts(firstEventTimeoutError ?? normalizedError);
+			const streamFailureCode = responsesStreamFailureCode(firstEventTimeoutError ?? normalizedError);
+			if (streamFailureCode !== undefined) output.errorCode = streamFailureCode;
 			output.errorMessage =
 				firstEventTimeoutError?.message ?? (await finalizeErrorMessage(normalizedError, rawRequestDump));
 			output.duration = Date.now() - startTime;

package/src/providers/cursor.d.ts

@@ -1,9 +1,9 @@
+import http2 from "node:http2";
 import { type JsonValue } from "@bufbuild/protobuf";
-import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, Model, StreamFunction, StreamOptions, ToolCall, ToolResultMessage, Usage } from "../types";
-import { kCursorExecResolved } from "../utils/block-symbols";
+import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, Model, StreamFunction, StreamOptions, Tool, ToolCall, ToolResultMessage, Usage } from "../types";
+import { kProviderResolvedToolCall } from "../utils/block-symbols";
 import { CURSOR_CLIENT_VERSION } from "./cursor/client-version";
 import type { CursorRule, RequestedModel_ModelParameterbytes } from "./cursor/gen/agent_pb";
-import { type ConversationStateStructure } from "./cursor/gen/agent_pb";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
 export { CURSOR_CLIENT_VERSION };
 /** Drop all cached state + blob bytes for a conversation (F15 bound + session-teardown hook). */
@@ -14,6 +14,24 @@ export interface CursorOptions extends StreamOptions {
     execHandlers?: CursorExecHandlers;
     onToolResult?: CursorToolResultHandler;
 }
+/** Exported for deterministic validation of fragmented Connect progress. */
+export declare function isPlausibleCursorConnectProgressForTest(bufferedLength: number, flags: number, messageLength?: number): boolean;
+/** Exported for deterministic coverage of the Cursor exec-budget derivation. */
+export declare function cursorExecDeadlineMsForTest(idleTimeoutMs: number | undefined): number;
+/** Settlement proof for a started non-abortable Cursor exec. */
+export interface CursorNonAbortableSettlement {
+    /** Resolves when the marked mutation settles; never rejects. */
+    settled: Promise<void>;
+}
+/** Exported for production-bridge coverage of non-abortable terminal ordering. */
+export declare function runWithCursorExecDeadlineForTest<T>(operation: (signal: AbortSignal, markNonAbortable: () => void) => Promise<T>, signal: AbortSignal | undefined, deadlineMs: number): Promise<T>;
+/** Await request-side END_STREAM under the same bounded teardown contract used by Cursor streams. */
+export declare function endCursorRequestForTest(request: Pick<http2.ClientHttp2Stream, "end">, timeoutMs?: number): Promise<boolean>;
+/** Exported for deterministic coverage of successful writer teardown ordering. */
+export declare function waitForCursorWritesForTest(request: http2.ClientHttp2Stream | null, timeoutMs?: number): Promise<void>;
+export declare function waitForCursorWriteDrainForTest(request: http2.ClientHttp2Stream, timeoutMs?: number): Promise<void>;
+/** Exported for deterministic coverage of the post-fence write race. */
+export declare function writeCursorFrameForTest(request: http2.ClientHttp2Stream, frame: Uint8Array): boolean;
 /** Build the ordered global USER rules Cursor expects for the current system prompt. */
 export declare function buildCursorRequestContextRules(systemPrompt: readonly string[] | undefined): CursorRule[];
 export interface CursorWireModelResolution {
@@ -30,42 +48,34 @@ type ToolCallState = ToolCall & {
     index: number;
     partialJson?: string;
     kind: "mcp" | "todo_write" | "native" | "cursor-exec";
-    [kCursorExecResolved]?: true;
+    [kProviderResolvedToolCall]?: true;
 };
 interface UsageState {
     sawTokenDelta: boolean;
-    /**
-     * Latest `ConversationTokenDetails.used_tokens`: the whole conversation's
-     * token consumption as counted by Cursor, not this turn's output.
-     */
     conversationUsedTokens: number;
-    /** Output tokens already included in the latest checkpoint snapshot. */
     checkpointOutputTokens: number;
-    /** Whether the current stream received a checkpoint, including an explicit zero. */
     hasConversationCheckpoint: boolean;
-    pendingCheckpoint?: ConversationStateStructure;
 }
+export declare function storeCursorBlobForTest(blobStore: Map<string, Uint8Array>, blobId: Uint8Array, blobData: Uint8Array, limits: {
+    maxBytes: number;
+}): boolean;
 /** Exported for tests: verifies handler is invoked with correct `this` when passed as bound. */
-export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler: ((args: TArgs) => Promise<CursorExecHandlerResult<TResult>>) | undefined, onToolResult: CursorToolResultHandler | undefined, buildFromToolResult: (toolResult: ToolResultMessage) => TResult, buildRejected: (reason: string) => TResult, buildError: (error: string) => TResult): Promise<{
+export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler: ((args: TArgs, signal?: AbortSignal, markNonAbortable?: () => void) => Promise<CursorExecHandlerResult<TResult>>) | undefined, onToolResult: CursorToolResultHandler | undefined, buildFromToolResult: (toolResult: ToolResultMessage) => TResult, buildRejected: (reason: string) => TResult, buildError: (error: string) => TResult, signal?: AbortSignal, markNonAbortable?: () => void): Promise<{
     execResult: TResult;
     toolResult?: ToolResultMessage;
 }>;
 /** Exported for deterministic coverage of ordered server-message handling. */
-export declare function createCursorMessageQueueForTest(onError?: (error: unknown) => void): {
-    enqueue(handler: () => void | Promise<void>): Promise<void>;
+export declare function createCursorMessageQueueForTest(onError?: (error: unknown) => void, maxPendingBytes?: number): {
+    enqueue(handler: () => void | Promise<void>, byteSize?: number): Promise<void>;
     drain(): Promise<void>;
+    pending(): number;
+    pendingBytes(): number;
 };
 /** Exported for direct regression coverage of the JSON-safety boundary. */
 export declare function cursorJsonSafeValueForTest(value: unknown): unknown;
 export declare function buildNativeToolCallBlock(toolCall: Record<string, unknown>, callId: string, index: number): ToolCallState | null;
-/**
- * Cursor streams output tokens as deltas and reports whole-conversation
- * consumption separately as `ConversationTokenDetails.used_tokens`. Derive
- * prompt tokens from the difference so context accounting and compaction see a
- * real prompt size instead of zero.
- */
+/** Derive prompt usage from Cursor's whole-conversation checkpoint total. */
 export declare function finalizeCursorUsage(output: AssistantMessage, usageState: UsageState): void;
-/** Exposes {@link finalizeCursorUsage} for tests without a live HTTP/2 stream. */
 export declare function finalizeCursorUsageForTest(usedTokens: number, outputTokens: number, options?: {
     checkpointOutputTokens?: number;
     hasConversationCheckpoint?: boolean;
@@ -91,6 +101,8 @@ export declare function finalizeCursorUsageForTest(usedTokens: number, outputTok
  * an empty `rootPromptMessagesJson` head.
  */
 export declare function buildCursorSystemPromptJsons(systemPrompt: readonly string[] | undefined, modelId?: string): string[];
+/** Exported for regression coverage of the tool usage-cache identity boundary. */
+export declare function buildCursorUsageToolsKeyForTest(tools: Tool[]): string;
 /** Exported for tests: decodes Cursor history blobs built from conversation messages. */
 export declare function buildCursorHistoryForTest(messages: Message[]): {
     rootPromptMessagesJson: unknown[];