@code-yeongyu/senpi-ai 2026.10.21-1 → 2026.10.21-3

package/dist/api/anthropic-messages.js

@@ -734,6 +734,19 @@ function markSystemMessageCacheCheckpoint(message, cacheControl) {
         lastBlock.cache_control = cacheControl;
     }
 }
+/** Marks the last block that accepts `cache_control` (thinking blocks do not); false when none does. */
+function markAssistantMessageCacheCheckpoint(blocks, cacheControl) {
+    for (let index = blocks.length - 1; index >= 0; index--) {
+        const block = blocks[index];
+        if (block.type === "text" || block.type === "tool_use") {
+            block.cache_control = cacheControl;
+            return true;
+        }
+        if (block.type === "thinking" || block.type === "redacted_thinking")
+            return false;
+    }
+    return false;
+}
 function markUserMessageCacheCheckpoint(message, cacheControl) {
     if (message.role !== "user")
         return false;
@@ -1779,6 +1792,12 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     });
     // The prompt travels in `params.system`; the leading system message is not a turn.
     const conversationMessages = initialSystemMessage ? transformedMessages.slice(1) : transformedMessages;
+    // Context reduction marks the last message its frontier leaves unchanged: on a frontier step both the
+    // old boundary (read) and the new one (written for the next step) are marked. Two checkpoints fit
+    // only when the system block holds one, which then also covers the tools before it (senpi#3242).
+    const stablePrefixMarkers = conversationMessages.filter((message) => message.role === "assistant" && message.promptCacheBreakpoint === true).length;
+    const systemHoldsCheckpoint = isOAuthToken || initialSystemText.length > 0;
+    const stablePrefixCheckpointLimit = stablePrefixMarkers >= 2 && systemHoldsCheckpoint ? 2 : Math.min(1, stablePrefixMarkers);
     // Native tool changes reference tools by name, so a redefined name cannot be expressed,
     // and Anthropic rejects a tool list where every tool is deferred, so there must be an
     // initial active tool to anchor the deferred ones. Otherwise the current tool list is sent.
@@ -1823,7 +1842,7 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         nativeToolChanges,
         refusalFallbacks: sendFallbacks,
     }, options);
-    const convertedMessages = convertMessages(conversationMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, midConvoEffort ? model.provider : undefined, nativeToolChanges);
+    const convertedMessages = convertMessages(conversationMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, midConvoEffort ? model.provider : undefined, nativeToolChanges, stablePrefixCheckpointLimit);
     const messages = midConvoEffort
         ? insertThinkingLevelMessages(convertedMessages, activeEffort)
         : convertedMessages.messages;
@@ -1885,7 +1904,7 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
             configurable: true,
         });
     }
-    const toolCacheControl = compat.supportsCacheControlOnTools ? cacheControl : undefined;
+    const toolCacheControl = compat.supportsCacheControlOnTools && stablePrefixCheckpointLimit < 2 ? cacheControl : undefined;
     if (nativeToolChanges) {
         // Initial tools stay active with the cache breakpoint on the last one. Every later
         // declaration is deferred and only surfaced by its `tool_addition` block; removed
@@ -2053,10 +2072,11 @@ function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames
                 : convertedContent,
     };
 }
-function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay = "text", deferredToolNames = new Set(), normalizeToolName = (name) => name, managedProvider, nativeToolChanges = false) {
+function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay = "text", deferredToolNames = new Set(), normalizeToolName = (name) => name, managedProvider, nativeToolChanges = false, stablePrefixCheckpointLimit = 0) {
     const params = [];
     const assistantLevels = new Map();
     const loadedToolNames = new Set();
+    let stablePrefixCheckpoints = 0;
     // Later system messages are held back and emitted directly before the next assistant
     // message (or at the end of the transcript). Anthropic requires `tool_result` blocks to
     // immediately follow their `tool_use`, so a system message between them is rejected; this
@@ -2247,6 +2267,12 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                 role: "assistant",
                 content: blocks,
             });
+            if (cacheControl &&
+                msg.promptCacheBreakpoint === true &&
+                stablePrefixCheckpoints < stablePrefixCheckpointLimit &&
+                markAssistantMessageCacheCheckpoint(blocks, cacheControl)) {
+                stablePrefixCheckpoints++;
+            }
             if (managedProvider !== undefined &&
                 msg.api === "anthropic-messages" &&
                 msg.provider === managedProvider &&
@@ -2285,7 +2311,11 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
         markSystemMessageCacheCheckpoint(lastParam, cacheControl);
         return { messages: params, assistantLevels };
     }
-    const retainPrecedingCheckpoint = isToolLoopContinuation(params);
+    // Four breakpoints at most: system, tools or a second stable-prefix checkpoint, a stable-prefix
+    // checkpoint and the final user turn. A stable-prefix checkpoint takes the preceding tool-loop
+    // checkpoint's slot; the final checkpoint's lookback already reaches the previous request's entry
+    // two blocks back (senpi#3242).
+    const retainPrecedingCheckpoint = stablePrefixCheckpoints === 0 && isToolLoopContinuation(params);
     if (cacheControl && params.length > 0 && markUserMessageCacheCheckpoint(params[params.length - 1], cacheControl)) {
         if (retainPrecedingCheckpoint) {
             for (let index = params.length - 2; index >= 0; index--) {

package/dist/api/azure-openai-responses.js

@@ -8,7 +8,7 @@ import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { getDeclaredTools, resolveTranscript, resolveTranscriptTools } from "../utils/transcript.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
-import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { deriveOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 const DEFAULT_AZURE_API_VERSION = "v1";
@@ -233,7 +233,7 @@ function buildParams(model, context, options, deploymentName, grammarToolInputPr
         stream: true,
         ...((options?.cacheRetention ?? model.cacheRetention) === "none"
             ? {}
-            : { prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId) }),
+            : { prompt_cache_key: deriveOpenAIPromptCacheKey(model.id, context) }),
         store: false,
     };
     if (options?.maxTokens) {

package/dist/api/cursor-agent.js

@@ -20,6 +20,7 @@ import * as http2 from "node:http2";
 import { create, fromBinary, fromJson, toBinary, toJson } from "@bufbuild/protobuf";
 import { ValueSchema } from "@bufbuild/protobuf/wkt";
 import { CURSOR_COMPOSER_PROMPT, isCursorComposerModel } from "../cursor/composer-prompt.js";
+import { cursorDiscoveredInput } from "../cursor/model-input.js";
 import { calculateCost } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { clearStreamingPartialJson, kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind, kStreamingEnvelopeId, kStreamingLastParseLen, kStreamingPartialJson, } from "../utils/block-symbols.js";
@@ -3788,11 +3789,6 @@ const CURSOR_DEFAULT_MAX_TOKENS = 64_000;
 const CURSOR_1M_CONTEXT_WINDOW = 1_000_000;
 const CURSOR_1M_NAME_PATTERN = /\b1m\b/i;
 const CURSOR_MAX_MODE_1M_ID_PATTERN = /claude|gemini/;
-/**
- * Model-id families whose native catalogs are multimodal. Cursor-only or
- * text-only families (`composer-*`, `grok-code-*`) stay outside this pattern.
- */
-const CURSOR_MULTIMODAL_ID_PATTERN = /claude|gemini|gpt-|codex/;
 /**
  * Fetches Cursor models through `GetUsableModels` (unary protobuf over
  * HTTP/2; the ALB rejects HTTP/1.1 with 464) and normalizes them.
@@ -3882,7 +3878,7 @@ export async function fetchCursorUsableModels(options) {
                 id,
                 name,
                 reasoning: Boolean(model.thinkingDetails),
-                input: CURSOR_MULTIMODAL_ID_PATTERN.test(id.toLowerCase()) ? ["text", "image"] : ["text"],
+                input: cursorDiscoveredInput(id),
                 contextWindow,
                 maxTokens: CURSOR_DEFAULT_MAX_TOKENS,
                 cursorMaxMode: maxMode,

package/dist/api/google-generative-ai.js

@@ -4,6 +4,7 @@ import { formatProviderError, normalizeProviderError } from "../utils/error-body
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText } from "../utils/text.js";
 import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage } from "../utils/transcript.js";
@@ -191,12 +192,13 @@ export const stream = (model, context, options) => {
                     }
                 }
                 if (chunk.usageMetadata) {
+                    const reasoning = reportedCount(chunk.usageMetadata.thoughtsTokenCount);
                     output.usage = {
                         input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
                         output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
                         cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
                         cacheWrite: 0,
-                        reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
+                        ...(reasoning === undefined ? {} : { reasoning }),
                         totalTokens: chunk.usageMetadata.totalTokenCount || 0,
                         cost: {
                             input: 0,

package/dist/api/google-vertex.js

@@ -5,6 +5,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText } from "../utils/text.js";
 import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage } from "../utils/transcript.js";
@@ -195,12 +196,13 @@ export const stream = (model, context, options) => {
                     }
                 }
                 if (chunk.usageMetadata) {
+                    const reasoning = reportedCount(chunk.usageMetadata.thoughtsTokenCount);
                     output.usage = {
                         input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
                         output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
                         cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
                         cacheWrite: 0,
-                        reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
+                        ...(reasoning === undefined ? {} : { reasoning }),
                         totalTokens: chunk.usageMetadata.totalTokenCount || 0,
                         cost: {
                             input: 0,

package/dist/api/openai-codex-responses.js

@@ -28,7 +28,7 @@ import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { clearWebSocketFallbackState, getOrCreateWebSocketDebugStats, getWebSocketDebugStats, isWebSocketSseFallbackActive, recordWebSocketFailure, recordWebSocketSseFallback, recordWebSocketSuccess, } from "./openai-codex-responses/fallback-state.js";
 import { codexEventProviderDiagnostic, codexHttpProviderDiagnostic, } from "./openai-codex-responses/provider-diagnostic.js";
 import { buildCodexReasoning } from "./openai-codex-responses/reasoning.js";
-import { applyChatGptSubscriptionCacheAffinityHeaders, clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { applyChatGptSubscriptionCacheAffinityHeaders, clampOpenAIPromptCacheKey, deriveOpenAIPromptCacheKey, } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
 import { applyExtraBody, buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS, } from "./simple-options.js";
 import { startWebSocketLiveness } from "./websocket-liveness.js";
@@ -171,7 +171,7 @@ export const stream = (model, context, options) => {
             const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
             const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
             const codexSessionId = clampOpenAIPromptCacheKey(cacheSessionId);
-            let body = buildRequestBody(model, normalizedContext, options, codexSessionId, grammarToolInputProperties);
+            let body = buildRequestBody(model, normalizedContext, options, grammarToolInputProperties);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
                 body = nextBody;
@@ -402,7 +402,7 @@ export const streamSimple = (model, context, options) => {
 // ============================================================================
 // Request Building
 // ============================================================================
-function buildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
+function buildRequestBody(model, context, options, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
     const requestedReasoningEffort = options?.reasoningEffort;
     const mappedReasoningEffort = requestedReasoningEffort === undefined
         ? undefined
@@ -436,7 +436,7 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
-        prompt_cache_key: cacheSessionId,
+        prompt_cache_key: options?.cacheRetention === "none" ? undefined : deriveOpenAIPromptCacheKey(model.id, context),
         tool_choice: options?.toolChoice ?? "auto",
         parallel_tool_calls: true,
     };

package/dist/api/openai-completions.js

@@ -12,6 +12,7 @@ import { getOpenAICompletionsCompat as getCompat, } from "../utils/prompt-cache-
 import { awaitProviderTransport, iterateProviderTransport, openAICompatibleProviderDiagnosticFromError, } from "../utils/provider-diagnostic-sources.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderStreamRequest } from "../utils/provider-retry.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
 import { primeStreamUntilContent, sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
@@ -1569,12 +1570,13 @@ function parseChunkUsage(rawUsage, model) {
     const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
     // OpenAI completion_tokens already includes reasoning_tokens.
     const outputTokens = rawUsage.completion_tokens || 0;
+    const reasoning = reportedCount(rawUsage.completion_tokens_details?.reasoning_tokens);
     const usage = {
         input,
         output: outputTokens,
         cacheRead: cacheReadTokens,
         cacheWrite: cacheWriteTokens,
-        reasoning: rawUsage.completion_tokens_details?.reasoning_tokens || 0,
+        ...(reasoning === undefined ? {} : { reasoning }),
         totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
     };

package/dist/api/openai-prompt-cache.d.ts

@@ -1,4 +1,7 @@
+import type { TranscriptContext } from "../types.ts";
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Cache affinity belongs to the reusable leading prefix, never to a conversation UUID. */
+export declare function deriveOpenAIPromptCacheKey(modelId: string, context: TranscriptContext): string | undefined;
 export declare function clampOpenAIPromptCacheKey(key: string | undefined): string | undefined;
 export declare function applyChatGptSubscriptionCacheAffinityHeaders(headers: Headers, sessionId: string | undefined): void;
 //# sourceMappingURL=openai-prompt-cache.d.ts.map

package/dist/api/openai-prompt-cache.js

@@ -1,4 +1,26 @@
+import { shortHash } from "../utils/hash.js";
+import { getSystemMessageText } from "../utils/text.js";
+import { getInitialSystemMessage } from "../utils/transcript.js";
 export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+const PREFIX_VERSION = "senpi-responses-prefix-v1";
+/** Cache affinity belongs to the reusable leading prefix, never to a conversation UUID. */
+export function deriveOpenAIPromptCacheKey(modelId, context) {
+    const initial = getInitialSystemMessage(context.messages);
+    const tools = [...(initial?.toolsAdded ?? [])].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const prefix = JSON.stringify([
+        PREFIX_VERSION,
+        modelId,
+        initial === undefined ? "" : getSystemMessageText(initial),
+        tools.map(({ name, description, parameters, freeform, constrainedSampling }) => ({
+            name,
+            description,
+            parameters,
+            freeform,
+            constrainedSampling,
+        })),
+    ]);
+    return clampOpenAIPromptCacheKey(`${PREFIX_VERSION}-${shortHash(prefix)}`);
+}
 export function clampOpenAIPromptCacheKey(key) {
     if (key === undefined)
         return undefined;

package/dist/api/openai-responses-shared.js

@@ -3,6 +3,7 @@ import { calculateCost, supportsConfigurationUpdate } from "../models.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { shortHash } from "../utils/hash.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
+import { reportedCount } from "../utils/reported-count.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
 import { getCurrentTools, getDeclaredTools, resolveTranscript, resolveTranscriptTools } from "../utils/transcript.js";
@@ -480,7 +481,8 @@ export function convertResponsesTools(tools, options) {
     const defaultStrict = options?.strict === undefined ? false : options.strict;
     const supportsStrictMode = options?.supportsStrictMode ?? true;
     const supportsOpenAIGrammarTools = options?.supportsOpenAIGrammarTools ?? false;
-    return tools.map((tool) => {
+    const sortedTools = [...tools].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return sortedTools.map((tool) => {
         const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
         if (grammar) {
             return {
@@ -772,13 +774,14 @@ export async function processResponsesStream(openaiStream, output, stream, model
             const cachedTokens = inputDetails?.cached_tokens || 0;
             // OpenAI platform reports cache_write_tokens; some compatible gateways use cache_creation_tokens.
             const cacheWriteTokens = inputDetails?.cache_write_tokens ?? inputDetails?.cache_creation_tokens ?? 0;
+            const reasoning = reportedCount(response.usage.output_tokens_details?.reasoning_tokens);
             output.usage = {
                 // OpenAI includes cached and cache-write tokens in input_tokens, so subtract both.
                 input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
                 output: response.usage.output_tokens || 0,
                 cacheRead: cachedTokens,
                 cacheWrite: cacheWriteTokens,
-                reasoning: response.usage.output_tokens_details?.reasoning_tokens || 0,
+                ...(reasoning === undefined ? {} : { reasoning }),
                 totalTokens: response.usage.total_tokens || 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             };

package/dist/api/openai-responses.js

@@ -17,7 +17,7 @@ import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { withGitHubCopilotFailureNote } from "./github-copilot-errors.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
-import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { deriveOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { applyAllowedToolsChoice, hasRefusedAllowedToolsChoice, isAllowedToolsChoiceRefusal, rememberAllowedToolsChoiceRefusal, restrictToAllowedTools, } from "./openai-responses-allowed-tools.js";
 import { findPromptCacheComparisonResponseId, withPromptCacheComparison, } from "./openai-responses-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
@@ -195,7 +195,7 @@ export const stream = (model, context, options) => {
             params = applyAllowedToolsChoice(params, normalizedContext, context.activeToolNames, compat);
             if (hasRefusedAllowedToolsChoice(model))
                 params = restrictToAllowedTools(params);
-            const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
+            const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice, getDeclaredTools(normalizedContext.messages).map((tool) => tool.name));
             if (limitedTools.omittedCount > 0) {
                 params = { ...params, tools: limitedTools.tools };
                 recordGitHubCopilotToolLimit(output, limitedTools.omittedCount);
@@ -348,7 +348,7 @@ export async function warmOpenAIResponsesPromptCache(model, context, options) {
     if (nextParams !== undefined)
         params = nextParams;
     params = sanitizeUnsupportedNativeTools(params, compat);
-    const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
+    const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice, getDeclaredTools(prefix.messages).map((tool) => tool.name));
     if (limitedTools.omittedCount > 0)
         params = { ...params, tools: limitedTools.tools };
     const body = {
@@ -443,10 +443,7 @@ function buildParams(model, context, options, compat = getCompat(model, options?
         model: model.id,
         input: messages,
         stream: true,
-        prompt_cache_key: cacheRetention === "none" ||
-            (isNativeEndpoint && (compat.supportsExplicitPromptCacheMode || model.cost.cacheWrite > 0))
-            ? undefined
-            : clampOpenAIPromptCacheKey(options?.sessionId),
+        prompt_cache_key: cacheRetention === "none" ? undefined : deriveOpenAIPromptCacheKey(model.id, context),
         prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
         prompt_cache_options: withPromptCacheComparison(getPromptCacheOptions(compat, cacheRetention), comparisonResponseId),
         store: false,

package/dist/api/pi-messages.js

@@ -21,6 +21,11 @@ export class PiMessagesResponseError extends Error {
         this.diagnosticDetails = diagnosticDetails;
     }
 }
+/** `promptCacheBreakpoint` is a request-local hint for adapters that place cache breakpoints; it is not part of the pi-messages wire. */
+function withoutPromptCacheBreakpoint(message) {
+    const { promptCacheBreakpoint: _hint, ...rest } = message;
+    return rest;
+}
 function parsePiMessagesErrorBody(body) {
     try {
         const parsed = JSON.parse(body);
@@ -266,7 +271,9 @@ export const stream = (model, context, options) => {
                                 }
                                 : part),
                         }
-                        : message),
+                        : message.role === "assistant" && message.promptCacheBreakpoint
+                            ? withoutPromptCacheBreakpoint(message)
+                            : message),
                 },
                 options: {
                     temperature: options?.temperature,

package/dist/auth/pool/kinds.d.ts

@@ -0,0 +1,17 @@
+import type { Credential } from "../types.ts";
+import { type CredentialSlot, type PooledCredential } from "./slots.ts";
+export type CredentialKind = Credential["type"];
+/**
+ * A slot's kind from its own material: OAuth tokens make an OAuth login, a key alone makes an API
+ * key. A slot with neither is not classified, so a caller never drops or reports it by guess.
+ */
+export declare function slotKind(slot: Pick<CredentialSlot, "access" | "refresh" | "key">): CredentialKind | undefined;
+/**
+ * Kinds held by a credential's slots that its top-level type cannot use: slots are projected
+ * through that type, so a slot of the other kind is never used (senpi#3448). Builds before the
+ * fix appended a login of the other kind this way.
+ */
+export declare function unusedSlotKinds(credential: PooledCredential | undefined): ReadonlyArray<CredentialKind>;
+/** The slots a credential can actually use: a slot of the other kind never projects (senpi#3486). */
+export declare function slotsOfOwnKind(credential: PooledCredential): CredentialSlot[];
+//# sourceMappingURL=kinds.d.ts.map

package/dist/auth/pool/kinds.js

@@ -0,0 +1,32 @@
+import { listSlots } from "./slots.js";
+/**
+ * A slot's kind from its own material: OAuth tokens make an OAuth login, a key alone makes an API
+ * key. A slot with neither is not classified, so a caller never drops or reports it by guess.
+ */
+export function slotKind(slot) {
+    if (slot.access !== undefined || slot.refresh !== undefined)
+        return "oauth";
+    return slot.key !== undefined ? "api_key" : undefined;
+}
+/**
+ * Kinds held by a credential's slots that its top-level type cannot use: slots are projected
+ * through that type, so a slot of the other kind is never used (senpi#3448). Builds before the
+ * fix appended a login of the other kind this way.
+ */
+export function unusedSlotKinds(credential) {
+    if (!credential || !Array.isArray(credential.accounts))
+        return [];
+    const kinds = new Set();
+    for (const slot of listSlots(credential)) {
+        const kind = slotKind(slot);
+        if (kind !== undefined && kind !== credential.type)
+            kinds.add(kind);
+    }
+    return [...kinds];
+}
+/** The slots a credential can actually use: a slot of the other kind never projects (senpi#3486). */
+export function slotsOfOwnKind(credential) {
+    return listSlots(credential).filter((slot) => slotKind(slot) !== otherKind(credential.type));
+}
+const otherKind = (kind) => (kind === "oauth" ? "api_key" : "oauth");
+//# sourceMappingURL=kinds.js.map

package/dist/auth/pool/slots.d.ts

@@ -72,6 +72,18 @@ export declare function pinSlot(credential: PooledCredential, name: string): Poo
  * plain credential and never write pool state back through the projection.
  */
 export declare function projectSlot(credential: PooledCredential | undefined, name: string): Credential | undefined;
+/** A login tried to store an API-key credential whose `key` is blank or missing (#3867). */
+export declare class EmptyApiKeyError extends Error {
+    readonly name = "EmptyApiKeyError";
+    constructor();
+}
+/** Drops a blank or missing `key` from an API-key credential; used only for providers that declare `keyOptional`. */
+export declare function withoutBlankKey(credential: Credential): Credential;
+/**
+ * Throws `EmptyApiKeyError` when an API-key credential names a `key` that is not a non-empty
+ * string. Env-only logins (AWS profile or credential chain, Vertex ADC) omit the field and pass.
+ */
+export declare function assertLoginKeyPresent(credential: Credential): void;
 /**
  * Appends an unnamed flat credential to a pool as a generated `login-N` slot.
  * An absent current entry keeps today's whole-write shape; a flat current entry
@@ -89,7 +101,7 @@ export declare function projectSlot(credential: PooledCredential | undefined, na
  * `onAllocated` reports the account this login committed, so a caller can name
  * it in a receipt without re-reading storage.
  */
-export declare function appendLoginSlot(current: PooledCredential | undefined, flat: Credential, onAllocated?: (name: string, origin: "generated" | "provider") => void): Credential;
+export declare function appendLoginSlot(stored: PooledCredential | undefined, flat: Credential, onAllocated?: (name: string, origin: "generated" | "provider") => void): Credential;
 /**
  * Material a provider writes into the flat credential when the real token lives
  * outside auth.json (an SDK subprocess or a vendor CLI owns it): the literal

package/dist/auth/pool/slots.js

@@ -289,6 +289,34 @@ function mergeProvidedPool(current, existing, provided) {
 function hasNewerMaterial(candidate, stored) {
     return candidate.expires !== undefined && (stored.expires === undefined || candidate.expires > stored.expires);
 }
+/** A login tried to store an API-key credential whose `key` is blank or missing (#3867). */
+export class EmptyApiKeyError extends Error {
+    constructor() {
+        super("Refusing to save an empty API key");
+        this.name = "EmptyApiKeyError";
+    }
+}
+/** True when an API-key credential names a `key` that is blank, whitespace or not a string. */
+function hasBlankKey(credential) {
+    if (credential.type !== "api_key" || !Object.hasOwn(credential, "key"))
+        return false;
+    return typeof credential.key !== "string" || credential.key.trim() === "";
+}
+/** Drops a blank or missing `key` from an API-key credential; used only for providers that declare `keyOptional`. */
+export function withoutBlankKey(credential) {
+    if (credential.type !== "api_key" || !hasBlankKey(credential))
+        return credential;
+    const { key: _blank, ...rest } = credential;
+    return rest;
+}
+/**
+ * Throws `EmptyApiKeyError` when an API-key credential names a `key` that is not a non-empty
+ * string. Env-only logins (AWS profile or credential chain, Vertex ADC) omit the field and pass.
+ */
+export function assertLoginKeyPresent(credential) {
+    if (hasBlankKey(credential))
+        throw new EmptyApiKeyError();
+}
 /**
  * Appends an unnamed flat credential to a pool as a generated `login-N` slot.
  * An absent current entry keeps today's whole-write shape; a flat current entry
@@ -306,7 +334,11 @@ function hasNewerMaterial(candidate, stored) {
  * `onAllocated` reports the account this login committed, so a caller can name
  * it in a receipt without re-reading storage.
  */
-export function appendLoginSlot(current, flat, onAllocated) {
+export function appendLoginSlot(stored, flat, onAllocated) {
+    assertLoginKeyPresent(flat);
+    // A pool holds one kind: a login of the other kind replaces the credential instead of joining it
+    // as a slot nothing can project (senpi#3448). The caller backs up what it replaces.
+    const current = stored?.type === flat.type ? stored : undefined;
     const provided = providedSlots(flat);
     if (provided) {
         // Provider-owned envelopes identify an addition by immutable ID, never by

package/dist/auth/types.d.ts

@@ -188,6 +188,13 @@ export interface ApiKeyAuth {
     name: string;
     /** Ambient compatibility adapter that must not outrank a stored OAuth credential. */
     ambientOnly?: boolean;
+    /**
+     * A login may leave the key blank: the provider needs none (a local server such as llama.cpp) or its
+     * `resolve` falls back to an ambient key while the login stores other env (Kimi's region + KIMI_API_KEY).
+     * `Models.login` then drops the blank key; without this flag it refuses one with `EmptyApiKeyError` (#3867).
+     * Only `Models.login` reads it: `AuthStorage.set` and RPC `login_api_key` always require a key.
+     */
+    keyOptional?: boolean;
     /** Interactive setup (prompt for key/provider env). Absent = ambient-only. */
     login?(interaction: ProviderAuthInteraction): Promise<ApiKeyCredential>;
     /**

package/dist/cursor/capability-table.d.ts

@@ -0,0 +1,10 @@
+import type { CursorModelCapability } from "./model-capabilities.ts";
+/**
+ * Static cursor capability table. Values come from the live
+ * aiserver.v1 AvailableModels capture of 2026-08-18 (evidence:
+ * local-ignore/qa-evidence/20260818-cursor-reasoning-levels/available-models-catalog.json).
+ * `GetUsableModels` carries no window or parameter field, so this table is the
+ * authoritative source; see .omo/plans/cursor-reasoning-levels.md §3.1/§6.
+ */
+export declare const CURSOR_MODEL_CAPABILITIES: Record<string, CursorModelCapability>;
+//# sourceMappingURL=capability-table.d.ts.map