Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

fix cursor context usage reporting

Raine Virtab6bc68893ce3
diff --git a/src/providers/cursor/index.test.ts b/src/providers/cursor/index.test.ts
index 5684d13..f3470e0 100644
--- a/src/providers/cursor/index.test.ts
+++ b/src/providers/cursor/index.test.ts
@@ -257,9 +257,12 @@ describe("Cursor provider messages", () => {
);
const initialEvents = await collectCursorSse(initial);
const toolStart = getToolUseStartEvent(initialEvents);
+ const initialStop = findCursorSseEvent(initialEvents, "message_delta");
expect(toolStart?.data.content_block.name).toBe("Bash");
expect(toolStart?.data.content_block.id).toStartWith("call_cursor_");
+ expect(initialStop?.data.usage.input_tokens).toBeGreaterThan(0);
+ expect(initialStop?.data.usage.cache_read_input_tokens).toBe(0);
const toolInputDelta = getInputJsonDeltaEvent(initialEvents);
expect(JSON.parse(toolInputDelta?.data.delta.partial_json).command).toBe(
"cd '/tmp/cursor bridge cwd' && printf should-not-run",
diff --git a/src/providers/cursor/index.ts b/src/providers/cursor/index.ts
index cf4f5ce..e4e79e0 100644
--- a/src/providers/cursor/index.ts
+++ b/src/providers/cursor/index.ts
@@ -71,6 +71,7 @@ async function handleMessages(
const selection = resolveCursorModel(body);
const prompt = renderCursorPrompt(body);
+ const inputTokens = countCursorTokens(body);
const selectedImages = cursorSelectedImages(body);
const wantStream = wantsDownstreamStream(body);
const conversationId = cursorConversationForRequest(body, ctx.sessionId);
@@ -103,6 +104,7 @@ async function handleMessages(
sessionId: ctx.sessionId,
messageId,
model: body.model,
+ inputTokens,
log: ctx.childLogger("cursor.bridge"),
traffic: ctx.traffic,
proto: deps.proto,
@@ -164,6 +166,7 @@ async function handleMessages(
proto: deps.proto,
onSession,
allowedToolNames,
+ inputTokens,
});
return sseResponse(stream);
}
@@ -177,6 +180,7 @@ async function handleMessages(
proto: deps.proto,
onSession,
allowedToolNames,
+ inputTokens,
});
return jsonResponse(result.response);
} catch (err) {
diff --git a/src/providers/cursor/sse-framing.ts b/src/providers/cursor/sse-framing.ts
index 4fbac0f..f5792c6 100644
--- a/src/providers/cursor/sse-framing.ts
+++ b/src/providers/cursor/sse-framing.ts
@@ -8,6 +8,12 @@ interface CursorSseFramingOptions {
model: string;
emit: (event: string, data: unknown) => boolean;
mapUsage: (usage?: CursorUsage) => unknown;
+ initialUsage?: {
+ input_tokens: number;
+ output_tokens: number;
+ cache_creation_input_tokens: number;
+ cache_read_input_tokens: number;
+ };
}
export interface CursorSseFramer {
@@ -40,7 +46,11 @@ export function createCursorSseFramer(opts: CursorSseFramingOptions): CursorSseF
const ensureStart = () => {
if (started) return;
started = true;
- emitMessageStart(emit, { messageId: opts.messageId, model: opts.model });
+ emitMessageStart(emit, {
+ messageId: opts.messageId,
+ model: opts.model,
+ usage: opts.initialUsage,
+ });
};
const openThinking = () => {
diff --git a/src/providers/cursor/tool-bridge.ts b/src/providers/cursor/tool-bridge.ts
index c75f9ab..7182ba6 100644
--- a/src/providers/cursor/tool-bridge.ts
+++ b/src/providers/cursor/tool-bridge.ts
@@ -2,6 +2,7 @@ import { encodeSseEvent } from "../../sse.ts";
import type { AnthropicRequest, AnthropicToolResultBlock } from "../../anthropic/schema.ts";
import type { Logger } from "../../log.ts";
import type { RequestContext } from "../types.ts";
+import { countCursorTokens } from "./count-tokens.ts";
import {
appendCursorReadResult,
appendCursorShellStreamResult,
@@ -64,6 +65,7 @@ interface CursorBridgeState {
sessionId: string;
messageId: string;
model: string;
+ inputTokens?: number;
iterator: AsyncGenerator<CursorStreamEvent>;
pendingNext?: Promise<IteratorResult<CursorStreamEvent>>;
pendingTool?: PendingNativeTool;
@@ -135,6 +137,7 @@ export function createCursorShellToolBridge(opts: {
sessionId: string;
messageId: string;
model: string;
+ inputTokens?: number;
log: Logger;
traffic?: RequestContext["traffic"];
proto?: CursorProto;
@@ -150,6 +153,7 @@ export function createCursorShellToolBridge(opts: {
sessionId: opts.sessionId,
messageId: opts.messageId,
model: opts.model,
+ inputTokens: opts.inputTokens,
iterator: undefined as unknown as AsyncGenerator<CursorStreamEvent>,
waiters: [],
log: opts.log,
@@ -302,6 +306,7 @@ export function resumeCursorShellToolBridge(
state.pendingTool = undefined;
state.messageId = messageId;
state.model = body.model;
+ state.inputTokens = countCursorTokens(body);
tool.resolve({
content: renderToolResultContent(result.content),
isError: Boolean(result.is_error),
@@ -337,7 +342,8 @@ function streamBridgeUntilToolOrEnd(
messageId: state.messageId,
model: state.model,
emit,
- mapUsage: cursorUsageToAnthropic,
+ mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: state.inputTokens }),
+ initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: state.inputTokens }),
});
const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: state.allowedToolNames });
diff --git a/src/providers/cursor/translate/response.test.ts b/src/providers/cursor/translate/response.test.ts
index 0edc55c..2a80327 100644
--- a/src/providers/cursor/translate/response.test.ts
+++ b/src/providers/cursor/translate/response.test.ts
@@ -39,6 +39,7 @@ async function translateCursorSse(
frames: Uint8Array[],
messageId: string,
allowedToolNames?: ReadonlySet<string>,
+ inputTokens?: number,
): Promise<Array<{ event: string; data: any }>> {
const downstream = translateCursorStream(
streamFromChunks(frames),
@@ -48,25 +49,45 @@ async function translateCursorSse(
log: createLogger("cursor.response.test"),
proto: fakeProto,
allowedToolNames,
+ inputTokens,
},
);
return collectCursorSse(downstream);
}
describe("Cursor response translation", () => {
- it("maps usage tokens including cache reads and writes", () => {
+ it("does not expose Cursor aggregate cache counters as Anthropic context cache", () => {
expect(
cursorUsageToAnthropic({
inputTokens: "100",
outputTokens: "7",
- cacheReadTokens: "20",
- cacheWriteTokens: "3",
+ cacheReadTokens: "4490752",
+ cacheWriteTokens: "3000",
}),
).toEqual({
- input_tokens: 77,
+ input_tokens: 100,
output_tokens: 7,
- cache_creation_input_tokens: 3,
- cache_read_input_tokens: 20,
+ cache_creation_input_tokens: 0,
+ cache_read_input_tokens: 0,
+ });
+ });
+
+ it("uses request-side input estimates instead of Cursor aggregate input counters", () => {
+ expect(
+ cursorUsageToAnthropic(
+ {
+ inputTokens: "2116658",
+ outputTokens: "5576",
+ cacheReadTokens: "1976832",
+ cacheWriteTokens: "0",
+ },
+ { inputTokens: 135246 },
+ ),
+ ).toEqual({
+ input_tokens: 135246,
+ output_tokens: 5576,
+ cache_creation_input_tokens: 0,
+ cache_read_input_tokens: 0,
});
});
@@ -237,6 +258,40 @@ describe("Cursor response translation", () => {
expect(events[8]?.data.usage.output_tokens).toBe(3);
});
+ it("emits estimated input usage at stream start and finish", async () => {
+ const events = await translateCursorSse(
+ [
+ frame({ interactionUpdate: { textDelta: { text: "done" } } }),
+ frame({
+ interactionUpdate: {
+ turnEnded: {
+ inputTokens: "2116658",
+ outputTokens: "5576",
+ cacheReadTokens: "1976832",
+ },
+ },
+ }),
+ encodeConnectFrame(jsonBytes({}), 2),
+ ],
+ "msg_estimated_usage",
+ undefined,
+ 135246,
+ );
+
+ expect(events[0]?.data.message.usage).toMatchObject({
+ input_tokens: 135246,
+ output_tokens: 0,
+ cache_creation_input_tokens: 0,
+ cache_read_input_tokens: 0,
+ });
+ expect(events.find((event) => event.event === "message_delta")?.data.usage).toEqual({
+ input_tokens: 135246,
+ output_tokens: 5576,
+ cache_creation_input_tokens: 0,
+ cache_read_input_tokens: 0,
+ });
+ });
+
it("recovers XML tool_use text deltas as Anthropic tool calls", async () => {
const events = await translateCursorSse(
[
diff --git a/src/providers/cursor/translate/response.ts b/src/providers/cursor/translate/response.ts
index 43b2599..5aeff8f 100644
--- a/src/providers/cursor/translate/response.ts
+++ b/src/providers/cursor/translate/response.ts
@@ -32,16 +32,21 @@ export interface AnthropicUsage {
cache_read_input_tokens: number;
}
-export function cursorUsageToAnthropic(usage?: CursorUsage): AnthropicUsage {
- const input = toNumber(usage?.inputTokens);
+export function cursorUsageToAnthropic(
+ usage?: CursorUsage,
+ opts: { inputTokens?: number } = {},
+): AnthropicUsage {
+ const input = opts.inputTokens ?? toNumber(usage?.inputTokens);
const output = toNumber(usage?.outputTokens);
- const cacheRead = toNumber(usage?.cacheReadTokens);
- const cacheWrite = toNumber(usage?.cacheWriteTokens);
+ // Cursor's turnEnded token counters are aggregate agent-run/billing counters,
+ // not Anthropic-style current prompt-window counters. Claude Code uses these
+ // fields for active context/autocompact, so prefer our request-side input
+ // estimate and suppress Cursor cache counters.
return {
- input_tokens: Math.max(0, input - cacheRead - cacheWrite),
+ input_tokens: input,
output_tokens: output,
- cache_creation_input_tokens: cacheWrite,
- cache_read_input_tokens: cacheRead,
+ cache_creation_input_tokens: 0,
+ cache_read_input_tokens: 0,
};
}
@@ -55,6 +60,7 @@ export async function accumulateCursorResponse(
proto?: CursorProto;
onSession?: (sessionId: string) => void;
allowedToolNames?: ReadonlySet<string>;
+ inputTokens?: number;
},
): Promise<{ response: AnthropicCursorResponse; cursorSessionId?: string }> {
let thinking = "";
@@ -139,7 +145,7 @@ export async function accumulateCursorResponse(
content,
stop_reason: toolUseXml.sawToolUse ? "tool_use" : "end_turn",
stop_sequence: null,
- usage: cursorUsageToAnthropic(usage),
+ usage: cursorUsageToAnthropic(usage, { inputTokens: opts.inputTokens }),
},
};
}
@@ -155,6 +161,7 @@ export function translateCursorStream(
proto?: CursorProto;
onSession?: (sessionId: string) => void;
allowedToolNames?: ReadonlySet<string>;
+ inputTokens?: number;
},
): ReadableStream<Uint8Array> {
const encoder = new TextEncoder();
@@ -173,7 +180,8 @@ export function translateCursorStream(
messageId: opts.messageId,
model: opts.model,
emit,
- mapUsage: cursorUsageToAnthropic,
+ mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: opts.inputTokens }),
+ initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: opts.inputTokens }),
});
const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: opts.allowedToolNames });
diff --git a/src/providers/shared/anthropic-sse.ts b/src/providers/shared/anthropic-sse.ts
index 8ebabe1..574c21c 100644
--- a/src/providers/shared/anthropic-sse.ts
+++ b/src/providers/shared/anthropic-sse.ts
@@ -8,7 +8,16 @@
*/
export function emitMessageStart(
emit: (event: string, data: unknown) => void,
- opts: { messageId: string; model: string },
+ opts: {
+ messageId: string;
+ model: string;
+ usage?: {
+ input_tokens: number;
+ output_tokens: number;
+ cache_creation_input_tokens: number;
+ cache_read_input_tokens: number;
+ };
+ },
): void {
emit("message_start", {
type: "message_start",
@@ -20,7 +29,7 @@ export function emitMessageStart(
content: [],
stop_reason: null,
stop_sequence: null,
- usage: {
+ usage: opts.usage ?? {
input_tokens: 0,
output_tokens: 0,
cache_creation_input_tokens: 0,