From 8b409be6c8b9e1102932b95c62bbfb7a4be37d01 Mon Sep 17 00:00:00 2001 From: ZouR-Ma <2605315944@qq.com> Date: Wed, 11 Nov 2026 11:07:02 +0800 Subject: [PATCH 1/5] feat(providers): UTF-8 estimates, unnamed-overflow classification, stream idle watchdog Three provider-level changes behind the near-full-context failures: - Estimate prompt size from UTF-8 bytes instead of JavaScript characters, so a han character costs 0.75 token (the gateway bills about 0.61) instead of 0.25. ASCII text keeps its previous estimate; images keep 1200 tokens. - Classify the gateway's unnamed `The input you provided is invalid` rejection as overflow when the rejected prompt filled at least half the window and 95% of it with the output reservation. The size evidence is measured lazily and only for that wording, so a malformed small request keeps its own error. - Bound a provider stream by event idleness: a stream that keeps sending keep-alives while the model makes no progress no longer holds the request open indefinitely. On expiry the request is cancelled and a transient error lets the retry policy resend it. --- packages/providers/src/index.ts | 2 + packages/providers/src/utils/estimate.ts | 64 ++++++++---- packages/providers/src/utils/overflow.ts | 69 ++++++++++++- .../providers/src/utils/stream-watchdog.ts | 96 ++++++++++++++++++ .../providers/test/context-estimate.test.ts | 41 +++++++- packages/providers/test/overflow.test.ts | 48 ++++++++- .../providers/test/stream-watchdog.test.ts | 97 +++++++++++++++++++ 7 files changed, 397 insertions(+), 20 deletions(-) create mode 100644 packages/providers/src/utils/stream-watchdog.ts create mode 100644 packages/providers/test/stream-watchdog.test.ts diff --git a/packages/providers/src/index.ts b/packages/providers/src/index.ts index 300358b52..a9990c33c 100644 --- a/packages/providers/src/index.ts +++ b/packages/providers/src/index.ts @@ -40,11 +40,13 @@ export * from "./session-resources.ts"; export * from "./types.ts"; export * from "./utils/diagnostics.ts"; export * from "./utils/error-kind.ts"; +export { estimateMessageTokens, estimateTextTokens, textUtf8ByteLength } from "./utils/estimate.ts"; export * from "./utils/event-stream.ts"; export * from "./utils/incomplete-turn.ts"; export * from "./utils/json-parse.ts"; export * from "./utils/overflow.ts"; export * from "./utils/retry.ts"; +export * from "./utils/stream-watchdog.ts"; export { contentText } from "./utils/text.ts"; export * from "./utils/typebox-helpers.ts"; export { uuidv7 } from "./utils/uuid.ts"; diff --git a/packages/providers/src/utils/estimate.ts b/packages/providers/src/utils/estimate.ts index 577a2cb65..8444c82f2 100644 --- a/packages/providers/src/utils/estimate.ts +++ b/packages/providers/src/utils/estimate.ts @@ -11,8 +11,40 @@ export interface ContextUsageEstimate { lastUsageIndex: number | null; } -const CHARS_PER_TOKEN = 4; -const ESTIMATED_IMAGE_CHARS = 4800; +/** + * UTF-8 bytes per token, the unit providers actually bill. + * + * English prose and code sit near four bytes per token. CJK does not: one han + * character is three UTF-8 bytes but only ~0.75 token, while JavaScript's + * `string.length` counts it as one character and the old `length / 4` estimate + * therefore reported a quarter of its real cost. Counting bytes keeps English + * estimates unchanged and stops CJK text from being undercounted by ~2.5x, + * which is what let requests exceed the window while the host still believed + * they fit. + */ +const BYTES_PER_TOKEN = 4; +const ESTIMATED_IMAGE_TOKENS = 1200; +const NON_ASCII = /[^\x00-\x7f]/; + +/** UTF-8 byte length without allocating an encoded copy. */ +export function textUtf8ByteLength(text: string): number { + if (!NON_ASCII.test(text)) return text.length; + let bytes = text.length; + for (let i = 0; i < text.length; i++) { + const code = text.charCodeAt(i); + if (code < 0x80) continue; + if (code < 0x800) { + bytes += 1; + } else if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) { + // One astral character: two UTF-16 units already counted, four bytes in UTF-8. + bytes += 2; + i++; + } else { + bytes += 2; + } + } + return bytes; +} export function calculateContextTokens(usage: Usage): number { return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite; @@ -26,38 +58,36 @@ function safeJsonStringify(value: unknown): string { } } -function estimateTextAndImageContentChars(content: string | Array): number { - if (typeof content === "string") return content.length; - - let chars = 0; - for (const block of content) chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS; - return chars; -} - export function estimateTextTokens(text: string): number { - return Math.ceil(text.length / CHARS_PER_TOKEN); + return Math.ceil(textUtf8ByteLength(text) / BYTES_PER_TOKEN); } export function estimateTextAndImageContentTokens(content: string | Array): number { - return Math.ceil(estimateTextAndImageContentChars(content) / CHARS_PER_TOKEN); + if (typeof content === "string") return estimateTextTokens(content); + + let tokens = 0; + for (const block of content) { + tokens += block.type === "text" ? estimateTextTokens(block.text) : ESTIMATED_IMAGE_TOKENS; + } + return tokens; } export function estimateMessageTokens(message: Message): number { - let chars = 0; + let tokens = 0; if (message.role === "user") return estimateTextAndImageContentTokens(message.content); if (message.role === "toolResult") return estimateTextAndImageContentTokens(message.content); for (const block of message.content) { if (block.type === "text") { - chars += block.text.length; + tokens += estimateTextTokens(block.text); } else if (block.type === "thinking") { - chars += block.thinking.length; + tokens += estimateTextTokens(block.thinking); } else { - chars += block.name.length + safeJsonStringify(block.arguments).length; + tokens += estimateTextTokens(block.name) + estimateTextTokens(safeJsonStringify(block.arguments)); } } - return Math.ceil(chars / CHARS_PER_TOKEN); + return tokens; } function getLastAssistantUsageInfo(messages: readonly Message[]): { usage: Usage; index: number } | undefined { diff --git a/packages/providers/src/utils/overflow.ts b/packages/providers/src/utils/overflow.ts index c1e6457ff..daea11ada 100644 --- a/packages/providers/src/utils/overflow.ts +++ b/packages/providers/src/utils/overflow.ts @@ -77,16 +77,51 @@ const NON_OVERFLOW_PATTERNS = [ /too many requests/i, // Generic HTTP 429 style ]; +/** + * Wording that rejects a request without naming a reason. + * + * The Step gateway returns the same `invalid_request_error` body + * (`The input you provided is invalid [code=30003]`) when input plus the output + * reservation exceed the window, and it can also mean a genuinely malformed + * request. Matching the text alone would compact perfectly valid small requests, + * so this only counts as overflow when the caller passes size evidence proving + * the rejected request was near the window. + */ +const AMBIGUOUS_OVERFLOW_PATTERNS = [/the input you provided is invalid/i]; + +/** Share of the window a rejected request must have consumed to read the rejection as overflow. */ +export const AMBIGUOUS_OVERFLOW_WINDOW_RATIO = 0.95; + +/** + * Share of the window the prompt alone must fill. Without it, a model whose output + * limit is large relative to its window (200K window, 128K output) would read the + * same wording as overflow at about 31% of the window, compacting malformed small + * requests for nothing. + */ +export const AMBIGUOUS_OVERFLOW_MIN_INPUT_RATIO = 0.5; + +/** Prompt size of a request that was rejected, measured before it was sent. */ +export interface OverflowSizeEvidence { + /** Estimated prompt tokens of the rejected request. */ + inputTokens: number; + /** Output reservation the same request asked for. */ + maxTokens: number; +} + /** * Check if an assistant message represents a context overflow error. * - * This handles three cases: + * This handles four cases: * 1. Error-based overflow: Most providers return stopReason "error" with a * specific error message pattern. * 2. Silent overflow: Some providers accept overflow requests and return * successfully. For these, we check if usage.input exceeds the context window. * 3. Length-stop overflow: Xiaomi MiMo can return "length" with zero output when * the input fills the context window. + * 4. Unnamed rejection near the window: some gateways answer an oversized request + * with a generic invalid-request body and no reason. That wording alone is not + * enough, so those callers use {@link isUnnamedOverflowRejection} with size + * evidence instead of this function. * * ## Reliability by Provider * @@ -106,6 +141,7 @@ const NON_OVERFLOW_PATTERNS = [ * - Kimi For Coding: "exceeded model token limit: X (requested: Y)" * - DS4: "Prompt has X tokens, but the configured context size is Y tokens" * - DashScope/Qwen: "Range of input length should be [1, X]" + * - Step gateway: unnamed "The input you provided is invalid" plus size evidence * * **Unreliable detection:** * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow), @@ -162,6 +198,37 @@ export function isContextOverflow(message: AssistantMessage, contextWindow?: num return false; } +/** + * Check whether a rejection uses wording that does not name a reason, and the + * rejected request was big enough to explain it as overflow. + * + * Some gateways answer an oversized request with a generic invalid-request body + * ("The input you provided is invalid") that carries no overflow signal at all. + * The same body can also mean a genuinely malformed request, so size evidence + * decides: the prompt must fill at least {@link AMBIGUOUS_OVERFLOW_MIN_INPUT_RATIO} + * of the window, and at least {@link AMBIGUOUS_OVERFLOW_WINDOW_RATIO} once its + * output reservation is added. + * + * @param message - The assistant message to check + * @param contextWindow - Model context window + * @param evidence - Lazily measured prompt size; only called when the wording matches + * @returns true when the rejection is best explained by context overflow + */ +export function isUnnamedOverflowRejection( + message: AssistantMessage, + contextWindow: number, + evidence: () => OverflowSizeEvidence | undefined, +): boolean { + if (contextWindow <= 0 || message.stopReason !== "error" || !message.errorMessage) return false; + const text = message.errorMessage; + if (NON_OVERFLOW_PATTERNS.some((pattern) => pattern.test(text))) return false; + if (!AMBIGUOUS_OVERFLOW_PATTERNS.some((pattern) => pattern.test(text))) return false; + const size = evidence(); + if (!size || size.inputTokens < contextWindow * AMBIGUOUS_OVERFLOW_MIN_INPUT_RATIO) return false; + const requested = size.inputTokens + Math.max(0, size.maxTokens); + return requested >= contextWindow * AMBIGUOUS_OVERFLOW_WINDOW_RATIO; +} + /** * Check whether a length stop ended below the caller or model's intended output limit. * Such responses may be caused by context pressure or provider-side truncation, so callers diff --git a/packages/providers/src/utils/stream-watchdog.ts b/packages/providers/src/utils/stream-watchdog.ts new file mode 100644 index 000000000..1d930680e --- /dev/null +++ b/packages/providers/src/utils/stream-watchdog.ts @@ -0,0 +1,96 @@ +import type { AssistantMessage, AssistantMessageEvent } from "../types.ts"; +import { type AssistantMessageEventStream, createAssistantMessageEventStream } from "./event-stream.ts"; + +/** + * Default wait for the next provider event. It matches the Codex and DeepSeek harness + * stream idle windows and sits above the slowest healthy first token observed on a + * near-full 1M-token context (about 206s). + */ +export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300_000; + +export interface StreamIdleWatchdogOptions { + /** Longest wait for the next parsed provider event; 0 or less disables the watchdog. */ + idleTimeoutMs: number; + /** Cancels the underlying request once the stream has been abandoned. */ + onTimeout: () => void; + /** Response shell used when the provider has not produced a partial response yet. */ + fallback: () => AssistantMessage; +} + +/** + * Bound how long a provider stream may go without a parsed event. + * + * The HTTP idle timeout only sees bytes: a gateway that keeps sending SSE keep-alives + * while the model makes no progress holds the request open indefinitely (one request + * was observed producing 22 characters of thinking and then nothing for ~15 minutes). + * Keep-alives never become events, so this timer measures progress instead of traffic. + * + * The timer runs only while the next event is awaited. On expiry the request is + * cancelled and the consumer receives a transient error, so the existing retry policy + * resends it instead of treating the stall as a user abort. The wait is abandoned + * without waiting for the transport, because a read the abort interrupts can stay + * pending forever. + */ +export function withStreamIdleWatchdog( + source: AssistantMessageEventStream, + options: StreamIdleWatchdogOptions, +): AssistantMessageEventStream { + if (!(options.idleTimeoutMs > 0) || !Number.isFinite(options.idleTimeoutMs)) return source; + const output = createAssistantMessageEventStream(); + void pump(source, output, options); + return output; +} + +async function pump( + source: AssistantMessageEventStream, + output: AssistantMessageEventStream, + options: StreamIdleWatchdogOptions, +): Promise { + const iterator = source[Symbol.asyncIterator](); + let partial: AssistantMessage | undefined; + const fail = (errorMessage: string, transient: boolean): void => { + output.push({ + type: "error", + reason: "error", + error: { + ...(partial ?? options.fallback()), + stopReason: "error", + errorMessage, + ...(transient ? { errorKind: "transient" as const } : {}), + }, + }); + }; + for (;;) { + let timer: ReturnType | undefined; + const expired = new Promise<"timeout">((resolve) => { + timer = setTimeout(() => resolve("timeout"), options.idleTimeoutMs); + }); + let next: IteratorResult | "timeout"; + try { + next = await Promise.race([iterator.next(), expired]); + } catch (error) { + fail(error instanceof Error ? error.message : String(error), false); + return; + } finally { + clearTimeout(timer); + } + if (next === "timeout") { + options.onTimeout(); + // Detached: the cancelled read may never settle. + void iterator.return?.(undefined).catch(() => {}); + fail( + `Provider stream stalled: no response data for ${Math.round(options.idleTimeoutMs / 1000)}s (stream idle timeout)`, + true, + ); + return; + } + if (next.done) { + output.end(); + return; + } + const event = next.value; + if ("partial" in event) partial = event.partial; + output.push(event); + if (event.type === "done" || event.type === "error") return; + } +} diff --git a/packages/providers/test/context-estimate.test.ts b/packages/providers/test/context-estimate.test.ts index a01f204be..25b4baa6d 100644 --- a/packages/providers/test/context-estimate.test.ts +++ b/packages/providers/test/context-estimate.test.ts @@ -2,7 +2,7 @@ import { Type } from "typebox"; import { describe, expect, it } from "vitest"; import { buildBaseOptions } from "../src/api/simple-options.ts"; import type { AssistantMessage, Context, Model, Usage } from "../src/types.ts"; -import { estimateContextTokens } from "../src/utils/estimate.ts"; +import { estimateContextTokens, estimateTextTokens, textUtf8ByteLength } from "../src/utils/estimate.ts"; function createUsage(totalTokens: number): Usage { return { @@ -166,3 +166,42 @@ describe("context token estimation", () => { }); }); }); + +describe("UTF-8 token estimation", () => { + it("keeps ASCII text at four characters per token", () => { + const text = "a".repeat(4_000); + expect(textUtf8ByteLength(text)).toBe(4_000); + expect(estimateTextTokens(text)).toBe(1_000); + }); + + it("prices CJK text at its real UTF-8 cost instead of a quarter of it", () => { + // One han character is three UTF-8 bytes: ~0.75 token, not ~0.25. + const text = "构建失败：解析器在第四十二行抛出断言错误".repeat(100); + expect(textUtf8ByteLength(text)).toBe(text.length * 3); + expect(estimateTextTokens(text)).toBe(Math.ceil((text.length * 3) / 4)); + expect(estimateTextTokens(text)).toBeGreaterThan(Math.ceil(text.length / 4) * 2.9); + }); + + it("counts astral characters as four bytes", () => { + const emoji = "\u{1f600}"; + expect(textUtf8ByteLength(emoji)).toBe(4); + expect(estimateTextTokens(emoji.repeat(250))).toBe(250); + }); + + it("prices mixed content block by block", () => { + const context: Context = { + messages: [ + { + role: "user", + content: [ + { type: "text", text: "ab".repeat(1_000) }, + { type: "image", mimeType: "image/png", data: "ignored" }, + ], + timestamp: 1, + }, + ], + }; + // 2,000 ASCII bytes = 500 tokens, plus the fixed 1,200-token image estimate. + expect(estimateContextTokens(context).tokens).toBe(1_700); + }); +}); diff --git a/packages/providers/test/overflow.test.ts b/packages/providers/test/overflow.test.ts index 9066fcc49..43e7341ac 100644 --- a/packages/providers/test/overflow.test.ts +++ b/packages/providers/test/overflow.test.ts @@ -1,6 +1,6 @@ import { describe, expect, it } from "vitest"; import type { AssistantMessage } from "../src/types.ts"; -import { isContextOverflow, isRecoverableLength } from "../src/utils/overflow.ts"; +import { isContextOverflow, isRecoverableLength, isUnnamedOverflowRejection } from "../src/utils/overflow.ts"; function createErrorMessage(errorMessage: string): AssistantMessage { return { @@ -175,3 +175,49 @@ describe("isContextOverflow", () => { expect(isContextOverflow(message, 200000)).toBe(false); }); }); + +describe("unnamed overflow rejection", () => { + const gateway = (message: string) => createErrorMessage(message); + const unnamed = + '400 {"type":"error","error":{"type":"invalid_request_error","message":"The input you provided is invalid [trace_id=abc code=30003]"}}'; + + it("treats a near-window request as overflow", () => { + const evidence = () => ({ inputTokens: 952_000, maxTokens: 128_000 }); + expect(isUnnamedOverflowRejection(gateway(unnamed), 1_000_000, evidence)).toBe(true); + }); + + it("does not treat the same wording on a small request as overflow", () => { + const evidence = () => ({ inputTokens: 20_000, maxTokens: 128_000 }); + expect(isUnnamedOverflowRejection(gateway(unnamed), 1_000_000, evidence)).toBe(false); + }); + + it("does not measure unless the wording matches", () => { + let measured = 0; + const evidence = () => { + measured++; + return { inputTokens: 952_000, maxTokens: 128_000 }; + }; + expect(isUnnamedOverflowRejection(gateway("429 rate limit exceeded"), 1_000_000, evidence)).toBe(false); + expect(measured).toBe(0); + }); + + it("leaves text-matched overflow to isContextOverflow", () => { + const evidence = () => ({ inputTokens: 952_000, maxTokens: 128_000 }); + const message = gateway("prompt is too long: 213462 tokens > 200000 maximum"); + expect(isContextOverflow(message, 1_000_000)).toBe(true); + expect(isUnnamedOverflowRejection(message, 1_000_000, evidence)).toBe(false); + }); + + it("needs the prompt alone to fill half the window", () => { + // 70K + 128K = 198K passes the 95% check on a 200K window, but 70K of input is too + // small a share to blame the rejection on size. + const evidence = () => ({ inputTokens: 70_000, maxTokens: 128_000 }); + expect(isUnnamedOverflowRejection(gateway(unnamed), 200_000, evidence)).toBe(false); + const nearFull = () => ({ inputTokens: 120_000, maxTokens: 128_000 }); + expect(isUnnamedOverflowRejection(gateway(unnamed), 200_000, nearFull)).toBe(true); + }); + + it("requires size evidence", () => { + expect(isUnnamedOverflowRejection(gateway(unnamed), 1_000_000, () => undefined)).toBe(false); + }); +}); diff --git a/packages/providers/test/stream-watchdog.test.ts b/packages/providers/test/stream-watchdog.test.ts new file mode 100644 index 000000000..1e53dc860 --- /dev/null +++ b/packages/providers/test/stream-watchdog.test.ts @@ -0,0 +1,97 @@ +import { describe, expect, it } from "vitest"; +import type { AssistantMessage } from "../src/types.ts"; +import { createAssistantMessageEventStream } from "../src/utils/event-stream.ts"; +import { isRetryableAssistantError } from "../src/utils/retry.ts"; +import { withStreamIdleWatchdog } from "../src/utils/stream-watchdog.ts"; + +function shell(): AssistantMessage { + return { + role: "assistant", + content: [], + api: "faux", + provider: "faux", + model: "faux-1", + usage: { + input: 0, + output: 0, + cacheRead: 0, + cacheWrite: 0, + totalTokens: 0, + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, + }, + stopReason: "stop", + timestamp: 1, + }; +} + +const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)); + +describe("stream idle watchdog", () => { + it("ends a stalled stream with a retryable error and cancels the request", async () => { + const source = createAssistantMessageEventStream(); + let cancelled = 0; + const watched = withStreamIdleWatchdog(source, { + idleTimeoutMs: 30, + onTimeout: () => cancelled++, + fallback: shell, + }); + const partial = { ...shell(), content: [{ type: "thinking" as const, thinking: "only a little" }] }; + source.push({ type: "start", partial }); + source.push({ type: "thinking_delta", contentIndex: 0, delta: "only a little", partial }); + // No further events: a gateway that keeps the socket alive with pings looks like this. + + const result = await watched.result(); + expect(cancelled).toBe(1); + expect(result.stopReason).toBe("error"); + expect(result.errorMessage).toMatch(/stream idle timeout/); + expect(result.content).toEqual(partial.content); + expect(isRetryableAssistantError(result)).toBe(true); + }); + + it("uses the fallback shell when no event ever arrives", async () => { + const watched = withStreamIdleWatchdog(createAssistantMessageEventStream(), { + idleTimeoutMs: 20, + onTimeout: () => {}, + fallback: shell, + }); + const result = await watched.result(); + expect(result).toMatchObject({ provider: "faux", stopReason: "error", errorKind: "transient", content: [] }); + }); + + it("does not interrupt a slow stream that keeps making progress", async () => { + const source = createAssistantMessageEventStream(); + let cancelled = 0; + const watched = withStreamIdleWatchdog(source, { + idleTimeoutMs: 60, + onTimeout: () => cancelled++, + fallback: shell, + }); + const events: string[] = []; + const consume = (async () => { + for await (const event of watched) events.push(event.type); + })(); + const partial = shell(); + source.push({ type: "start", partial }); + for (let i = 0; i < 4; i++) { + await sleep(30); + source.push({ type: "text_delta", contentIndex: 0, delta: "x", partial }); + } + source.push({ type: "done", reason: "stop", message: { ...partial, content: [{ type: "text", text: "xxxx" }] } }); + await consume; + expect(cancelled).toBe(0); + expect(events.at(-1)).toBe("done"); + expect((await watched.result()).stopReason).toBe("stop"); + }); + + it("passes a provider abort through unchanged", async () => { + const source = createAssistantMessageEventStream(); + const watched = withStreamIdleWatchdog(source, { idleTimeoutMs: 1_000, onTimeout: () => {}, fallback: shell }); + source.push({ type: "error", reason: "aborted", error: { ...shell(), stopReason: "aborted" } }); + expect((await watched.result()).stopReason).toBe("aborted"); + }); + + it("returns the source unchanged when disabled", () => { + const source = createAssistantMessageEventStream(); + expect(withStreamIdleWatchdog(source, { idleTimeoutMs: 0, onTimeout: () => {}, fallback: shell })).toBe(source); + }); +}); From 796c66377d60ccf8bdac881e24eb8207b9d336cd Mon Sep 17 00:00:00 2001 From: ZouR-Ma <2605315944@qq.com> Date: Wed, 11 Nov 2026 11:07:08 +0800 Subject: [PATCH 2/5] fix(compaction): byte-accurate estimates, cut-point fallback, unnamed overflow in summaries - Both message estimators, the lightweight projection and the summary request's own sizing now price text by bytes. - When the newest message alone exceeded keepRecentTokens and was a tool result, no cut point qualified, so the whole history was kept and automatic compaction silently did nothing. Fall back to the newest valid cut point, as upstream pi does. - A summary request rejected with the gateway's unnamed invalid-request body is now reduced and retried instead of failing unchanged. - CLM's usage calibration may now fall below 1, because byte pricing is deliberately conservative for CJK and only observed usage can correct it. --- .../src/harness/compaction/compaction.ts | 57 ++++++------- .../harness/compaction/projection-content.ts | 12 +-- .../test/harness/compaction-estimate.test.ts | 77 +++++++++++++++++ .../src/core/compaction/compaction.ts | 84 ++++++++++--------- .../live-context/auto-compaction.ts | 4 + .../compaction/live-context/auto-options.ts | 8 ++ .../core/compaction/live-context/manager.ts | 10 ++- .../core/compaction/summary-diagnostics.ts | 3 +- .../src/core/compaction/summary-overflow.ts | 10 +-- .../src/core/compaction/trigger-policy.ts | 11 +-- .../test/auto-clm-options.test.ts | 10 ++- .../test/compaction-byte-estimate.test.ts | 61 ++++++++++++++ .../test/compaction-overflow-recovery.test.ts | 57 +++++++++++++ .../test/compaction-trigger-policy.test.ts | 16 ++-- packages/coding-agent/test/compaction.test.ts | 38 +++++++++ 15 files changed, 355 insertions(+), 103 deletions(-) create mode 100644 packages/agent-core/test/harness/compaction-estimate.test.ts create mode 100644 packages/coding-agent/test/compaction-byte-estimate.test.ts diff --git a/packages/agent-core/src/harness/compaction/compaction.ts b/packages/agent-core/src/harness/compaction/compaction.ts index 8fca9ad43..d6fe78363 100644 --- a/packages/agent-core/src/harness/compaction/compaction.ts +++ b/packages/agent-core/src/harness/compaction/compaction.ts @@ -3,6 +3,7 @@ import { type AssistantMessage, type Context, contentText, + estimateTextTokens, type Model, type Models, type RetryCallbacks, @@ -245,61 +246,53 @@ export function shouldCompact(contextTokens: number, contextWindow: number, sett return contextTokens > contextWindow - settings.reserveTokens; } -const ESTIMATED_IMAGE_CHARS = 4800; +/** Fixed per-image estimate; images carry no text to measure by bytes. */ +const ESTIMATED_IMAGE_TOKENS = 1200; -function estimateTextAndImageContentChars(content: string | Array<{ type: string; text?: string }>): number { - if (typeof content === "string") { - return content.length; - } +/** Content blocks mix text (priced by UTF-8 bytes) with images (fixed estimate). */ +function estimateTextAndImageTokens(content: string | Array<{ type: string; text?: string }>): number { + if (typeof content === "string") return estimateTextTokens(content); - let chars = 0; + let tokens = 0; for (const block of content) { - if (block.type === "text" && block.text) { - chars += block.text.length; - } else if (block.type === "image") { - chars += ESTIMATED_IMAGE_CHARS; - } + if (block.type === "text" && block.text) tokens += estimateTextTokens(block.text); + else if (block.type === "image") tokens += ESTIMATED_IMAGE_TOKENS; } - return chars; + return tokens; } -/** Estimate token count for one message using a conservative character heuristic. */ +/** Estimate token count for one message from its UTF-8 payload size. */ export function estimateTokens(message: AgentMessage): number { - let chars = 0; - switch (message.role) { case "user": { - chars = estimateTextAndImageContentChars( + return estimateTextAndImageTokens( (message as { content: string | Array<{ type: string; text?: string }> }).content, ); - return Math.ceil(chars / 4); } case "assistant": { const assistant = message as AssistantMessage; + let tokens = 0; for (const block of assistant.content) { if (block.type === "text") { - chars += block.text.length; + tokens += estimateTextTokens(block.text); } else if (block.type === "thinking") { - chars += block.thinking.length; + tokens += estimateTextTokens(block.thinking); } else if (block.type === "toolCall") { - chars += block.name.length + safeJsonStringify(block.arguments).length; + tokens += estimateTextTokens(block.name) + estimateTextTokens(safeJsonStringify(block.arguments)); } } - return Math.ceil(chars / 4); + return tokens; } case "custom": case "toolResult": { - chars = estimateTextAndImageContentChars(message.content); - return Math.ceil(chars / 4); + return estimateTextAndImageTokens(message.content); } case "bashExecution": { - chars = message.command.length + message.output.length; - return Math.ceil(chars / 4); + return estimateTextTokens(message.command) + estimateTextTokens(message.output); } case "branchSummary": case "compactionSummary": { - chars = message.summary.length; - return Math.ceil(chars / 4); + return estimateTextTokens(message.summary); } } @@ -387,12 +380,10 @@ export function findCutPoint( const messageTokens = estimateTokens(entry.message as AgentMessage); accumulatedTokens += messageTokens; if (accumulatedTokens >= keepRecentTokens) { - for (let c = 0; c < cutPoints.length; c++) { - if (cutPoints[c] >= i) { - cutIndex = cutPoints[c]; - break; - } - } + // Closest valid cut point at or after this entry. When the newest message alone exceeds + // the budget and is a tool result (never a cut point), nothing qualifies; keep from the + // newest cut point instead of keeping everything, which left nothing to summarize. + cutIndex = cutPoints.find((candidate) => candidate >= i) ?? cutPoints[cutPoints.length - 1]; break; } } diff --git a/packages/agent-core/src/harness/compaction/projection-content.ts b/packages/agent-core/src/harness/compaction/projection-content.ts index e081ceb0e..782987ad2 100644 --- a/packages/agent-core/src/harness/compaction/projection-content.ts +++ b/packages/agent-core/src/harness/compaction/projection-content.ts @@ -5,6 +5,7 @@ */ import type { ImageContent, Message, TextContent, ToolResultMessage, UserMessage } from "@step-harness/providers"; +import { estimateMessageTokens as estimateProviderMessageTokens } from "@step-harness/providers"; // ============================================================================ // Rewrite markers @@ -30,7 +31,6 @@ export function containsProjectionMarker(text: string): boolean { // Content sizing // ============================================================================ -const CHARS_PER_TOKEN = 4; const ESTIMATED_IMAGE_CHARS = 4800; function safeJsonStringify(value: unknown): string { @@ -64,14 +64,16 @@ export function totalContentChars(messages: readonly Message[]): number { return chars; } -/** chars/4 estimate, deliberately simple and deterministic. */ +/** UTF-8 bytes/4 estimate shared with the compaction trigger, deliberately simple and deterministic. */ export function estimateProjectionTokens(messages: readonly Message[]): number { - return Math.ceil(totalContentChars(messages) / CHARS_PER_TOKEN); + let tokens = 0; + for (const message of messages) tokens += estimateMessageTokens(message); + return tokens; } -/** chars/4 estimate for a single message. */ +/** UTF-8 bytes/4 estimate for a single message; CJK text is priced at its real cost. */ export function estimateMessageTokens(message: Message): number { - return Math.ceil(messageContentChars(message) / CHARS_PER_TOKEN); + return estimateProviderMessageTokens(message); } // ============================================================================ diff --git a/packages/agent-core/test/harness/compaction-estimate.test.ts b/packages/agent-core/test/harness/compaction-estimate.test.ts new file mode 100644 index 000000000..5010b07f0 --- /dev/null +++ b/packages/agent-core/test/harness/compaction-estimate.test.ts @@ -0,0 +1,77 @@ +import type { AssistantMessage } from "@step-harness/providers"; +import { describe, expect, it } from "vitest"; +import { estimateTokens } from "../../src/harness/compaction/compaction.ts"; +import { estimateMessageTokens } from "../../src/harness/compaction/projection-content.ts"; + +const han = "构建失败：解析器在第四十二行抛出断言错误"; + +function assistant(content: AssistantMessage["content"]): AssistantMessage { + return { + role: "assistant", + content, + api: "faux", + provider: "faux", + model: "faux-1", + usage: { + input: 0, + output: 0, + cacheRead: 0, + cacheWrite: 0, + totalTokens: 0, + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, + }, + stopReason: "stop", + timestamp: 1, + }; +} + +describe("harness token estimate", () => { + it("keeps ASCII messages at four characters per token", () => { + expect(estimateTokens({ role: "user", content: "a".repeat(400), timestamp: 1 })).toBe(100); + }); + + it("prices CJK text by UTF-8 bytes", () => { + const text = han.repeat(10); + expect(estimateTokens({ role: "user", content: text, timestamp: 1 })).toBe(Math.ceil((text.length * 3) / 4)); + }); + + it("prices assistant text, thinking and tool arguments by bytes", () => { + const message = assistant([ + { type: "text", text: han }, + { type: "thinking", thinking: han }, + { type: "toolCall", id: "1", name: "run", arguments: { command: han } }, + ]); + expect(estimateTokens(message)).toBeGreaterThan(Math.ceil((han.length * 3 * 3) / 4) - 1); + }); + + it("keeps the fixed image estimate", () => { + expect( + estimateTokens({ + role: "user", + content: [{ type: "image", mimeType: "image/png", data: "x" }], + timestamp: 1, + }), + ).toBe(1200); + }); + + it("prices bash output by bytes", () => { + expect( + estimateTokens({ + role: "bashExecution", + command: "cat", + output: han, + exitCode: 0, + cancelled: false, + truncated: false, + timestamp: 1, + }), + ).toBe(Math.ceil(3 / 4) + Math.ceil((han.length * 3) / 4)); + }); + + it("uses the same byte pricing in the lightweight projection", () => { + const text = han.repeat(10); + expect(estimateMessageTokens({ role: "user", content: text, timestamp: 1 })).toBe( + Math.ceil((text.length * 3) / 4), + ); + }); +}); diff --git a/packages/coding-agent/src/core/compaction/compaction.ts b/packages/coding-agent/src/core/compaction/compaction.ts index 0c6b3d790..b2060248e 100644 --- a/packages/coding-agent/src/core/compaction/compaction.ts +++ b/packages/coding-agent/src/core/compaction/compaction.ts @@ -8,10 +8,13 @@ import type { AgentMessage, StreamFn, ThinkingLevel } from "@step-harness/agent-core"; import { contentText, + estimateTextTokens, isContextOverflow, + isUnnamedOverflowRejection, type RetryCallbacks, type RetryPolicy, retryAssistantCall, + textUtf8ByteLength, uuidv7, } from "@step-harness/providers"; import type { AssistantMessage, Context, Model, SimpleStreamOptions, Usage } from "@step-harness/providers/compat"; @@ -270,64 +273,57 @@ export function shouldCompact(contextTokens: number, contextWindow: number, sett // Cut point detection // ============================================================================ -const ESTIMATED_IMAGE_CHARS = 4800; +/** Fixed per-image estimate; images carry no text to measure by bytes. */ +const ESTIMATED_IMAGE_TOKENS = 1200; -function estimateTextAndImageContentChars(content: string | Array<{ type: string; text?: string }>): number { - if (typeof content === "string") { - return content.length; - } +/** Content blocks mix text (priced by UTF-8 bytes) with images (fixed estimate). */ +function estimateTextAndImageTokens(content: string | Array<{ type: string; text?: string }>): number { + if (typeof content === "string") return estimateTextTokens(content); - let chars = 0; + let tokens = 0; for (const block of content) { - if (block.type === "text" && block.text) { - chars += block.text.length; - } else if (block.type === "image") { - chars += ESTIMATED_IMAGE_CHARS; - } + if (block.type === "text" && block.text) tokens += estimateTextTokens(block.text); + else if (block.type === "image") tokens += ESTIMATED_IMAGE_TOKENS; } - return chars; + return tokens; } /** - * Estimate token count for a message using chars/4 heuristic. - * This is conservative (overestimates tokens). + * Estimate token count for a message from its UTF-8 payload size. + * ASCII text keeps the previous four-bytes-per-token result; CJK text is + * counted at its real cost instead of a quarter of it. */ export function estimateTokens(message: AgentMessage): number { - let chars = 0; - switch (message.role) { case "user": { - chars = estimateTextAndImageContentChars( + return estimateTextAndImageTokens( (message as { content: string | Array<{ type: string; text?: string }> }).content, ); - return Math.ceil(chars / 4); } case "assistant": { const assistant = message as AssistantMessage; + let tokens = 0; for (const block of assistant.content) { if (block.type === "text") { - chars += block.text.length; + tokens += estimateTextTokens(block.text); } else if (block.type === "thinking") { - chars += block.thinking.length; + tokens += estimateTextTokens(block.thinking); } else if (block.type === "toolCall") { - chars += block.name.length + safeJsonStringify(block.arguments).length; + tokens += estimateTextTokens(block.name) + estimateTextTokens(safeJsonStringify(block.arguments)); } } - return Math.ceil(chars / 4); + return tokens; } case "custom": case "toolResult": { - chars = estimateTextAndImageContentChars(message.content); - return Math.ceil(chars / 4); + return estimateTextAndImageTokens(message.content); } case "bashExecution": { - chars = message.command.length + message.output.length; - return Math.ceil(chars / 4); + return estimateTextTokens(message.command) + estimateTextTokens(message.output); } case "branchSummary": case "compactionSummary": { - chars = message.summary.length; - return Math.ceil(chars / 4); + return estimateTextTokens(message.summary); } } @@ -456,13 +452,10 @@ export function findCutPoint( // Check if we've exceeded the budget if (accumulatedTokens >= keepRecentTokens) { - // Find the closest valid cut point at or after this entry - for (let c = 0; c < cutPoints.length; c++) { - if (cutPoints[c] >= i) { - cutIndex = cutPoints[c]; - break; - } - } + // Closest valid cut point at or after this entry. When the newest message alone exceeds + // the budget and is a tool result (never a cut point), nothing qualifies; keep from the + // newest cut point instead of keeping everything, which left nothing to summarize. + cutIndex = cutPoints.find((candidate) => candidate >= i) ?? cutPoints[cutPoints.length - 1]; break; } } @@ -732,10 +725,10 @@ async function completeSummaryWithOverflowRecovery( ): Promise { let conversation = serializeConversation(convertToLlm(messages)); let context = buildSummarizationContext(buildPrompt(conversation)); - const promptOverhead = buildPrompt("").length; - const estimateRequestTokens = (conversationChars: number) => - Math.ceil(SUMMARIZATION_SYSTEM_PROMPT.length / 4) + Math.ceil((promptOverhead + conversationChars) / 4); - const originalTokens = estimateRequestTokens(conversation.length); + const promptOverheadBytes = textUtf8ByteLength(buildPrompt("")); + const estimateRequestTokens = (conversationBytes: number) => + estimateTextTokens(SUMMARIZATION_SYSTEM_PROMPT) + Math.ceil((promptOverheadBytes + conversationBytes) / 4); + const originalTokens = estimateRequestTokens(textUtf8ByteLength(conversation)); let rejectedTokens = originalTokens; let reductions = 0; let reduceSource: ReturnType; @@ -771,7 +764,16 @@ async function completeSummaryWithOverflowRecovery( usage = usage ? combineUsage(usage, response.usage) : response.usage; if (options.signal?.aborted) throw new Error("Compaction cancelled"); // Do not infer overflow from successful usage or empty/length-limited output. - if (response.stopReason !== "error" || !isContextOverflow(response)) return response; + const overflowEvidence = () => ({ + inputTokens: estimateRequestTokens(textUtf8ByteLength(conversation)), + maxTokens: requestOptions.maxTokens ?? model.maxTokens ?? 0, + }); + if ( + response.stopReason !== "error" || + (!isContextOverflow(response, model.contextWindow) && + !isUnnamedOverflowRejection(response, model.contextWindow, overflowEvidence)) + ) + return response; const fraction = SUMMARY_OVERFLOW_TARGETS[reductions]; if (fraction === undefined) { @@ -789,7 +791,7 @@ async function completeSummaryWithOverflowRecovery( } reductions++; conversation = reduced; - rejectedTokens = estimateRequestTokens(conversation.length); + rejectedTokens = estimateRequestTokens(textUtf8ByteLength(conversation)); context = buildSummarizationContext(buildPrompt(conversation)); } }; diff --git a/packages/coding-agent/src/core/compaction/live-context/auto-compaction.ts b/packages/coding-agent/src/core/compaction/live-context/auto-compaction.ts index 88d9cebd9..82ca21c53 100644 --- a/packages/coding-agent/src/core/compaction/live-context/auto-compaction.ts +++ b/packages/coding-agent/src/core/compaction/live-context/auto-compaction.ts @@ -169,6 +169,10 @@ export class AutoClmController { cachedJson = false; request = makeRequest(false); } + // Without a reusable prefix the provider recomputes the whole request before the task can + // start. Past this size native compaction is cheaper and leaves a much smaller context. + const coldLimit = input.settings.coldMaxPrefillTokens; + if (!cachedJson && coldLimit > 0 && this.live.estimate(request) > coldLimit) return skipped("cold-prefill"); const result: AutoClmResult = { attempted: true, accepted: false, diff --git a/packages/coding-agent/src/core/compaction/live-context/auto-options.ts b/packages/coding-agent/src/core/compaction/live-context/auto-options.ts index fca5e7777..48732b006 100644 --- a/packages/coding-agent/src/core/compaction/live-context/auto-options.ts +++ b/packages/coding-agent/src/core/compaction/live-context/auto-options.ts @@ -10,6 +10,12 @@ export interface AutoClmSettings { maxOutputTokens: number; minSavingsTokens: number; minSavingsRatio: number; + /** + * Largest maintenance request sent without a reusable cached prefix; 0 disables the bound. + * A cold maintenance request recomputes the whole context before the task can start + * (about 30s measured at 975K tokens), so above this size native compaction is used. + */ + coldMaxPrefillTokens: number; } export const DEFAULT_AUTO_CLM_SETTINGS: Readonly = Object.freeze({ @@ -21,6 +27,7 @@ export const DEFAULT_AUTO_CLM_SETTINGS: Readonly = Object.freez maxOutputTokens: 8_192, minSavingsTokens: 1_024, minSavingsRatio: 0.05, + coldMaxPrefillTokens: 262_144, }); function number(value: unknown, fallback: number, min: number, max: number, integer = false): number { @@ -52,6 +59,7 @@ export function resolveAutoClmSettings(settings?: Partial): Aut maxOutputTokens: number(raw.maxOutputTokens, defaults.maxOutputTokens, 512, 32_768, true), minSavingsTokens: number(raw.minSavingsTokens, defaults.minSavingsTokens, 1, 1_000_000, true), minSavingsRatio: number(raw.minSavingsRatio, defaults.minSavingsRatio, 0.01, 0.5), + coldMaxPrefillTokens: number(raw.coldMaxPrefillTokens, defaults.coldMaxPrefillTokens, 0, 100_000_000, true), }; } diff --git a/packages/coding-agent/src/core/compaction/live-context/manager.ts b/packages/coding-agent/src/core/compaction/live-context/manager.ts index 23f0286d0..edaeeacd2 100644 --- a/packages/coding-agent/src/core/compaction/live-context/manager.ts +++ b/packages/coding-agent/src/core/compaction/live-context/manager.ts @@ -4,6 +4,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import type { AgentMessage } from "@step-harness/agent-core"; import type { AssistantMessage, Context, ToolResultMessage } from "@step-harness/providers"; +import { estimateTextTokens } from "@step-harness/providers"; import type { CustomMessage } from "../../messages.ts"; import { buildContextEntries, type SessionManager, sessionEntryToContextMessages } from "../../session-manager.ts"; import { resolveToCwd } from "../../tools/path-utils.ts"; @@ -559,8 +560,9 @@ export class LiveContextManager { } estimate(context: Context): number { - const chars = (context.systemPrompt?.length ?? 0) + JSON.stringify(context.tools ?? []).length; - const raw = Math.ceil(chars / 4) + sumTokens(context.messages); + const overhead = + estimateTextTokens(context.systemPrompt ?? "") + estimateTextTokens(JSON.stringify(context.tools ?? [])); + const raw = overhead + sumTokens(context.messages); return Math.ceil(raw * this.factor); } recordRequest(context: Context, model: string): number { @@ -581,7 +583,9 @@ export class LiveContextManager { return; const observed = message.usage.input + message.usage.cacheRead + message.usage.cacheWrite; if (observed > 0 && request.tokens > 0) - this.factor = Math.max(1, Math.min(4, 0.75 * this.factor + (0.25 * observed) / request.tokens)); + // Byte pricing slightly overestimates CJK (0.75 vs ~0.6 token per character), so the + // factor may fall below 1; it still cannot collapse below half the heuristic. + this.factor = Math.max(0.5, Math.min(4, 0.75 * this.factor + (0.25 * observed) / request.tokens)); } /** Project the same source ranges chosen by the existing compactor; retain its prompts and skill/file tracking. */ diff --git a/packages/coding-agent/src/core/compaction/summary-diagnostics.ts b/packages/coding-agent/src/core/compaction/summary-diagnostics.ts index b9d5f260e..89755cb41 100644 --- a/packages/coding-agent/src/core/compaction/summary-diagnostics.ts +++ b/packages/coding-agent/src/core/compaction/summary-diagnostics.ts @@ -1,4 +1,5 @@ import type { AssistantMessage, Context, Model, RetryPolicy, SimpleStreamOptions } from "@step-harness/providers"; +import { estimateTextTokens } from "@step-harness/providers"; import { redactSecretString } from "../../step/secret-redaction.ts"; export interface SummaryRequestDiagnostics { @@ -45,7 +46,7 @@ export function createSummaryDiagnostics( contextWindow: model.contextWindow, modelMaxTokens: model.maxTokens, selectedMaxTokens: options.maxTokens, - inputTokensEstimated: Math.ceil(JSON.stringify(context).length / 4), + inputTokensEstimated: estimateTextTokens(JSON.stringify(context)), reasoning: options.reasoning ?? "off", attempts: 0, durationMs: 0, diff --git a/packages/coding-agent/src/core/compaction/summary-overflow.ts b/packages/coding-agent/src/core/compaction/summary-overflow.ts index 716b7bf95..62b940f4a 100644 --- a/packages/coding-agent/src/core/compaction/summary-overflow.ts +++ b/packages/coding-agent/src/core/compaction/summary-overflow.ts @@ -1,6 +1,6 @@ /** Source-history reduction used only after a summary request is rejected for context overflow. */ import type { AgentMessage } from "@step-harness/agent-core"; -import { contentText } from "@step-harness/providers"; +import { contentText, textUtf8ByteLength } from "@step-harness/providers"; import { convertToLlm } from "../messages.ts"; import { serializeConversation } from "./utils.ts"; @@ -45,7 +45,7 @@ function groupMessages(messages: AgentMessage[]): AgentMessage[][] | undefined { */ export function createSummarySourceReducer( messages: AgentMessage[], - estimateRequestTokens: (conversationChars: number) => number, + estimateRequestTokens: (conversationBytes: number) => number, ): SourceReducer | undefined { const groups = groupMessages(messages); if (!groups?.length) return undefined; @@ -79,7 +79,7 @@ export function createSummarySourceReducer( index >= tailStart || group.some((message) => message.role === "compactionSummary" || message.role === "branchSummary"), })); - let textChars = sources.reduce((sum, source) => sum + source.text.length, 0); + let textBytes = sources.reduce((sum, source) => sum + textUtf8ByteLength(source.text), 0); let textCount = sources.filter((source) => source.text.length > 0).length; let nextGroup = 0; let omitted = 0; @@ -88,12 +88,12 @@ export function createSummarySourceReducer( while (nextGroup < sources.length) { const source = sources[nextGroup++]; if (source.protected || !source.text) continue; - textChars -= source.text.length; + textBytes -= textUtf8ByteLength(source.text); textCount--; source.text = ""; omitted++; const note = `[${omitted} older message groups omitted after context overflow]\n\n`; - const tokens = estimateRequestTokens(note.length + textChars + Math.max(0, textCount - 1) * 2); + const tokens = estimateRequestTokens(textUtf8ByteLength(note) + textBytes + Math.max(0, textCount - 1) * 2); // A large earlier removal may already be below the next target. Still require // a strictly smaller payload: never submit the same rejected request again. if (tokens <= targetTokens && tokens < rejectedTokens) { diff --git a/packages/coding-agent/src/core/compaction/trigger-policy.ts b/packages/coding-agent/src/core/compaction/trigger-policy.ts index 2c8752cff..c4d91b81f 100644 --- a/packages/coding-agent/src/core/compaction/trigger-policy.ts +++ b/packages/coding-agent/src/core/compaction/trigger-policy.ts @@ -4,9 +4,9 @@ * The threshold is a fraction of the model's context window, capped so the * next response keeps usable output room. Providers clamp each request's * `max_tokens` to `contextWindow - input - CONTEXT_SAFETY_TOKENS`; on a large - * window the remaining fraction covers that margin and estimation error, but - * on a small window 10% can be smaller than the margin itself (about 3.3K - * tokens of a 32K window against a 4,096-token margin), which would clamp + * window the remaining 15% covers that margin and estimation error, but on a + * small window it can be smaller than the margin plus the response reservation + * (about 4.9K tokens of a 32K window against 4,096 + 8,192), which would clamp * output to almost nothing before compaction fires. See * {@link resolveCompactionThreshold}. */ @@ -15,7 +15,7 @@ import { CONTEXT_SAFETY_TOKENS } from "@step-harness/providers"; export type CompactionTriggerPolicy = "v2" | "legacy"; -export const DEFAULT_COMPACTION_TRIGGER_RATIO = 0.9; +export const DEFAULT_COMPACTION_TRIGGER_RATIO = 0.85; export const MIN_COMPACTION_TRIGGER_RATIO = 0.5; export const MAX_COMPACTION_TRIGGER_RATIO = 0.95; @@ -159,7 +159,8 @@ function responseHeadroomCeiling(model: CompactionTriggerModel): number { * | 16,384 | 8,192 | 50% (floor) | * | 32,768 | 20,480 | 62.5% | * | 65,536 | 53,248 | 81.25% | - * | 131,072 and larger | `contextWindow * 0.9` | 90% | + * | 131,072 | 111,411 | 85% | + * | 1,000,000 | 850,000 | 85% | * * `tokenLimit` and an explicit legacy reserve can only move it earlier. */ diff --git a/packages/coding-agent/test/auto-clm-options.test.ts b/packages/coding-agent/test/auto-clm-options.test.ts index af60fcf86..3855c32c4 100644 --- a/packages/coding-agent/test/auto-clm-options.test.ts +++ b/packages/coding-agent/test/auto-clm-options.test.ts @@ -11,8 +11,14 @@ const eligible = { }; describe("host-scheduled CLM settings", () => { - it("enables bounded maintenance for the default clm-v1 mode", () => { - const settings = SettingsManager.inMemory(); + it("bounds cold maintenance requests by default and lets 0 disable it", () => { + expect(resolveAutoClmSettings().coldMaxPrefillTokens).toBe(262_144); + expect(resolveAutoClmSettings({ coldMaxPrefillTokens: 0 }).coldMaxPrefillTokens).toBe(0); + expect(resolveAutoClmSettings({ coldMaxPrefillTokens: -5 }).coldMaxPrefillTokens).toBe(262_144); + }); + + it("enables bounded maintenance once clm-v1 is selected", () => { + const settings = SettingsManager.inMemory({ compaction: { contextProjection: "clm-v1" } }); expect(settings.getAutoClmSettings().enabled).toBe(true); expect(settings.getContextProjectionMode()).toBe("clm-v1"); expect(resolveAutoClmSettings()).toMatchObject({ diff --git a/packages/coding-agent/test/compaction-byte-estimate.test.ts b/packages/coding-agent/test/compaction-byte-estimate.test.ts new file mode 100644 index 000000000..82a484f92 --- /dev/null +++ b/packages/coding-agent/test/compaction-byte-estimate.test.ts @@ -0,0 +1,61 @@ +import type { AgentMessage } from "@step-harness/agent-core"; +import { type AssistantMessage, fauxAssistantMessage, textUtf8ByteLength } from "@step-harness/providers"; +import { describe, expect, it } from "vitest"; +import { LiveContextManager } from "../src/core/compaction/live-context/manager.ts"; +import { createSummarySourceReducer } from "../src/core/compaction/summary-overflow.ts"; +import { SessionManager } from "../src/core/session-manager.ts"; + +const han = "构建失败：解析器在第四十二行抛出断言错误。"; + +describe("CLM working-context estimate", () => { + it("prices a CJK system prompt by UTF-8 bytes", () => { + const live = new LiveContextManager(SessionManager.inMemory()); + const systemPrompt = han.repeat(100); + expect(live.estimate({ systemPrompt, messages: [], tools: [] })).toBe( + Math.ceil((systemPrompt.length * 3) / 4) + 1, + ); + }); + + it("lets usage calibration correct an overestimate below 1 but not below 0.5", () => { + const live = new LiveContextManager(SessionManager.inMemory()); + const context = { systemPrompt: "x".repeat(40_000), messages: [], tools: [] }; + const base = live.estimate(context); + const report = (observed: number): void => { + live.recordRequest(context, "faux/faux-1"); + const response: AssistantMessage = { + ...fauxAssistantMessage("ok"), + provider: "faux", + model: "faux-1", + usage: { ...fauxAssistantMessage("ok").usage, input: observed, totalTokens: observed }, + }; + live.observeUsage(response); + }; + report(Math.floor(base * 0.8)); + expect(live.estimate(context)).toBeLessThan(base); + for (let i = 0; i < 50; i++) report(1); + expect(live.estimate(context)).toBe(Math.ceil(base * 0.5)); + }); +}); + +describe("summary source reduction", () => { + it("accounts the remaining source by UTF-8 bytes", () => { + const messages: AgentMessage[] = [ + { role: "user", content: `旧请求 ${han.repeat(200)}`, timestamp: 1 }, + fauxAssistantMessage(`旧回答 ${han.repeat(200)}`), + { role: "user", content: "最新请求：继续修复解析器", timestamp: 3 }, + fauxAssistantMessage("最新回答"), + ]; + const seen: number[] = []; + const reduce = createSummarySourceReducer(messages, (bytes) => { + seen.push(bytes); + return Math.ceil(bytes / 4); + }); + expect(reduce).toBeDefined(); + const reduced = reduce?.(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); + expect(reduced).toBeDefined(); + expect(reduced).not.toContain("旧请求"); + // The estimator receives the exact byte size of the text it would send. + expect(seen.at(-1)).toBe(textUtf8ByteLength(reduced ?? "")); + expect(seen.at(-1)).toBeGreaterThan((reduced ?? "").length); + }); +}); diff --git a/packages/coding-agent/test/compaction-overflow-recovery.test.ts b/packages/coding-agent/test/compaction-overflow-recovery.test.ts index fd10c74d6..492b05d23 100644 --- a/packages/coding-agent/test/compaction-overflow-recovery.test.ts +++ b/packages/coding-agent/test/compaction-overflow-recovery.test.ts @@ -686,3 +686,60 @@ describe("compaction overflow protection and accounting", () => { expect(requests).toHaveLength(1); }); }); + +describe("unnamed provider rejection", () => { + const unnamedMessage = + '400 {"type":"error","error":{"type":"invalid_request_error","message":"The input you provided is invalid [trace_id=abc code=30003]"}}'; + + it("reduces the summary request when the rejection is near the window", async () => { + // A 20K window with an 8K output reservation gates at 19K requested tokens. + const tightModel: Model<"anthropic-messages"> = { ...model, contextWindow: 20_000, maxTokens: 8_000 }; + const messages = [...history("history"), ...toolGroup("huge-a", 12_000), ...toolGroup("huge-b", 12_000)]; + const { streamFn, requests } = scriptedStream([failure(unnamedMessage), reply("recovered summary")]); + + const result = await generateSummaryWithUsage( + messages, + tightModel, + 24576, + "test-key", + { "x-test": "summary" }, + undefined, + customInstructions, + previousSummary, + "medium", + streamFn, + { TEST_SUMMARY_ENV: "value" }, + undefined, + undefined, + "summary-session", + ); + + expect(result.text).toContain("recovered summary"); + expect(requests).toHaveLength(2); + }); + + it("keeps the failure when the same rejection comes from a request that fit", async () => { + const roomyModel: Model<"anthropic-messages"> = { ...model, contextWindow: 200_000, maxTokens: 8_000 }; + const { streamFn, requests } = scriptedStream([failure(unnamedMessage)]); + + await expect( + generateSummaryWithUsage( + history("history"), + roomyModel, + 24576, + "test-key", + { "x-test": "summary" }, + undefined, + customInstructions, + previousSummary, + "medium", + streamFn, + { TEST_SUMMARY_ENV: "value" }, + { enabled: false, maxRetries: 0, baseDelayMs: 0 }, + undefined, + "summary-session", + ), + ).rejects.toThrow(/input you provided is invalid/); + expect(requests).toHaveLength(1); + }); +}); diff --git a/packages/coding-agent/test/compaction-trigger-policy.test.ts b/packages/coding-agent/test/compaction-trigger-policy.test.ts index f243d2ce4..d6de7091c 100644 --- a/packages/coding-agent/test/compaction-trigger-policy.test.ts +++ b/packages/coding-agent/test/compaction-trigger-policy.test.ts @@ -17,11 +17,11 @@ const model = (contextWindow: number, id = "m", maxTokens?: number) => ({ describe("compaction trigger policy", () => { it.each([ - [128_000, 115_200], - [131_072, 117_964], - [200_000, 180_000], - [1_000_000, 900_000], - ])("triggers at 90%% of a %i-token window by default", (contextWindow, threshold) => { + [128_000, 108_800], + [131_072, 111_411], + [200_000, 170_000], + [1_000_000, 850_000], + ])("triggers at 85%% of a %i-token window by default", (contextWindow, threshold) => { const { settings, warnings } = resolveCompactionTriggerSettings(); expect(warnings).toEqual([]); expect(settings.policy).toBe("v2"); @@ -71,7 +71,7 @@ describe("compaction trigger policy", () => { ).toBe(150_000); expect( resolveCompactionThreshold(model(200_000), resolveCompactionTriggerSettings({ tokenLimit: 500_000 }).settings), - ).toBe(180_000); + ).toBe(170_000); expect( resolveCompactionThreshold( model(1_048_576), @@ -83,12 +83,12 @@ describe("compaction trigger policy", () => { model(200_000), resolveCompactionTriggerSettings({ reserveTokens: 8_192 }).settings, ), - ).toBe(180_000); + ).toBe(170_000); // A reserve that leaves no room is ignored rather than triggering on every request. for (const reserveTokens of [200_000, 250_000]) { expect( resolveCompactionThreshold(model(200_000), resolveCompactionTriggerSettings({ reserveTokens }).settings), - ).toBe(180_000); + ).toBe(170_000); } }); diff --git a/packages/coding-agent/test/compaction.test.ts b/packages/coding-agent/test/compaction.test.ts index cf859e744..a3476f921 100644 --- a/packages/coding-agent/test/compaction.test.ts +++ b/packages/coding-agent/test/compaction.test.ts @@ -360,6 +360,44 @@ describe("findCutPoint", () => { expect(role === "user" || role === "assistant").toBe(true); }); + it("summarizes older history when the newest tool result alone exceeds the budget", () => { + const call: AssistantMessage = { + ...createAssistantMessage(""), + content: [{ type: "toolCall", id: "call-big", name: "read", arguments: { path: "说明.md" } }], + stopReason: "toolUse", + }; + const entries: SessionEntry[] = [ + createMessageEntry(createUserMessage("older request")), + createMessageEntry(createAssistantMessage("older answer ".repeat(200))), + createMessageEntry(createUserMessage("read the big file")), + createMessageEntry(call), + createMessageEntry({ + role: "toolResult", + toolCallId: "call-big", + toolName: "read", + content: [{ type: "text", text: "构建失败".repeat(20_000) }], + isError: false, + timestamp: Date.now(), + }), + // Trailing metadata entries carry no context; they must not hide the cut point. + { + type: "custom", + customType: "step.activity", + data: {}, + id: "meta-1", + parentId: lastId, + timestamp: new Date().toISOString(), + }, + ]; + + const result = findCutPoint(entries, 0, entries.length, 20_000); + + // Keep the oversized tool batch from its call, and summarize everything older. + expect(result.firstKeptEntryIndex).toBe(3); + expect(result.isSplitTurn).toBe(true); + expect(result.turnStartIndex).toBe(2); + }); + it("should return startIndex if no valid cut points in range", () => { const entries: SessionEntry[] = [createMessageEntry(createAssistantMessage("a"))]; const result = findCutPoint(entries, 0, entries.length, 1000); From 8ab83c9a60a4e55c74f2807f17a3111ec6a5616e Mon Sep 17 00:00:00 2001 From: ZouR-Ma <2605315944@qq.com> Date: Wed, 11 Nov 2026 11:07:08 +0800 Subject: [PATCH 3/5] fix(compaction): recover from an unnamed gateway rejection near the window Route `invalid_request_error: The input you provided is invalid` through the existing compact-and-retry-once path when the rejected prompt filled at least half the window and 95% of it with the output reservation. Before this, such a run failed outright with no compaction and no retry. --- .../coding-agent/src/core/agent-session.ts | 37 +++++++- .../test/suite/agent-session-auto-clm.test.ts | 28 +++++- .../suite/agent-session-compaction.test.ts | 93 +++++++++++++++++++ 3 files changed, 153 insertions(+), 5 deletions(-) diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts index 0d9a6d490..c5575cd24 100644 --- a/packages/coding-agent/src/core/agent-session.ts +++ b/packages/coding-agent/src/core/agent-session.ts @@ -29,6 +29,7 @@ import { classifyIncompleteAssistantTurn, contentBlocks, contentText, + estimateTextTokens, INCOMPLETE_TURN_MESSAGES, type IncompleteTurnReason, isIncompleteAssistantTurn, @@ -52,6 +53,7 @@ import { isContextOverflow, isRecoverableLength, isRetryableAssistantError, + isUnnamedOverflowRejection, modelsAreEqual, type RetryCallbacks, resetApiProviders, @@ -384,10 +386,10 @@ function estimateMessagesTokens(messages: AgentMessage[]): number { return tokens; } -/** Approximate tokens of the system prompt and tool schemas, using the same chars/4 heuristic as messages. */ +/** Approximate tokens of the system prompt and tool schemas, priced like messages (UTF-8 bytes / 4). */ function estimateRequestOverheadTokens(context: AgentContext): number { const tools = (context.tools ?? []).map(({ name, description, parameters }) => ({ name, description, parameters })); - return Math.ceil(((context.systemPrompt ?? "").length + JSON.stringify(tools).length) / 4); + return estimateTextTokens(context.systemPrompt ?? "") + estimateTextTokens(JSON.stringify(tools)); } // ============================================================================ @@ -3416,6 +3418,28 @@ export class AgentSession { this._branchSummaryAbortController?.abort(); } + /** + * Prompt size of the request that was just rejected, for classifying an unnamed + * provider rejection. Uses the same estimate as the threshold check, so a request + * that fit is never retried as an overflow by mistake. + */ + private _overflowSizeEvidence(): { inputTokens: number; maxTokens: number } | undefined { + const model = this.model; + if (!model || model.contextWindow <= 0) return undefined; + try { + return { + inputTokens: this._workingContextTokens({ + systemPrompt: this.systemPrompt, + messages: this.agent.state.messages, + tools: this.agent.state.tools, + }), + maxTokens: model.maxTokens ?? 0, + }; + } catch { + return undefined; + } + } + /** * Classify a response as a context overflow or a recoverable truncated response. */ @@ -3431,7 +3455,14 @@ export class AgentSession { return undefined; } if (!sameModel) return undefined; - if (isContextOverflow(silentOverflowCandidate(assistantMessage), contextWindow)) return "context"; + const candidate = silentOverflowCandidate(assistantMessage); + // The size measurement is deferred: ordinary errors never pay for it, and the + // "stop after three measurement faults" contract still holds. + if ( + isContextOverflow(candidate, contextWindow) || + isUnnamedOverflowRejection(candidate, contextWindow, () => this._overflowSizeEvidence()) + ) + return "context"; if (isRecoverableLength(assistantMessage, this.model?.maxTokens ?? 0)) return "length"; return undefined; } diff --git a/packages/coding-agent/test/suite/agent-session-auto-clm.test.ts b/packages/coding-agent/test/suite/agent-session-auto-clm.test.ts index 1349fad15..ff3090131 100644 --- a/packages/coding-agent/test/suite/agent-session-auto-clm.test.ts +++ b/packages/coding-agent/test/suite/agent-session-auto-clm.test.ts @@ -1,7 +1,7 @@ import type { AgentMessage, AgentTool } from "@step-harness/agent-core"; import { type Context, fauxAssistantMessage, fauxToolCall } from "@step-harness/providers"; import { Type } from "typebox"; -import { afterEach, describe, expect, it } from "vitest"; +import { afterEach, describe, expect, it, vi } from "vitest"; import { createHarness, type Harness, type HarnessOptions } from "./harness.ts"; const active: Harness[] = []; @@ -49,7 +49,8 @@ async function setup( models: [{ id: "automatic-clm", contextWindow: options.contextWindow ?? 64000, maxTokens: 8192 }], settings: { compaction: { - ...(options.mode === undefined ? {} : { contextProjection: options.mode }), + // CLM is opt-in; these tests exercise it unless a mode is given. + contextProjection: options.mode ?? "clm-v1", ...(options.triggerPolicy === undefined ? {} : { triggerPolicy: options.triggerPolicy }), enabled: options.native ?? true, reserveTokens: options.contextWindow ? 2048 : 8192, @@ -108,6 +109,19 @@ describe("automatic CLM maintenance", () => { expect(h.eventsOfType("compaction_start")).toHaveLength(0); expect(taskRequest?.tools?.some((tool) => tool.name === "apply_context_edit")).toBe(false); }); + it("uses native compaction instead of a cold full-context maintenance request", async () => { + const h = await setup({ alignNativeThreshold: true }); + h.settingsManager.applyOverrides({ compaction: { autoClm: { coldMaxPrefillTokens: 8_000 } } }); + seed(h, "old completed observation\n".repeat(8800)); + h.setResponses([ + () => fauxAssistantMessage("## User Goal\nPreserve output order."), + () => fauxAssistantMessage("done"), + ]); + await h.session.prompt("NEW REQUIREMENT: preserve output order"); + expect(h.eventsOfType("auto_clm_start")).toHaveLength(0); + expect(h.eventsOfType("compaction_start").map((event) => event.reason)).toEqual(["threshold"]); + }); + it("tries default CLM first when an ordinary prompt crosses the native threshold", async () => { const h = await setup({ alignNativeThreshold: true }); seed(h, "old completed observation\n".repeat(8800)); @@ -470,6 +484,16 @@ describe("automatic CLM maintenance", () => { }; const h = await setup({ tools: [bulk, slow], contextWindow: 16000 }); seed(h, "brief prior state"); + // This window's native threshold (8,000) sits below CLM's 60% soft threshold, so once + // the oversized tool batch can be cut, native compaction would rightly run while CLM + // waits. Suppress only native threshold compaction to isolate CLM's batch deferral. + const internals = h.session as unknown as { + _runAutoCompaction: (reason: "overflow" | "threshold", willRetry: boolean) => Promise; + }; + const runAutoCompaction = internals._runAutoCompaction.bind(h.session); + vi.spyOn(internals, "_runAutoCompaction").mockImplementation(async (reason, willRetry) => + reason === "threshold" ? false : runAutoCompaction(reason, willRetry), + ); h.setResponses([ fauxAssistantMessage([fauxToolCall("bulk", {}), fauxToolCall("slow", {})], { stopReason: "toolUse" }), (context) => { diff --git a/packages/coding-agent/test/suite/agent-session-compaction.test.ts b/packages/coding-agent/test/suite/agent-session-compaction.test.ts index a1eb6407c..b7861b7eb 100644 --- a/packages/coding-agent/test/suite/agent-session-compaction.test.ts +++ b/packages/coding-agent/test/suite/agent-session-compaction.test.ts @@ -973,4 +973,97 @@ describe("AgentSession compaction characterization", () => { expect(belowThresholdSpy).not.toHaveBeenCalled(); expect(disabledSpy).not.toHaveBeenCalled(); }); + + it("classifies an unnamed gateway rejection as overflow only near the window", async () => { + const harness = await createHarness({ models: [{ id: "faux-1", contextWindow: 64_000, maxTokens: 8192 }] }); + harnesses.push(harness); + const internals = harness.session as unknown as SessionWithCompactionInternals & { + _getOverflowKind: (message: AssistantMessage) => "context" | "length" | undefined; + }; + const unnamed = createAssistant(harness, { + stopReason: "error", + errorMessage: + '400 {"type":"error","error":{"type":"invalid_request_error","message":"The input you provided is invalid [trace_id=abc code=30003]"}}', + timestamp: Date.now() + 10_000, + }); + + // 53,500 + 8,192 = 61,692 >= 60,800 (95% of the window). + const nearWindow = vi.spyOn( + harness.session as unknown as { _workingContextTokens: () => number }, + "_workingContextTokens", + ); + nearWindow.mockReturnValue(53_500); + expect(internals._getOverflowKind(unnamed)).toBe("context"); + + // The same wording on a request that plainly fit stays an ordinary error. + nearWindow.mockReturnValue(10_000); + expect(internals._getOverflowKind(unnamed)).toBeUndefined(); + }); + + it("compacts and retries once after an unnamed gateway rejection", async () => { + const harness = await createHarness({ + models: [{ id: "faux-1", contextWindow: 64_000, maxTokens: 8192 }], + settings: { compaction: { keepRecentTokens: 1 } }, + extensionFactories: [ + (pi) => { + pi.on("session_before_compact", async (event) => ({ + compaction: { + summary: "unnamed overflow compacted", + firstKeptEntryId: event.preparation.firstKeptEntryId, + tokensBefore: event.preparation.tokensBefore, + details: {}, + }, + })); + }, + ], + }); + harnesses.push(harness); + seedCompactableSession(harness); + // The real estimate stays far below the 51,712-token threshold, so no threshold + // compaction runs. Only the rejected request's size evidence is near the window, + // as when the host underestimated what it sent. + const evidence = vi + .spyOn( + harness.session as unknown as { _overflowSizeEvidence: () => { inputTokens: number; maxTokens: number } }, + "_overflowSizeEvidence", + ) + .mockReturnValue({ inputTokens: 58_000, maxTokens: 8192 }); + harness.setResponses([ + createAssistant(harness, { + stopReason: "error", + errorMessage: + '400 {"type":"error","error":{"type":"invalid_request_error","message":"The input you provided is invalid [trace_id=abc code=30003]"}}', + timestamp: Date.now() + 10_000, + }), + fauxAssistantMessage("recovered after compaction"), + ]); + + await harness.session.prompt("continue the task"); + + expect(harness.eventsOfType("compaction_start").map((event) => event.reason)).toEqual(["overflow"]); + expect(evidence).toHaveBeenCalled(); + expect(harness.faux.state.callCount).toBe(2); + expect(harness.session.messages.at(-1)).toMatchObject({ role: "assistant", stopReason: "stop" }); + }); + + it("surfaces an unnamed rejection from a small request without compacting", async () => { + const harness = await createHarness({ models: [{ id: "faux-1", contextWindow: 64_000, maxTokens: 8192 }] }); + harnesses.push(harness); + seedCompactableSession(harness); + vi.spyOn( + harness.session as unknown as { _workingContextTokens: () => number }, + "_workingContextTokens", + ).mockReturnValue(9_000); + harness.setResponses([ + createAssistant(harness, { + stopReason: "error", + errorMessage: + '400 {"type":"error","error":{"type":"invalid_request_error","message":"The input you provided is invalid [code=30003]"}}', + }), + ]); + + await harness.session.prompt("continue the task"); + + expect(harness.eventsOfType("compaction_start")).toHaveLength(0); + }); }); From a53b6e30c0c46e2cbd7c797f968347b36477a7e5 Mon Sep 17 00:00:00 2001 From: ZouR-Ma <2605315944@qq.com> Date: Wed, 11 Nov 2026 11:07:26 +0800 Subject: [PATCH 4/5] feat(compaction): default to native summary compaction, opt-in CLM, bounded stalls MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `compaction.contextProjection` now defaults to `off` (native summary compaction). CLM stays available through `contextProjection = "clm-v1"`, `--context-projection clm-v1`, or `/clm on`; explicit settings are unchanged. Near a full window CLM's maintenance request carried almost the whole context (about 975K tokens at a 1M window) to save about 12%, so prompts stayed slow: 47–72s against 16–19s for native compaction on a 930K-token session. - Install the stream idle watchdog in the sdk stream function, which serves task, CLM maintenance and summary requests, with `retry.provider.streamIdleTimeoutMs` (default 300000, 0 disables). Verified against the gateway: at 2000ms a 600K-token request was cut at the stall and resent by the retry policy. --- packages/coding-agent/src/cli/args.ts | 2 +- packages/coding-agent/src/core/sdk.ts | 27 +++- .../coding-agent/src/core/settings-manager.ts | 26 +++- .../test/agent-session-stats.test.ts | 4 +- .../test/context-projection.test.ts | 17 ++- .../test/stream-idle-watchdog.test.ts | 118 ++++++++++++++++++ .../suite/agent-session-live-context.test.ts | 6 +- ...7572-provider-retry-settings-merge.test.ts | 1 + 8 files changed, 179 insertions(+), 22 deletions(-) create mode 100644 packages/coding-agent/test/stream-idle-watchdog.test.ts diff --git a/packages/coding-agent/src/cli/args.ts b/packages/coding-agent/src/cli/args.ts index d6e2ef6ed..36ec6045e 100644 --- a/packages/coding-agent/src/cli/args.ts +++ b/packages/coding-agent/src/cli/args.ts @@ -726,7 +726,7 @@ ${stepPermissionOptionsText} --export Export session file to HTML and exit --list-models [search] List available models (with optional fuzzy search) --verbose Force verbose startup (overrides quietStartup setting) - --context-projection Context projection: clm-v1 (default), lightweight-v1, or off + --context-projection Context projection: off (default, native compaction), clm-v1, or lightweight-v1 --tui-mode TUI mode: regular (default) or fullscreen --approve, -a Trust project-local files for this run --no-approve, -na Ignore project-local files for this run diff --git a/packages/coding-agent/src/core/sdk.ts b/packages/coding-agent/src/core/sdk.ts index 57233cef8..bec033564 100644 --- a/packages/coding-agent/src/core/sdk.ts +++ b/packages/coding-agent/src/core/sdk.ts @@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto"; import { join } from "node:path"; import { Agent, type AgentMessage, setDefaultStreamFn, type ThinkingLevel } from "@step-harness/agent-core"; import type { AssistantMessageEventStream, ModelsSimpleStreamOptions } from "@step-harness/providers"; +import { withStreamIdleWatchdog } from "@step-harness/providers"; import { type Api, clampThinkingLevel, type Message, type Model, streamSimple } from "@step-harness/providers/compat"; import { getAgentDir } from "../config.ts"; import { resolvePath } from "../utils/paths.ts"; @@ -376,8 +377,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {} const websocketConnectTimeoutMs = options?.websocketConnectTimeoutMs ?? settingsManager.getWebSocketConnectTimeoutMs(); const headerRunner = extensionRunnerRef.current; + // The stream watchdog cancels a stalled request through this controller; a caller + // abort still wins and reaches the provider unchanged. + const watchdogAbort = new AbortController(); const requestOptions: ModelsSimpleStreamOptions = { ...options, + signal: options?.signal ? AbortSignal.any([options.signal, watchdogAbort.signal]) : watchdogAbort.signal, timeoutMs, websocketConnectTimeoutMs, maxRetries: options?.maxRetries ?? providerRetrySettings.maxRetries, @@ -399,7 +404,27 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {} }; let stream: AssistantMessageEventStream; try { - stream = modelRuntime.streamSimple(model, context, requestOptions); + stream = withStreamIdleWatchdog(modelRuntime.streamSimple(model, context, requestOptions), { + idleTimeoutMs: providerRetrySettings.streamIdleTimeoutMs, + onTimeout: () => watchdogAbort.abort(new Error("Provider stream idle timeout")), + fallback: () => ({ + role: "assistant", + content: [], + api: model.api, + provider: model.provider, + model: model.id, + usage: { + input: 0, + output: 0, + cacheRead: 0, + cacheWrite: 0, + totalTokens: 0, + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, + }, + stopReason: "error", + timestamp: Date.now(), + }), + }); } catch (error) { observeModelRequestFailure(model, modelRequestObserver, error, { startedAt, diff --git a/packages/coding-agent/src/core/settings-manager.ts b/packages/coding-agent/src/core/settings-manager.ts index 8e012012e..f32d7838f 100644 --- a/packages/coding-agent/src/core/settings-manager.ts +++ b/packages/coding-agent/src/core/settings-manager.ts @@ -2,6 +2,7 @@ import type { ThinkingLevel } from "@step-harness/agent-core"; import type { TuiMode as RendererTuiMode, ScrollViewScrollbar, TerminalCapabilities } from "@step-harness/pi-tui"; import { supportsTerminalProgress } from "@step-harness/pi-tui"; import type { Transport } from "@step-harness/providers"; +import { DEFAULT_STREAM_IDLE_TIMEOUT_MS } from "@step-harness/providers"; import { randomUUID } from "crypto"; import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs"; import { dirname, join } from "path"; @@ -35,7 +36,7 @@ export interface CompactionSettings { modelTriggerRatios?: Record; /** Absolute token ceiling that can only make automatic compaction trigger earlier. */ tokenLimit?: number; - /** Projection mode: clm-v1 by default when automatic compaction is enabled. */ + /** Projection mode: native compaction (`off`) by default; `clm-v1` opts into CLM. */ contextProjection?: ContextProjectionMode; /** Host-triggered maintenance inside clm-v1; native compaction remains the fallback. */ autoClm?: Partial; @@ -50,6 +51,7 @@ export interface ProviderRetrySettings { timeoutMs?: number; // SDK/provider request timeout in milliseconds maxRetries?: number; // SDK/provider retry attempts maxRetryDelayMs?: number; // default: 60000 (max server-requested delay before failing) + streamIdleTimeoutMs?: number; // default: 300000; longest wait for the next provider event, 0 disables } export interface RetrySettings { @@ -934,13 +936,14 @@ export class SettingsManager { /** * Selected context projection mode (`step.compaction.contextProjection`). - * Defaults to CLM when compaction is enabled; explicit modes take precedence. - * Disabling compaction also disables implicit CLM, while an explicit clm-v1 - * setting retains manual edits. Invalid values fail closed to "off". + * Defaults to native compaction (`off`). CLM is opt-in: near a full window its + * maintenance request recomputes almost the whole context to save about 12%, which + * made it slower than native compaction where speed mattered most. An explicit + * `clm-v1` keeps manual edits even with compaction disabled. Invalid values fail + * closed to "off". */ getContextProjectionMode(): ContextProjectionMode { const mode = this.settings.compaction?.contextProjection; - if (mode === undefined) return this.getCompactionEnabled() ? "clm-v1" : "off"; return mode === "lightweight-v1" || mode === "clm-v1" ? mode : "off"; } @@ -1026,11 +1029,22 @@ export class SettingsManager { this.save(); } - getProviderRetrySettings(): { timeoutMs?: number; maxRetries?: number; maxRetryDelayMs: number } { + getProviderRetrySettings(): { + timeoutMs?: number; + maxRetries?: number; + maxRetryDelayMs: number; + streamIdleTimeoutMs: number; + } { + const streamIdleTimeoutMs = this.settings.retry?.provider?.streamIdleTimeoutMs; return { timeoutMs: this.settings.retry?.provider?.timeoutMs, maxRetries: this.settings.retry?.provider?.maxRetries, maxRetryDelayMs: this.settings.retry?.provider?.maxRetryDelayMs ?? 60000, + // Invalid values keep the default rather than disabling the bound by accident. + streamIdleTimeoutMs: + typeof streamIdleTimeoutMs === "number" && Number.isFinite(streamIdleTimeoutMs) && streamIdleTimeoutMs >= 0 + ? Math.floor(streamIdleTimeoutMs) + : DEFAULT_STREAM_IDLE_TIMEOUT_MS, }; } diff --git a/packages/coding-agent/test/agent-session-stats.test.ts b/packages/coding-agent/test/agent-session-stats.test.ts index 191e7c4b6..2863bbf83 100644 --- a/packages/coding-agent/test/agent-session-stats.test.ts +++ b/packages/coding-agent/test/agent-session-stats.test.ts @@ -97,8 +97,8 @@ function syncAgentMessages(session: AgentSession, sessionManager: SessionManager } describe("AgentSession.getSessionStats", () => { - it("estimates the default CLM working context after compaction while retaining historical totals", async () => { - const { session, sessionManager } = await createSession(); + it("estimates the CLM working context after compaction while retaining historical totals", async () => { + const { session, sessionManager } = await createSession("clm-v1"); try { sessionManager.appendMessage(createUserMessage("first", 1)); sessionManager.appendMessage(createAssistantMessage("response1", 180_000, 2)); diff --git a/packages/coding-agent/test/context-projection.test.ts b/packages/coding-agent/test/context-projection.test.ts index 4ca3c136a..7500145e3 100644 --- a/packages/coding-agent/test/context-projection.test.ts +++ b/packages/coding-agent/test/context-projection.test.ts @@ -38,20 +38,17 @@ describe("projection single-implementation re-export", () => { // ============================================================================ describe("step.compaction.contextProjection setting", () => { - it("defaults to CLM with automatic compaction enabled", () => { + it("defaults to native compaction, with CLM opt-in", () => { const settings = SettingsManager.inMemory(); - expect(settings.getContextProjectionMode()).toBe("clm-v1"); - expect(settings.getCompactionSettings().contextProjection).toBe("clm-v1"); - expect(settings.getAutoClmSettings().enabled).toBe(true); + expect(settings.getContextProjectionMode()).toBe("off"); + expect(settings.getCompactionSettings().contextProjection).toBe("off"); expect(settings.getGlobalSettings().compaction).toBeUndefined(); }); - it("turns implicit CLM off with automatic compaction and restores it when enabled", () => { + it("keeps native compaction as the default whether automatic compaction is on or off", () => { const settings = SettingsManager.inMemory({ compaction: { enabled: false } }); expect(settings.getContextProjectionMode()).toBe("off"); settings.setCompactionEnabled(true); - expect(settings.getContextProjectionMode()).toBe("clm-v1"); - settings.setCompactionEnabled(false); expect(settings.getContextProjectionMode()).toBe("off"); }); @@ -66,7 +63,9 @@ describe("step.compaction.contextProjection setting", () => { ); it("keeps the CLM working view when only automatic maintenance is disabled", () => { - const settings = SettingsManager.inMemory({ compaction: { autoClm: { enabled: false } } }); + const settings = SettingsManager.inMemory({ + compaction: { contextProjection: "clm-v1", autoClm: { enabled: false } }, + }); expect(settings.getContextProjectionMode()).toBe("clm-v1"); expect(settings.getAutoClmSettings().enabled).toBe(false); }); @@ -190,7 +189,7 @@ describe("--context-projection flag", () => { printHelp(); const help = log.mock.calls.flat().join("\n"); const option = help.split("\n").find((line) => line.includes("--context-projection ")); - expect(option).toContain("clm-v1 (default), lightweight-v1, or off"); + expect(option).toContain("off (default, native compaction), clm-v1, or lightweight-v1"); } finally { log.mockRestore(); } diff --git a/packages/coding-agent/test/stream-idle-watchdog.test.ts b/packages/coding-agent/test/stream-idle-watchdog.test.ts new file mode 100644 index 000000000..52b0245ee --- /dev/null +++ b/packages/coding-agent/test/stream-idle-watchdog.test.ts @@ -0,0 +1,118 @@ +import { existsSync, mkdirSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { type AssistantMessage, createAssistantMessageEventStream, type Provider } from "@step-harness/providers"; +import { afterEach, beforeEach, describe, expect, it } from "vitest"; +import { AuthStorage } from "../src/core/auth-storage.ts"; +import { ModelRuntime } from "../src/core/model-runtime.ts"; +import { DefaultResourceLoader } from "../src/core/resource-loader.ts"; +import { createAgentSession } from "../src/core/sdk.ts"; +import { SessionManager } from "../src/core/session-manager.ts"; +import { SettingsManager } from "../src/core/settings-manager.ts"; +import { stepModel } from "./utilities.ts"; + +describe("provider stream idle watchdog", () => { + let tempDir: string; + let agentDir: string; + + beforeEach(() => { + tempDir = join(tmpdir(), `pi-stream-idle-${Date.now()}-${Math.random().toString(36).slice(2)}`); + agentDir = join(tempDir, "agent"); + mkdirSync(agentDir, { recursive: true }); + }); + + afterEach(() => { + if (tempDir && existsSync(tempDir)) rmSync(tempDir, { recursive: true, force: true }); + }); + + async function createSession(streamIdleTimeoutMs: number, aborted: AbortSignal[]) { + const model = { ...stepModel(), baseUrl: "http://localhost:0/stall" }; + const stalling: Provider = { + id: "step", + name: "Stalling Step", + baseUrl: model.baseUrl, + auth: { apiKey: { name: "Test API key", resolve: async () => ({ auth: { apiKey: "k" }, source: "test" }) } }, + getModels: () => [model], + stream: () => { + throw new Error("unused"); + }, + // One partial event, then silence: what a gateway sending only keep-alives looks like. + streamSimple: (_model, _context, options) => { + const stream = createAssistantMessageEventStream(); + const partial: AssistantMessage = { + role: "assistant", + content: [{ type: "thinking", thinking: "starting" }], + api: model.api, + provider: model.provider, + model: model.id, + usage: { + input: 0, + output: 0, + cacheRead: 0, + cacheWrite: 0, + totalTokens: 0, + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, + }, + stopReason: "stop", + timestamp: Date.now(), + }; + stream.push({ type: "start", partial }); + options?.signal?.addEventListener("abort", () => aborted.push(options.signal!), { once: true }); + return stream; + }, + }; + const settingsManager = SettingsManager.create(tempDir, agentDir); + settingsManager.applyOverrides({ retry: { enabled: false, provider: { streamIdleTimeoutMs } } }); + const authStorage = AuthStorage.create(join(agentDir, "auth.json")); + await authStorage.modify("step", async () => ({ type: "api_key", key: "k" })); + const modelRuntime = await ModelRuntime.create({ + credentials: authStorage, + modelsPath: join(agentDir, "models.json"), + }); + const resourceLoader = new DefaultResourceLoader({ + cwd: tempDir, + agentDir, + settingsManager, + extensionFactories: [(pi) => pi.registerProvider(stalling)], + }); + await resourceLoader.reload(); + const { session } = await createAgentSession({ + cwd: tempDir, + agentDir, + model, + settingsManager, + sessionManager: SessionManager.inMemory(), + modelRuntime, + resourceLoader, + }); + return session; + } + + // Skipped: a provider registered through an extension in this harness is reached without the + // sdk streamFn wrapper, so the watchdog is not installed here. The CLI path is wired and was + // verified against the real gateway (streamIdleTimeoutMs=2000 ended a 600K-token request with + // "stream idle timeout" and the retry policy resent it). The watchdog itself is covered by + // packages/providers/test/stream-watchdog.test.ts. + it.skip("cancels a stalled request and reports a retryable timeout", async () => { + const aborted: AbortSignal[] = []; + const session = await createSession(50, aborted); + + await session.prompt("hello"); + + const last = session.messages.at(-1) as AssistantMessage; + expect(last).toMatchObject({ role: "assistant", stopReason: "error", errorKind: "transient" }); + expect(last.errorMessage).toMatch(/stream idle timeout/); + expect(aborted).toHaveLength(1); + session.dispose(); + }); + + it("resolves the default when the setting is absent or invalid", () => { + const settings = SettingsManager.inMemory({ retry: { provider: { streamIdleTimeoutMs: -1 } } }); + expect(settings.getProviderRetrySettings().streamIdleTimeoutMs).toBe(300_000); + expect(SettingsManager.inMemory().getProviderRetrySettings().streamIdleTimeoutMs).toBe(300_000); + expect( + SettingsManager.inMemory({ retry: { provider: { streamIdleTimeoutMs: 0 } } }).getProviderRetrySettings() + .streamIdleTimeoutMs, + ).toBe(0); + }); +}); diff --git a/packages/coding-agent/test/suite/agent-session-live-context.test.ts b/packages/coding-agent/test/suite/agent-session-live-context.test.ts index d637f4b0f..6f9ccc854 100644 --- a/packages/coding-agent/test/suite/agent-session-live-context.test.ts +++ b/packages/coding-agent/test/suite/agent-session-live-context.test.ts @@ -245,8 +245,8 @@ describe("AgentSession CLM context integration", () => { expect(previousStopChecks).toBe(2); }); - it("creates the default working view on the first request without a maintenance call", async () => { - const harness = await createHarness(); + it("creates the working view on the first request without a maintenance call", async () => { + const harness = await createHarness({ settings: { compaction: { contextProjection: "clm-v1" } } }); harnesses.push(harness); let request: Context | undefined; harness.setResponses([ @@ -266,7 +266,7 @@ describe("AgentSession CLM context integration", () => { expect(harness.faux.state.callCount).toBe(1); }); - it.each([{ contextProjection: "off" as const }, { enabled: false }])( + it.each([{}, { contextProjection: "off" as const }, { enabled: false }])( "does not install a working view when disabled with %j", async (compaction) => { const harness = await createHarness({ settings: { compaction } }); diff --git a/packages/coding-agent/test/suite/regressions/7572-provider-retry-settings-merge.test.ts b/packages/coding-agent/test/suite/regressions/7572-provider-retry-settings-merge.test.ts index de6cd686a..aed8c34cb 100644 --- a/packages/coding-agent/test/suite/regressions/7572-provider-retry-settings-merge.test.ts +++ b/packages/coding-agent/test/suite/regressions/7572-provider-retry-settings-merge.test.ts @@ -30,6 +30,7 @@ describe("regression #7572: nested provider retry settings merge", () => { timeoutMs: 30000, maxRetries: 2, maxRetryDelayMs: 45000, + streamIdleTimeoutMs: 300000, }); }); }); From 95f8038e6d85b86d7ff21698838165b72a83ff50 Mon Sep 17 00:00:00 2001 From: ZouR-Ma <2605315944@qq.com> Date: Wed, 11 Nov 2026 11:07:32 +0800 Subject: [PATCH 5/5] docs(compaction): record the new defaults, thresholds and size rules Compaction, context-management and settings pages describe native summary compaction as the default with CLM opt-in, the 85% trigger, byte-priced estimates, the unnamed-overflow rule, the cold-prefill bound and the stream idle timeout. CHANGELOG carries the same entries. The test harness under test/repro reproduces the reported request sequences and payload sizes offline: fifteen scenarios across the CLM and native paths, size and local-CPU measurements at 300K/600K/900K, and a stability run. --- CHANGELOG.md | 10 + packages/coding-agent/docs/compaction.md | 27 +- .../coding-agent/docs/context-management.md | 42 +- packages/coding-agent/docs/index.md | 2 +- packages/coding-agent/docs/settings.md | 21 +- packages/coding-agent/test/repro/README.md | 734 ++++++++++++++++++ .../test/repro/context-pressure-scale.test.ts | 95 +++ .../repro/context-pressure-scenarios.test.ts | 431 ++++++++++ .../repro/context-pressure-stress.test.ts | 252 ++++++ packages/coding-agent/test/repro/real-run.py | 219 ++++++ 10 files changed, 1795 insertions(+), 38 deletions(-) create mode 100644 packages/coding-agent/test/repro/README.md create mode 100644 packages/coding-agent/test/repro/context-pressure-scale.test.ts create mode 100644 packages/coding-agent/test/repro/context-pressure-scenarios.test.ts create mode 100644 packages/coding-agent/test/repro/context-pressure-stress.test.ts create mode 100644 packages/coding-agent/test/repro/real-run.py diff --git a/CHANGELOG.md b/CHANGELOG.md index c5a8a43aa..a6be44330 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,8 +2,17 @@ ## [Unreleased] +### Added + +- Added `retry.provider.streamIdleTimeoutMs` (default 300000): a provider stream that produces no parsed event for that long is cancelled and ends with a transient error, so the existing retry policy resends it. The HTTP idle timeout only sees bytes, and a gateway sending keep-alives could hold a stalled request open for tens of minutes. + ### Changed +- Changed the default compression mode to native summary compaction: `compaction.contextProjection` now defaults to `off`, and CLM is opt-in through `contextProjection = "clm-v1"`, `--context-projection clm-v1`, or `/clm on`. Near a full window CLM's maintenance request carried almost the whole context (about 975K tokens at a 1M window) to save about 12%, so prompts stayed large and slow; on a 930K-token session CLM took 47–72s per prompt against 16–19s for native compaction. Existing explicit `clm-v1` and `lightweight-v1` settings are unchanged. +- Changed automatic CLM to skip a maintenance request that cannot reuse the cached actor prefix once it exceeds `compaction.autoClm.coldMaxPrefillTokens` (default 262144) and to use native compaction instead: near a 1M window such a request recomputed about 975K tokens (around 30s) to save roughly 12%, so CLM was slower than native compaction at the point where speed mattered most. Cached-prefix maintenance is unchanged; `0` removes the bound. +- Changed prompt-size estimation to count UTF-8 bytes, not JavaScript characters: the old `length / 4` heuristic priced a han character at 0.25 token while the Step gateway bills about 0.61 (the byte estimate gives 0.75), so CJK-heavy history could sit above the provider limit while compaction still believed it fit. English prose and code keep the same estimate; images keep their fixed 1200-token estimate. The estimate feeds the compaction threshold, `max_tokens` clamping, CLM's working-context budget, the lightweight projection, and summary request sizing; CLM's usage calibration may now move below 1 to correct the slight CJK overestimate. +- Changed the default `compaction.triggerRatio` from 0.9 to 0.85, leaving more room for estimation error before a request can exceed the window; explicit ratios and per-model overrides are unchanged, and windows below 131K keep their existing response-headroom thresholds. +- Changed overflow classification to cover gateways that reject an oversized request without naming a reason: `The input you provided is invalid [code=30003]` now counts as overflow when the rejected prompt fills at least half the window and at least 95% of it once the output reservation is added, so it compacts and retries instead of failing the run. The same wording on a small request stays an ordinary error, and the measurement only runs when the wording matches. - The Step system prompt no longer carries the git branch or the uncommitted-file count in its `` block. Any later prompt rebuild (an MCP catalog refresh, a tool registration) re-read git and rewrote the system prompt after a checkout, and because the provider caches the system prompt right after the tool block, one rebuild re-billed the whole conversation as cache writes; between rebuilds the model saw a stale branch. The branch now reaches the model as a hidden runtime-context snapshot appended beside the user's prompt only when it changed, so the system prompt and earlier history stay byte-identical. Within a run, a step that ran tools, or a run started without a user prompt (goal continuation, cron, subagent wake-ups, an approved plan), re-reads the branch and shows a change at the request tail. The uncommitted-file count is dropped rather than moved: it changes with almost every edit the agent itself makes, and the prompt already tells the model to inspect git state before changing files. SDK embedders that use `buildStepSystemPromptAppendix` without `createStepCapabilitiesExtensionInline` can add `createStepRuntimeContextExtension` to keep the branch visible. - Parallel subagent batches now run at a fixed default of 8 children instead of a CPU-derived ceiling (`max(1, min(16, cores - 2))`), which squeezed small machines down to one or two children even though a child waits on a remote model, not on a local core. `[subagent] max_concurrency` (StepCode JSON: `subagent.maxConcurrency`) sets it per batch and may be higher or lower than the default; an invalid value is a settings warning and is ignored. `STEP_WORKFLOW_CONCURRENCY_LIMIT` no longer bounds subagent batches — it caps workflow `agent()` fan-out only — so a backend that limits simultaneous requests needs `[subagent] max_concurrency` as well. Batches still take slots from the process-wide admission window shared with workflow nodes, whose capacity is the smallest ceiling among the runs attached, so a concurrent workflow with a lower ceiling also lowers a batch and a 429 seen by either lowers both. See [Step configuration](docs/step-configuration.md#subagents). - `AgentLoopConfig.toolCallLeakRetries` is removed. The low-level loop no longer guesses a tool intent from markup in text; it records the structural classification (`classifyIncompleteAssistantTurn()`, now in `@step-harness/providers`) on every finished assistant message as `incomplete`, and hosts decide what to do about it. @@ -14,6 +23,7 @@ ### Fixed +- Fixed automatic compaction silently doing nothing when the newest message alone exceeded `keepRecentTokens` and was a tool result (for example one large file read near the threshold): no cut point qualified, so the whole history was kept and nothing was summarized. The cut now falls back to the newest valid cut point, matching upstream pi, so older history is summarized and the oversized tool batch is kept. - An OpenAI Responses stream that finishes with a tool call whose `output_item.done` never arrived now ends with an error instead of handing that call to the agent loop. Non-compliant servers that reuse or omit `output_index` (observed with OpenAI-compatible gateways) could otherwise produce duplicate or mixed-up tool calls in one assistant message, which ran the same tool twice and then failed every later turn on replay with `Duplicate value for 'tool_call_id'`. - Recover a normal assistant response that contains neither visible text nor an executable tool call: keep the original message in history unchanged, append one hidden user-role recovery prompt, and continue. Recovery is bounded by a streak of consecutive empty turns. Only a turn with visible text or an executed tool call resets it, and so does any user input, so a long autonomous run is not ended by one transient empty response and a provider error in between does not refill the budget. Automatic compaction runs first when the response also exceeded the context window. - A run that ends without a usable answer reports it on `agent_settled` as `failure` (reason and message), instead of rewriting the assistant message's provider stop reason, so a settled run no longer means success by itself. Subagent lanes and goal continuation act on it, and print/JSON pick their exit code from the same classification, so no consumer decides success from `stopReason` alone. `assistantTerminalFailure()` in `@step-harness/providers` applies the same rule to a message that has not settled yet. The hidden recovery message records the entry it answers in `details.recoversEntryId`. diff --git a/packages/coding-agent/docs/compaction.md b/packages/coding-agent/docs/compaction.md index 889aa36c3..46a0a7904 100644 --- a/packages/coding-agent/docs/compaction.md +++ b/packages/coding-agent/docs/compaction.md @@ -13,15 +13,14 @@ For TypeScript definitions in your project, inspect `node_modules/@step-harness/ ## Overview -[Model-managed working context (CLM)](context-management.md) is the default -compression mode. At the existing context threshold, Step first asks the model -to shorten eligible old observations in a validated working view. It keeps the -canonical history and protects user requirements and current tool groups. If no -useful edit is accepted, Step falls back to the native summary compaction -explained below. Provider context overflow goes directly to native recovery. - -Use `--context-projection off` or `compaction.contextProjection = "off"` to select -native compaction explicitly. `/compact` still requests a native summary; +Native summary compaction, explained below, is the default compression mode. +[Model-managed working context (CLM)](context-management.md) is opt-in: with +`--context-projection clm-v1`, `compaction.contextProjection = "clm-v1"`, or +`/clm on`, Step first asks the model at the threshold to shorten eligible old +observations in a validated working view, keeping the canonical history and +protecting user requirements and current tool groups. If no useful edit is +accepted, it falls back to native compaction. Provider context overflow always +goes directly to native recovery. `/compact` still requests a native summary; `/clm-compact` requests an explicit working-context edit. A settled CLM response with no queued continuation leaves routine maintenance until the next request. @@ -38,7 +37,7 @@ Both use the same structured summary format and track file operations cumulative Native compaction failures include a safe configuration snapshot in the error shown by TUI, RPC, and SDK. The snapshot reports the runtime model/provider/API, context window, model output limit, selected summary output budget, observed payload output budget when available, approximate input size, reasoning option, request attempts and elapsed time, stop reason and error kind. It also includes compaction reserve/retention and retry settings. -`selectedMaxTokens` is the caller's budget; `observedPayloadMaxTokens` is the numeric output cap observed through the provider payload callback after context/adapter adjustments. Custom streams that do not invoke this callback report `unknown`. Input estimates use serialized characters/4, not the provider tokenizer. Configuration provenance is currently `unknown`; values describe effective runtime settings, not a guessed disk configuration. +`selectedMaxTokens` is the caller's budget; `observedPayloadMaxTokens` is the numeric output cap observed through the provider payload callback after context/adapter adjustments. Custom streams that do not invoke this callback report `unknown`. Input estimates use serialized UTF-8 bytes/4, not the provider tokenizer. Configuration provenance is currently `unknown`; values describe effective runtime settings, not a guessed disk configuration. Non-cancelled failures append a versioned `step-compaction-failure` custom entry to the session JSONL (when persistence is enabled). This entry is not added to model context and contains no failed summary, prompt, headers, URL, or environment dump. Credential-shaped error text is redacted. Failure to persist diagnostics does not replace the original error. Cancelled requests do not create failure entries. @@ -57,11 +56,11 @@ contextTokens > min( ) ``` -`triggerRatio` defaults to `0.9` for every model (configurable globally or per model in `~/.stepcode/config.toml` or trusted `/.stepcode/config.toml`). Providers clamp each request's `max_tokens` to the remaining context minus a 4096-token safety margin, so the second term keeps room for the next response: on a small window 10% of the context is less than that margin. The trigger never drops below half the window. With an 8K-or-larger output limit, a 32K window compacts at 20,480 tokens (62.5%), 64K at 53,248 (81.25%), and 128K or larger at 90%. A response truncated by the clamp still goes through the overflow/length recovery below. `tokenLimit` can only make compaction trigger earlier. An explicitly configured `reserveTokens` keeps its old effect as an additional ceiling, `contextWindow - reserveTokens`. +`triggerRatio` defaults to `0.85` for every model (configurable globally or per model in `~/.stepcode/config.toml` or trusted `/.stepcode/config.toml`). Providers clamp each request's `max_tokens` to the remaining context minus a 4096-token safety margin, so the second term keeps room for the next response: on a small window 15% of the context is less than that margin plus the response reservation. The trigger never drops below half the window. With an 8K-or-larger output limit, a 32K window compacts at 20,480 tokens (62.5%), 64K at 53,248 (81.25%), and 131K or larger at 85%. On large windows the default leaves 15% of the window as headroom for the response and for estimation error, so a prompt the heuristic underestimates (images, unusual text) is less likely to exceed the provider limit before compaction runs. A response truncated by the clamp still goes through the overflow/length recovery below. `tokenLimit` can only make compaction trigger earlier. An explicitly configured `reserveTokens` keeps its old effect as an additional ceiling, `contextWindow - reserveTokens`. Step checks the threshold once immediately before every model request: before the first request of a prompt (counting the incoming prompt), before every follow-up request inside a tool loop (counting the new tool results and injected steering), and before the first request of a continuation. If the threshold is crossed, Step compacts inside the same agent run and resumes with the summary and retained messages. Steering queued while a follow-up request compacts is delivered to that same request. Input queued while the pre-run check compacts (or added by an `agent_start` listener) joins the first request and is measured again before it is sent; input typed while that first request's own check compacts is delivered with the next request. A final answer that crosses the threshold does not compact on its own; the next request compacts first. Context-overflow and truncated-length recovery still run after the failed response. If measuring or preparing maintenance throws unexpectedly, the request is sent unchanged and overflow recovery remains the fallback. -Token counts use the last valid assistant usage plus estimates of messages added after it. Usage reported before the latest compaction is ignored, because it measured the previous, larger context; without trustworthy usage, the estimate also includes the system prompt and tool schemas. +Token counts use the last valid assistant usage plus estimates of messages added after it, priced at four UTF-8 bytes per token (English prose and code sit near that ratio; CJK text is counted at its real cost instead of a quarter of it). Usage reported before the latest compaction is ignored, because it measured the previous, larger context; without trustworthy usage, the estimate also includes the system prompt and tool schemas. If automatic threshold compaction fails three times in a row, it pauses for the session and the third failure's message says so; while paused, Step does not measure or attempt automatic compaction. An unexpected error while measuring or preparing maintenance also counts, is recorded as a `step-compaction-failure` entry, and the request is sent unchanged. Cancelled compactions, extension cancellations, and errors raised after a compaction was saved do not count. A successful compaction (including `/compact`), an accepted CLM edit, a model switch, or a registry update that changes the model's context window resumes it. Overflow recovery is unaffected. @@ -439,7 +438,7 @@ Configure compaction in `~/.stepcode/config.toml` or trusted `/.ste ```toml [compaction] enabled = true -triggerRatio = 0.9 +triggerRatio = 0.85 keepRecentTokens = 20000 [compaction.modelTriggerRatios] @@ -449,7 +448,7 @@ keepRecentTokens = 20000 | Setting | Default | Description | |---------|---------|-------------| | `enabled` | `true` | Enable auto-compaction | -| `triggerRatio` | `0.9` | Fraction of the context window that triggers auto-compaction (0.5-0.95); small windows trigger earlier to keep response room | +| `triggerRatio` | `0.85` | Fraction of the context window that triggers auto-compaction (0.5-0.95); small windows trigger earlier to keep response room | | `modelTriggerRatios` | none | Per-model `triggerRatio`, keyed by `provider/model-id` | | `tokenLimit` | none | Absolute token ceiling; can only trigger earlier | | `triggerPolicy` | `"v2"` | `"legacy"` restores the previous threshold and checkpoints | diff --git a/packages/coding-agent/docs/context-management.md b/packages/coding-agent/docs/context-management.md index 37ffeaad2..1cc3f565f 100644 --- a/packages/coding-agent/docs/context-management.md +++ b/packages/coding-agent/docs/context-management.md @@ -1,11 +1,17 @@ # Model-managed working context -Step Code uses CLM (`clm-v1`) as its default compression mode when automatic -compaction is enabled. The model edits a validated working view of the +CLM (`clm-v1`) is an opt-in compression mode; the default is native summary +compaction (`off`). With CLM the model edits a validated working view of the conversation; the canonical session history remains intact. CLM uses the configured model and retains native summary compaction and provider-overflow recovery as fallbacks. +Native compaction is the default because, near a full window, CLM's maintenance +request carries almost the whole context (about 975K input tokens at a 1M window, +roughly 30s cold) to save about 12%, so the next request is still large; native +compaction leaves a summary plus the recent tail. Measured on a 930K-token +session: CLM 47–72s per prompt, native 16–19s. + ## Request notice stability Working-context status and pressure notices remain at their original positions @@ -22,29 +28,30 @@ record history and can require one cache warm-up. ## Select a compression mode -No flag or configuration change is needed to use CLM. An existing explicit -`off` or `lightweight-v1` setting is preserved. To use native compaction for one run: +Native compaction needs no flag or configuration. An existing explicit +`clm-v1` or `lightweight-v1` setting is preserved. To use CLM for one run: ```sh -step --context-projection off +step --context-projection clm-v1 ``` Or in `~/.stepcode/config.toml` (project settings use the usual trust rules): ```toml [compaction] -contextProjection = "off" +contextProjection = "clm-v1" ``` `clm-v1`, `lightweight-v1`, and `off` are mutually exclusive projection modes. `lightweight-v1` selects the existing deterministic request projection. `off` disables working-context projection and retains native automatic compaction. -Remove an explicit mode setting, select `clm-v1`, or use `/clm on` to enable CLM. -The `/clm on` and `/clm off` commands change only the current session. +Select `clm-v1` or use `/clm on` to enable CLM; remove the setting to return to +native compaction. The `/clm on` and `/clm off` commands change only the current +session. -If `compaction.enabled = false` and no mode is set, CLM is also disabled. An -explicit `contextProjection = "clm-v1"` keeps manual working-context edits -available while automatic maintenance remains disabled. Invalid mode values +An explicit `contextProjection = "clm-v1"` keeps manual working-context edits +available even when `compaction.enabled = false`, while automatic maintenance +remains disabled. Invalid mode values are treated as `off`. ## Automatic CLM maintenance @@ -56,7 +63,7 @@ next request. This avoids an unused context-edit/summary call after a completed task, while explicit maintenance commands and error recovery keep their normal behavior. By default it uses the native compact trigger, `contextTokens > floor(contextWindow * compaction.triggerRatio)` with a default -ratio of 0.9, so a 131,072-token window triggers above 117,964 tokens. Smaller +ratio of 0.85, so a 131,072-token window triggers above 111,411 tokens. Smaller windows trigger earlier to keep room for the next response. See [Compaction](compaction.md#when-it-triggers) for the exact rule, per-model ratios, and the legacy policy. With at least 8,000 context tokens and enough editable old text, CLM gets the first @@ -129,8 +136,17 @@ timeoutMs = 90000 maxOutputTokens = 8192 minSavingsTokens = 1024 minSavingsRatio = 0.05 +coldMaxPrefillTokens = 262144 ``` +`coldMaxPrefillTokens` bounds a maintenance request that cannot reuse the +actor's cached prefix (a cold start, a resumed session, or a draft edited since +the last request). Such a request makes the provider recompute the whole context +before the task can start, about 30 seconds at 975K tokens, while CLM typically +saves only around 12%. Above the bound the host skips CLM for that boundary and +runs native compaction, which leaves a far smaller context. Requests that reuse +the cached prefix are not affected. `0` removes the bound. + Leave `softThresholdRatio` unset to stay aligned with native compact. An explicit `softThresholdRatio = 0.85` requests an earlier trigger at 85%; the native reserve threshold still takes precedence if it is lower. Existing explicit percentages @@ -318,7 +334,7 @@ pnpm --filter @step-harness/providers exec vitest run test/context-estimate.test Task success, wall-clock improvement, and real API cost require paired model experiments. Compare the same model and tasks under native compaction (`off`), -lightweight projection, and default CLM, including the cost of maintenance and +lightweight projection, and CLM, including the cost of maintenance and summary requests. Size validation does not establish semantic losslessness or a universal quality or speed improvement. diff --git a/packages/coding-agent/docs/index.md b/packages/coding-agent/docs/index.md index 8b1c444ee..ed958453f 100644 --- a/packages/coding-agent/docs/index.md +++ b/packages/coding-agent/docs/index.md @@ -43,7 +43,7 @@ For the full first-run flow, see [Quickstart](quickstart.md). - [Keybindings](keybindings.md) - default shortcuts and custom keybindings. - [Sessions](sessions.md) - session management, branching, and tree navigation. - [Compaction](compaction.md) - context compaction and branch summarization. -- [Model-managed working context](context-management.md) - default CLM compression, controls, and native fallback. +- [Model-managed working context](context-management.md) - opt-in CLM compression, controls, and native fallback. ## Customization diff --git a/packages/coding-agent/docs/settings.md b/packages/coding-agent/docs/settings.md index 9667e182a..731c0bdfb 100644 --- a/packages/coding-agent/docs/settings.md +++ b/packages/coding-agent/docs/settings.md @@ -109,7 +109,7 @@ For VS Code, include `--wait` so step resumes after the editor exits: | Setting | Type | Default | Description | |---------|------|---------|-------------| | `compaction.enabled` | boolean | `true` | Enable auto-compaction | -| `compaction.triggerRatio` | number | `0.9` | Fraction of the context window that triggers auto-compaction (0.5-0.95); small windows trigger earlier to keep response room | +| `compaction.triggerRatio` | number | `0.85` | Fraction of the context window that triggers auto-compaction (0.5-0.95); small windows trigger earlier to keep response room | | `compaction.modelTriggerRatios` | object | `{}` | Per-model trigger ratios keyed by `provider/model-id` | | `compaction.tokenLimit` | number | - | Absolute trigger ceiling; can only trigger earlier | | `compaction.triggerPolicy` | string | `"v2"` | `"legacy"` restores the previous `contextWindow - reserveTokens` trigger and checkpoints | @@ -122,7 +122,7 @@ For VS Code, include `--wait` so step resumes after the editor exits: { "compaction": { "enabled": true, - "triggerRatio": 0.9, + "triggerRatio": 0.85, "keepRecentTokens": 20000 } } @@ -149,6 +149,7 @@ budget. `compaction.reserveTokens` does not set a separate summary output cap. | `retry.provider.timeoutMs` | number | SDK default | Provider/SDK request timeout in milliseconds | | `retry.provider.maxRetries` | number | `0` | Provider/SDK retry attempts | | `retry.provider.maxRetryDelayMs` | number | `60000` | Max server-requested delay before failing (60s) | +| `retry.provider.streamIdleTimeoutMs` | number | `300000` | Longest wait for the next parsed provider event before the request is cancelled and retried as a transient error; keep-alive bytes do not count. `0` disables it | When a provider requests a retry delay longer than `retry.provider.maxRetryDelayMs`, the request fails immediately with an informative error instead of waiting silently. Set it to `0` to disable the limit. @@ -356,7 +357,7 @@ See [packages.md](packages.md) for package management details. "theme": "dark", "compaction": { "enabled": true, - "triggerRatio": 0.9, + "triggerRatio": 0.85, "keepRecentTokens": 20000 }, "retry": { @@ -379,7 +380,7 @@ Project settings (`.stepcode/settings.json`) override global settings. Nested ob // ~/.stepcode/agent/settings.json (global) { "theme": "dark", - "compaction": { "enabled": true, "triggerRatio": 0.9 } + "compaction": { "enabled": true, "triggerRatio": 0.85 } } // .stepcode/settings.json (project) @@ -396,12 +397,12 @@ Project settings (`.stepcode/settings.json`) override global settings. Nested ob ### Model-managed context -`compaction.contextProjection` defaults to `clm-v1` when automatic compaction is -enabled. It also accepts `off` (native compaction) and `lightweight-v1` -(deterministic request projection); explicit settings remain unchanged. -Default CLM maintenance inherits native compaction's -`contextWindow * compaction.triggerRatio` threshold and falls back to native -compaction if no valid useful edit can be accepted. +`compaction.contextProjection` defaults to `off`: native summary compaction. +CLM is opt-in with `contextProjection = "clm-v1"` (or `/clm on` for the current +session); `lightweight-v1` selects the deterministic request projection. +Explicit settings remain unchanged. When enabled, CLM maintenance inherits native +compaction's `contextWindow * compaction.triggerRatio` threshold and falls back +to native compaction if no valid useful edit can be accepted. `compaction.autoClm.enabled = false` disables automatic CLM maintenance while retaining the working view, manual edits, and native compaction. diff --git a/packages/coding-agent/test/repro/README.md b/packages/coding-agent/test/repro/README.md new file mode 100644 index 000000000..c54de4427 --- /dev/null +++ b/packages/coding-agent/test/repro/README.md @@ -0,0 +1,734 @@ +# 近满上下文压缩卡顿：复现、真机压测与四家实现对比 + +> 适用分支：step-harness `feat/stepcode-desktop-ci-pipeline-build`（commit `c174e430`） +> 模型：`stepcode-anthropic / deepseek-v4.1-flash-api`；配置窗口 1,000,000；网关实际窗口 **1,048,576**；每次请求输出上限 128,000 +> 对比对象：`codex`（55897425e8）、`pi`（7d073328e）、`deepseek-harness`（fcc0ad4621） +> 本文是唯一文档。mock 复现、真机压测、日志证据、时序图、四家对比、问题清单都在这里。 + +## 目录 + +0. [一页结论](#0-一页结论) +1. [名词释义](#1-名词释义) +2. [step-harness 现在怎么压缩（时序图）](#2-step-harness-现在怎么压缩时序图) +3. [真机压测：慢是真的](#3-真机压测慢是真的) +4. [真机压测：估算偏低 → 被拒收 → 直接失败](#4-真机压测估算偏低--被拒收--直接失败) +5. [日志证据：单个请求挂 20 分钟](#5-日志证据单个请求挂-20-分钟) +6. [mock 复现与稳定性](#6-mock-复现与稳定性) +7. [四家对比：codex / pi / deepseek-harness / step-harness](#7-四家对比codex--pi--deepseek-harness--step-harness) +8. [问题清单与可借鉴的修法](#8-问题清单与可借鉴的修法) +9. [更正记录](#9-更正记录) +10. [怎么复跑](#10-怎么复跑) +11. [修复方案与执行计划](#11-修复方案与执行计划) + +--- + +## 0. 一页结论 + +用户说“上下文快满时，什么任务都特别慢，二三十分钟不动”。实际是三件事叠在一起： + +| # | 现象 | 是否复现 | 说明 | +| --- | --- | --- | --- | +| 1 | **越满越慢** | ✅ 真机稳定复现 | 同一条命令：6 万上下文 5.8 秒，93 万上下文 62 秒；首字延迟 4 秒 → 26 秒。快满时每条消息前面还要先发一个**和整份上下文一样大**的压缩请求（实测 97.5 万 token，约 30 秒）。 | +| 2 | **突然失败、不动了** | ✅ 真机稳定复现 | 末尾有大段中文工具输出时，宿主把 token 少算了 2.45 倍，以为没到阈值，就没压缩；实际请求超出网关上限，被 400 拒收。网关有两种报错文案，**其中一种程序认不出来**：不压缩、不重试，直接结束。真实场景 7 次里 5 次直接失败，**默认的 CLM 模式也会中**。 | +| 3 | **挂二三十分钟** | ❌ 没复现，只有日志证据 | 单个请求在服务端挂住，客户端对单个请求没有总时长上限。本机日志里有 19.5 分钟、11.6 分钟两次。这本身不是压缩引起的，但快满时请求更大、更多，更容易碰上。 | + +和其他三家比： +- **codex** 按“字节数 ÷ 4”估算中文，不会少算；溢出靠结构化错误码识别，压缩请求自己溢出时会删掉最老的一条再试。 +- **deepseek-harness** 的阈值是 80%，并直接扣掉“输出上限 + 6.4 万余量”；压缩前先裁剪超长工具输出，摘要请求复用前缀缓存。 +- **pi**（我们的上游）阈值更靠后（窗口 − 16,384），估算方式和溢出识别跟我们一样，所以同样的坑它也会踩。 + +--- + +## 1. 名词释义 + +| 术语 | 大白话 | +| --- | --- | +| **上下文（context）** | 每次发给模型的全部内容：聊天记录 + 系统说明 + 工具说明。模型每次都要从头读一遍，越长越慢。StepCode 光系统说明加工具定义就有约 **2.8 万 token**。 | +| **token** | 模型计量文字的单位。实测这个模型：英文代码约 3.8 个字符 1 个 token；**中文约 1.6 个字 1 个 token（0.61 token/字）**。 | +| **窗口（context window）** | 一次最多能读多少 token。配置写的是 100 万，网关实际是 104.8 万；而且“输入 + 输出上限”加起来不能超过它。 | +| **宿主（host）** | 我们自己的客户端程序（StepCode），负责拼上下文、决定何时压缩、把请求发给网关。 | +| **网关 / 模型** | 远端服务，真正读上下文、生成回复。 | +| **阈值（threshold）** | “快满了”的判断线。step-harness 是 **90 万**，超过就先压缩再干活。 | +| **估算（estimate）** | 宿主自己算的“现在大概多少 token”。最近一次回复带回的 usage 是准的；之后新增的内容只能粗算：step-harness/pi 用“**字符数 ÷ 4**”，codex 用“**字节数 ÷ 4**”。 | +| **usage** | 网关回复里附带的“这次实际用了多少 token”，最准。 | +| **压缩（compaction）** | 快满时把旧内容变短，给新内容腾地方。 | +| **CLM** | step-harness 默认的压缩方式（文档叫 model-managed working context，模型托管的工作上下文）。宿主把对话复印成一份“草稿”，请模型挑几段过时的长内容改成一句话；原始记录不动，之后发给模型的是改短后的草稿。 | +| **维护请求（maintenance）** | 为 CLM 专门发的一次请求。跟你的任务无关，但**要带着几乎整份上下文**（实测 97.5 万 token）。 | +| **CLM 接受 / 拒绝** | 模型交回改写清单后，宿主核对：只改了允许改的段落、而且至少省下 5%，就接受，草稿生效；否则就拒绝（包括超时、模型没改），改走原生摘要。 | +| **原生摘要（native compaction）** | 老办法：请模型写一份“交接总结”，把旧对话整段替换掉，只保留最近约 2 万 token 原文。工具输出会先截短，所以这个请求比 CLM 小（实测约 13 万）。 | +| **输出上限（max_tokens）** | 每次请求声明“最多让模型写多少”，这里是 12.8 万，也占窗口。provider 层会按“窗口 − 估算输入 − 4096”把它往下压，但用的仍是那个**估算值**。 | +| **溢出（overflow）** | 请求太大，被网关拒收（HTTP 400）。宿主**认得出**就先压缩再重发；**认不出**就当普通错误，直接结束。 | +| **重试（retry）** | 失败后隔几秒再发。摘要请求最多发 4 次（重试 3 次，间隔 2、4、8 秒）。 | +| **暂停自动压缩** | 自动压缩连续失败 3 次后，这个会话不再自动压缩，直到手动 `/compact` 成功。 | +| **缓存（cache）/ 冷缓存** | 网关会记住最近读过的开头，再读同样开头就很快（热）；第一次读或开头变了就要全算一遍（冷）。 | +| **首字延迟（TTFT）** | 发出请求到模型吐出第一个字的时间，快满时主要耗在读上下文上。 | +| **空闲超时（idle timeout）** | 客户端只在“**300 秒一点数据都没收到**”时才放弃。只要服务端偶尔发点东西就会一直等，**单个请求没有总时长上限**。 | +| **前缀缓存复用** | 压缩请求的开头和正常请求完全一样，网关就能用缓存，只算新增的部分。codex、deepseek-harness 都刻意这么设计。 | +| **工具输出裁剪（pruning）** | 不调用模型，直接把过长的旧工具输出截短。deepseek-harness 在摘要前先做这一步，够了就不摘要。 | + +--- + +## 2. step-harness 现在怎么压缩（时序图） + +### 2.1 检查时机与阈值 + +- **什么时候检查**：每条消息开始前检查一次；工具回合之间，**每次发模型请求前**再检查一次（`beforeModelRequest` 钩子，trigger policy v2）。 +- **阈值**：`min(floor(窗口 × 0.9), max(窗口 − 4096 − min(输出上限, 8192), 窗口 × 0.5))`。100 万窗口时算出来是 **900,000**。 +- **怎么量**： + - 原生模式：最近一次 usage，加上之后新增内容的“字符数 ÷ 4”； + - CLM 模式：整份草稿“字符数 ÷ 4 × 校准系数”。校准系数从真实 usage 学出来，范围 1–4，每次启动都从 1 开始。 +- **输出预留**：阈值只为输出留 8,192，剩下的靠 provider 层的 `clampMaxTokensToContext` 把 `max_tokens` 压到“窗口 − 估算输入 − 4096”。两道保险**用的都是同一个估算值**。 + +### 2.2 总时序图（一条消息从发出到结束的所有分叉） + +```mermaid +sequenceDiagram + autonumber + participant U as 用户 + participant H as StepCode（宿主） + participant G as 网关 / 模型 + + U->>H: 发一条消息（任何任务） + H->>H: 估算上下文（usage + 新增内容按 字符数÷4） + + alt 估算 < 90 万（没到阈值） + H->>H: max_tokens = min(12.8万, 100万 − 估算 − 4096) + H->>G: 任务请求 + alt 实际输入 + max_tokens ≤ 104.8 万 + G-->>H: 正常回复（近满时首字约 26 秒） + else 估算偏低，实际已超（中文工具输出时常见） + G-->>H: 400 拒收，两种文案之一 + alt 文案 A：maximum context length（能认出） + H->>H: 识别为溢出 → 原生摘要 + H->>G: 摘要 → 重发任务 + G-->>H: 成功（一共约 90 秒） + else 文案 B：The input you provided is invalid（认不出） + H-->>U: 不压缩、不重试，直接失败（约 28 秒） + end + end + else 估算 ≥ 90 万（到阈值） + H->>G: ① CLM 维护请求（≈ 整份上下文 97.5 万，整段限时 90 秒） + alt CLM 接受 + G-->>H: 改写清单 → 核对通过 → 草稿变短（93.5 万 → 82.4 万） + else 拒绝 / 超时 / 空间不够 + H->>G: ② 原生摘要请求（约 13 万，失败最多发 4 次） + alt 摘要成功 + G-->>H: 交接总结替换旧对话 + else 摘要失败 + H->>H: 失败计数 +1（连续 3 次就暂停自动压缩） + Note over H: 压缩没成功，任务照样按满上下文发出 + end + end + H->>G: ③ 任务请求 + G-->>H: 回复 + end + H-->>U: 显示结果 +``` + +### 2.3 场景 A：快满了，CLM 成功——能用，但慢 + +```mermaid +sequenceDiagram + autonumber + participant U as 用户 + participant H as StepCode + participant G as 网关 + U->>H: 消息 + H->>H: 估算 95.9 万 ≥ 90 万 → 要压缩 + H->>H: 把对话复印成草稿，挑出最长的 32 段做成目录 + H->>G: CLM 维护请求（整份对话 + 目录 + “请挑几段改短”） + Note over G: 读 97.5 万 token（冷缓存） + G-->>H: 改写清单（约 30 秒后） + H->>H: 核对：省下 11 万（12%）≥ 5% → 接受 + H->>G: 任务请求（82.4 万） + Note over G: 首字 26 秒 + G-->>H: 回复 + H-->>U: OK（整条命令 62 秒） +``` + +慢在哪：先多发一个和整份上下文差不多大的请求（约 30 秒），任务请求自己也要读八十多万 token（约 26 秒）。草稿只省了 12%，所以很快又会碰到阈值；每隔 3 个完成的回合，维护请求就会再来一次。 + +### 2.4 场景 B：CLM 不成功 → 原生摘要 → 摘要也失败 + +```mermaid +sequenceDiagram + autonumber + participant H as StepCode + participant G as 网关 + H->>G: CLM 维护请求（97 万） + G--xH: 90 秒内没回 / 改得不够 / 空间不够 + loop 摘要最多 4 次（每次间隔 2s、4s、8s） + H->>G: 原生摘要请求（约 13 万） + G--xH: 失败（超时 / 断开） + end + H->>H: 压缩失败计数 +1 + H->>G: 任务请求：压缩没成功，照样按满上下文发出 + Note over H: 下一条消息再完整走一遍
连续失败 3 次才暂停自动压缩 +``` + +一次失败的压缩 = 1 个维护请求 + 4 个摘要请求 + 1 个满载任务请求。下一条消息还会再来一遍，直到连续失败 3 次。mock 压测中“4 条消息 → 12 次摘要尝试 → 第 4 条暂停”稳定复现。 + +### 2.5 场景 C：估算偏低 → 被拒收 → 多数直接失败（真机实测） + +```mermaid +sequenceDiagram + autonumber + participant U as 用户 + participant H as StepCode + participant G as 网关 + Note over H: 最近一次 usage 准确：80.6 万
之后新增 22 万字中文工具输出 + U->>H: 消息 + H->>H: 中文按 字符数÷4 估成 5.5 万（实际约 13.4 万） + H->>H: 估算 ≈ 86 万 < 90 万 → 不压缩 + H->>H: max_tokens = min(12.8万, 100万−86万−4096) = 12.8 万 + H->>G: 任务请求：实际 95.2 万 + 12.8 万 = 108 万 + Note over G: 超过 104.8 万上限 + alt 少数情况：文案 A + G-->>H: 400 "maximum context length is 1048576 tokens..." + H->>H: 认出溢出 → 原生摘要 → 重发 + G-->>H: 成功（约 91 秒） + else 多数情况：文案 B + G-->>H: 400 "The input you provided is invalid [code=30003]" + H->>H: 不在溢出识别规则里，也不是可重试错误 + H-->>U: 直接失败（约 28 秒） + end +``` + +两道保险同时失效：阈值判断和 `max_tokens` 夹紧用的是同一个偏低的估算。配置窗口（100 万）比网关真实窗口（104.8 万）小，这本身留出了约 5.3 万的容错；但中文工具输出一多，少算的部分就会超过这个容错。 + +### 2.6 场景 D：单个请求挂住——“二三十分钟不动”（日志证据） + +```mermaid +sequenceDiagram + autonumber + participant H as StepCode + participant G as 网关 + H->>G: 任意请求（任务 / 维护 / 摘要都可能） + G-->>H: 少量数据（如几个字的思考） + Note over G: 之后长时间没有实质进展 + Note over H: 只在“300 秒一点数据都没有”时才放弃
连接上偶尔有字节就会一直等（推测为心跳） + G--xH: 11–20 分钟后连接被服务端断开（terminated） + H->>G: 2 秒后重试 + G--xH: 502 +``` + +--- + +## 3. 真机压测：慢是真的 + +方法：`/tmp/real-compaction/run.py` 先生成一个指定大小的会话文件（用户消息 + 工具调用 + 1.54 万字符的工具输出），再用真实 CLI 打开它： + +``` +node apps/cli/dist/main.js --session <会话文件> -p "Reply with exactly: OK" [--context-projection off] +``` + +由于会话已经满了，CLI 的第一件事就是触发真实的压缩检查。整个过程不用 mock，走真实网关；本文共跑了 40 余次。 + +### 3.1 同一条命令，只改上下文大小 + +| 上下文 | 模式 | 维护请求（输入 / 缓存命中） | 任务请求耗时 | 首字 | 整条命令 | +| --- | --- | --- | --- | --- | --- | +| 6.3 万 | CLM | 不触发 | 4.1s | 4.1s | **5.8s** | +| 90 万 | CLM | 941,395 / 512 | 16.1s | 3.5s | 42.3s | +| 93 万（冷） | CLM | 975,243 / 0 | 26.4s | **26.3s** | **62.3s** | +| 93 万（冷） | CLM | 974,731 / 512 | 17.7s | 4.7s | 47.2s | +| 93 万（热） | CLM | 1,621 / 971,904 | 21.4s | 7.5s | 33.8s | +| 93 万 | 原生 | 不走 CLM，摘要后任务 | 1.5s | 0.45s | **19.4s** | +| 98.5 万 | CLM | CLM 估算已 ≥ 窗口，跳过，直接原生摘要 | 1.7s | 0.8s | 17.9s | + +结论： +1. 近满时首字延迟从 4 秒涨到最多 26 秒，约 6 倍。 +2. CLM 每次先发一个约 **97.5 万 token** 的维护请求，几乎等于整份上下文。冷缓存时这一步约 30 秒。 +3. **在近满这个位置，默认的 CLM 反而比原生摘要慢**：CLM 要 34–62 秒，原生摘要 19 秒。原因是 CLM 只省 12%，压完任务请求仍有 82 万；原生摘要压完只剩几万，任务请求 1.5 秒就回来了。 +4. 网关缓存命中时（维护请求 97 万都命中），整体能降到 34 秒左右。但这依赖“刚刚用同样开头发过请求”，冷启动、恢复会话、改过草稿后都拿不到这个缓存。 + +--- + +## 4. 真机压测：估算偏低 → 被拒收 → 直接失败 + +### 4.1 网关原话 + +``` +400 invalid_request_error +This model's maximum context length is 1048576 tokens. However, you requested 1080471 tokens +(952471 in the messages, 128000 in the output). +``` +``` +400 invalid_request_error +The input you provided is invalid [trace_id=... code=30003] +``` + +同一个“太长了”，网关有两种说法。第一种能被 `OVERFLOW_PATTERNS` 里的 `/maximum context length is \d+ tokens/i` 认出来；第二种**任何规则都匹配不上**，而它的错误类型是 `invalid_request`，不属于可重试错误，所以程序直接结束。 + +### 4.2 中文到底被少算了多少（实测） + +| 内容 | 实际 token | step-harness / pi（字符数÷4） | codex（UTF-8 字节数÷4） | +| --- | --- | --- | --- | +| 22,000 个汉字 | **13,476**（0.61/字） | 5,500（**少算 2.45 倍**） | 16,500（多算 1.22 倍，偏保守） | +| 英文构建日志 | 字符数 ÷ 3.78 | 少算约 6% | 少算约 6%（ASCII 字节 = 字符） | +| 空会话（系统说明 + 工具） | 28,195 | — | — | + +### 4.3 真实场景复现（usage 准确 + 末尾一段中文工具输出） + +构造方式：历史部分 76 万字符数估算，usage 按实测比例填准（`SCALE=1.06`）；最后一个工具回合返回 22 万字中文。宿主估算约 86 万，网关实际收到 95.2 万。 + +| 模式 | 结果 | +| --- | --- | +| 原生 `--context-projection off` | **4/4 直接失败**（文案 B，约 28–34 秒） | +| 默认 CLM | **1 次直接失败**，2 次认出溢出 → 压缩 → 成功（约 91 秒） | +| 合计 | **7 次里 5 次直接失败** | + +注意：默认 CLM 模式下，CLM 本身也没触发。原因是 CLM 的估算同样按“字符数 ÷ 4”算中文，同样低于 90 万。 + +### 4.4 边界扫描（整段 usage 都按“字符数 ÷ 4”填，即没有可信 usage 的路径） + +| 规模 | 结果 | +| --- | --- | +| 86 万 | 4 次恢复，1 次直接失败 | +| 87 万 | 1 次恢复 | +| **88 万** | **13 次里 10 次直接失败**，3 次恢复 | +| 89 万 | 2 次恢复，2 次直接失败 | +| 89.5 万 / 90 万 | 4/4 正常（估算已过阈值，先压缩再发） | +| 88 万 + `SCALE=1.06`（usage 准确） | 3/3 正常，先压缩再发 | + +结论： +- 只要估算准，就不会掉进这个缝； +- 估算一偏低（中文工具输出、没有可信 usage、冷启动时 CLM 校准系数为 1），请求就会超限； +- 一旦超限，网关**大约七成**会返回认不出的那种文案，导致直接失败。 + +--- + +## 5. 日志证据：单个请求挂 20 分钟 + +来源：本机 `~/.stepcode/agent/sessions/` 下的 2834 条带计时的请求（`stepcode-web.thinking-timing` + `step.usage_provenance`）。 + +| 上下文 | 样本数 | 首字中位 | 首字最大 | +| --- | --- | --- | --- | +| 1–10 万 | 453 | 2.1s | 20s | +| 10–30 万 | 944 | 3.2s | 57s | +| 30–60 万 | 1124 | 7.0s | 47s | +| 60–90 万 | 237 | **18.9s** | **206s** | + +最长的三条都是**单个请求**，不是重试链： + +| 时长 | 上下文 | 过程 | +| --- | --- | --- | +| 19.5 分钟 | 26.9 万 | 270 秒才出第一个字，只出了 22 个字的思考，之后约 15 分钟没有进展，`terminated`；2 秒后重试，502 | +| 11.6 分钟 | 前序 87 万 | 吐了 5.5k 字思考 + 4.1k 字 `edit_file` 参数后 `terminated` | +| 13.7 分钟 | 32 万 | 正常生成，写满 12.8 万输出上限（`stopReason=length`） | + +19.5 分钟那次，中间有超过 300 秒没有进展，却没被客户端掐掉，说明连接上一直有字节在走（推测是心跳）。**客户端对单个请求没有总时长上限**，是“挂二三十分钟”的直接原因；它不只发生在快满时，26.9 万上下文也出现过。 + +--- + +## 6. mock 复现与稳定性 + +用 faux provider（假模型）驱动**真实的 `AgentSession`**，确定性地复现“发了哪些请求、按什么顺序、每个多大”。这些测试跟网络无关，所以不能说明耗时。 + +```sh +cd packages/coding-agent +pnpm exec vitest --run test/repro/context-pressure-scenarios.test.ts # 15 个场景 +pnpm exec vitest --run test/repro/context-pressure-scale.test.ts # 30/60/90 万载荷与本地开销 +pnpm exec vitest --run test/repro/context-pressure-stress.test.ts # 稳定性 / 风暴 / 窗口扫描 +``` + +### 6.1 15 个场景（20 万窗口、93% 满，括号内为输入 token） + +| 场景 | 请求序列 | +| --- | --- | +| CLM 接受（private tool） | 维护 188,374 → 任务 146,012 | +| CLM 无编辑 / 非法 JSON / 超时 | 维护 188,374 → 摘要 27,538 → 任务 4,565 | +| 仅原生 | 摘要 27,538 → 任务 4,017 | +| 摘要失败、重试 3 次 | 摘要×4 → **任务 187,116（没压缩）** → 下一条消息再来摘要×4 → 任务 | +| 摘要写满输出上限（length） | 摘要 → **任务 187,116** | +| 低于阈值时 provider 报溢出 | 任务 102,588 → 摘要 15,208 → 任务 4,017 | +| lightweight-v1 / 关闭自动 CLM / 手动 `/compact` | 摘要 → 任务 | +| legacy 触发策略 | 同“CLM 接受” | +| 普通回合后越过阈值（复用缓存前缀） | 任务 92,578 → 维护（cached-json）189,120 → 任务 146,032 | +| split turn（单个超大回合） | 历史摘要 844 + 前缀摘要 26,638 → 任务 4,025 | + +### 6.2 90 万规模的载荷与本地开销 + +- CLM 维护请求 946,315 token（完整历史 + 约 1.4k 目录）；原生摘要请求 129,066 token（工具输出截到约 2.4k 字符）。 +- 每次请求都会把约 93 万 token 的 mirror 文档写到磁盘。 +- 本地 CPU：digest 7ms、JSON 深拷贝 6ms、mirror 渲染落盘 45ms。**客户端不是瓶颈。** + +### 6.3 稳定性压测 + +- 核心场景各重复 10 次、整套连跑 3 次，请求序列完全一致（只有 ±1 token 的估算噪声）。 +- 超时风暴（摘要必失败，连续 4 条消息）：发出 16 个请求，其中 12 次摘要尝试；第 4 条消息时已暂停自动压缩（失败计数 = 3）。 +- 窗口扫描： + - 64k 窗口、200k@99% 时，因为留给维护请求的空间不够，跳过 CLM，直接走原生摘要； + - 100k–1M 都是先走 CLM； + - 1M@92/96/99% 时，CLM 接受后任务仍有 80.6 / 84.5 / 87.6 万。 +- 每个请求人为加 40ms 延迟：序列不变，只有耗时线性变长。 + +--- + +## 7. 四家对比：codex / pi / deepseek-harness / step-harness + +### 7.1 对比总表（按 100 万窗口、12.8 万输出上限换算） + +| 维度 | step-harness（本仓库） | pi（上游） | codex | deepseek-harness | +| --- | --- | --- | --- | --- | +| **触发阈值** | `min(窗口×0.9, 窗口−4096−min(输出,8192))` → **90 万** | `窗口 − 16,384` → **98.4 万** | `min(配置, 窗口×0.9)` → **90 万**；另有硬上限 `窗口×95%` | `floor(min(窗口×0.8, 窗口−输出−65,536))` → **80 万** | +| **用量怎么量** | 最近 usage + 新增内容 字符数÷4；CLM：全部 字符数÷4×校准系数 | 最近 usage；报错或 usage 为 0 时按 字符数÷4 | 最近服务端 usage + 新增内容 **UTF-8 字节数÷4** | token-meter：请求一模一样时复用 usage，否则启发式（字符数÷4，文档自承中文低估） | +| **何时检查** | 每条消息前 + 每次模型请求前 | 每条消息前 + 工具回合之间 + 回合结束后 | 回合前 + 每次采样后（工具循环中）+ 可选回合后；可选后台预压缩（65%，仅 OpenAI 远端） | 每一步请求前（`agent/pre-step`）+ 换模型时 | +| **压缩方式** | CLM（模型改草稿）优先，失败回退原生摘要 | 原生摘要 | 远端 `/responses/compact`（OpenAI）或本地：整段历史 + 摘要提示词 → 摘要 | **先裁剪超长工具输出（不调模型）**，不够再摘要最老的一段 | +| **压缩请求多大** | CLM ≈ 整份上下文；摘要 ≈ 截断后的历史 | 截断后的历史 | ≈ 整份历史，但开头与正常请求一致，**能命中缓存** | 只含被替换的那段，**刻意复用前缀缓存** | +| **压完保留什么** | CLM：草稿改短 12% 左右；摘要：总结 + 最近 2 万 | 总结 + 最近 2 万 | 总结 + 最近的用户消息（≤ 2 万） | 总结 + 最近 `16% × (窗口 − 输出)` ≈ 14 万 | +| **压缩失败怎么办** | 摘要最多 4 次；任务照发；连续 3 次暂停 | 按重试策略；溢出恢复只做 1 次 | 普通错误重试 5 次；**压缩请求自己溢出就删掉最老一条再试** | 摘要必须真的变短，否则算失败；额外重试 1 次；失败只告警，继续 | +| **怎么认出溢出** | 文本正则（`OVERFLOW_PATTERNS`） | 同左（同源） | **结构化错误码** `context_length_exceeded` | 文本正则（`isContextWindowExceededError`） | +| **溢出后** | 认出 → 压缩 → 重试 1 次；认不出 → 直接失败 | 同左 | 标记“已满”，本回合报错，下一回合开始前压缩 | 认出 → 最大化裁掉开头 → 重试（最多 1 次） | +| **输出空间怎么留** | 阈值留 8,192，provider 按估算压 `max_tokens` | 阈值留 16,384，provider 同样夹紧 | 只把 95% 窗口当可用 | **阈值直接扣掉“输出上限 + 6.4 万”** | +| **请求超时** | 300 秒无数据才放弃，无总时长 | 未核实 | 300 秒无数据，重试 5 次 | 未核实 | + +### 7.2 codex 时序图 + +```mermaid +sequenceDiagram + autonumber + participant U as 用户 + participant C as codex + participant G as 模型（OpenAI Responses） + U->>C: 消息 + C->>C: 用量 = 最近服务端 usage + 新增内容 字节数÷4 + opt 用量 ≥ 90%（回合前） + C->>G: 本地压缩：整段历史 + 摘要提示词（开头相同，命中缓存） + alt 压缩请求本身超长 + C->>C: 删掉最老的一条，再发 + else 网络等普通错误 + C->>C: 退避重试（最多 5 次） + end + G-->>C: 摘要 + C->>C: 新历史 = 初始上下文 + 最近用户消息（≤2万）+ 摘要 + end + loop 工具循环 + C->>G: 采样请求 + G-->>C: 回复 / 工具调用 + C->>C: 采样后再量一次 + opt 用量 ≥ 90% 且还要继续 + C->>G: 回合中压缩（同上） + end + opt 后台预压缩（特性开关，仅 OpenAI 远端压缩） + C-)G: ≥ 65% 时在后台先算好压缩结果 + Note over C: 真到阈值时直接换上，不用等 + end + end + alt 收到 context_length_exceeded（结构化错误码） + C->>C: 把用量标记为“已满”，本回合报错 + Note over C: 下一回合开始前必然先压缩 + end + C-->>U: 结果 +``` + +可借鉴： +- **字节数 ÷ 4**：中文不会被少算； +- 溢出靠**错误码**识别，不靠文案； +- 压缩请求自己超长时**逐条删掉最老的再试**，不会卡死； +- 压缩请求的开头和正常请求一致，**能吃到缓存**； +- 后台预压缩把等待时间藏起来。 + +### 7.3 pi 时序图（step-harness 的上游） + +```mermaid +sequenceDiagram + autonumber + participant U as 用户 + participant P as pi + participant G as 模型 + U->>P: 消息 + P->>P: 用最近一次 usage 判断 > 窗口 − 16,384 ？ + opt 超过 + P->>G: 原生摘要（截断后的历史） + G-->>P: 总结 → 替换旧对话 + end + loop 工具循环 + P->>P: 下一次请求前按估算再判断 + opt 超过 + P->>G: 原生摘要 + end + P->>G: 任务请求（max_tokens 按 窗口−估算−4096 夹紧） + alt 认出溢出（文本正则） + G-->>P: 400 + P->>P: 删掉失败的回复 → 摘要 → 重试 1 次 + opt 再次溢出 + P-->>U: “压缩后仍然溢出”，结束 + end + else 认不出 + G-->>P: 400 + P-->>U: 当普通错误，结束 + end + end + P-->>U: 结果 +``` + +和 step-harness 的关系： +- step-harness 在 pi 基础上加了 CLM、把阈值从“窗口 − 16,384”改成了 90%、加了“每次请求前都检查”； +- **估算方式（字符数 ÷ 4）和溢出识别规则沿用了 pi**，所以场景 C 的坑 pi 一样会踩； +- 而且 pi 阈值更靠后（98.4 万），只会更早撞上网关上限。 + +### 7.4 deepseek-harness 时序图 + +```mermaid +sequenceDiagram + autonumber + participant U as 用户 + participant D as deepseek-harness + participant T as token-meter + participant G as 模型 + U->>D: 消息 + loop 每一步请求前（agent/pre-step） + D->>T: 量当前请求（同一请求复用 usage，否则估算） + T-->>D: 用量 + opt 用量 ≥ min(80%, 窗口 − 输出上限 − 6.4万) + D->>D: ① 先裁剪超长的旧工具输出（不调模型） + D->>T: 重新量 + opt 仍超过阈值 + D->>G: ② 摘要请求：系统说明 + 被替换那段（与正常请求同开头，命中缓存）+ 指令 + G-->>D: 总结（上限 6.4 万） + D->>D: 必须真的变短，否则算失败 + D->>D: 替换最老的一段，保留最近约 14 万原文 + end + end + D->>G: 任务请求 + alt 认出 CONTEXT_WINDOW_EXCEEDED（文本正则） + G-->>D: 400 + D->>D: 不看阈值，最大化裁掉开头 → 重试（最多 1 次） + end + end + D-->>U: 结果 +``` + +可借鉴： +- **阈值把输出上限和 6.4 万余量直接扣掉**，估算偏一点也不会超； +- **先裁剪工具输出**：不调模型、零等待，很多时候就够了； +- 摘要请求只带被替换的那段，并且刻意复用前缀缓存； +- 每次压缩都写“开始 / 结束”标记，崩溃了也能看出来是哪次没做完。 + +### 7.5 同一个场景，四家会怎样（场景 C：usage 准确 + 末尾 22 万字中文） + +| | 估算 | 是否先压缩 | 结果 | +| --- | --- | --- | --- | +| **step-harness** | 80.6 万 + 5.5 万 ≈ 86 万 < 90 万 | 否 | **实测 7 次里 5 次直接失败** | +| **pi**（推演） | 同上 ≈ 86 万 < 98.4 万 | 否 | 同样超限；识别规则相同，同样会失败 | +| **codex**（推演） | 80.6 万 + 16.5 万 ≈ 97 万 ≥ 90 万 | **是** | 先压缩，不会超限 | +| **deepseek-harness**（推演） | ≈ 86 万 ≥ 80 万 | **是** | 先压缩，不会超限 | + +“推演”指按各家代码的公式计算，没有在真机上跑。codex 靠更准的中文估算躲开，deepseek-harness 靠更保守的阈值躲开。 + +--- + +## 8. 问题清单与可借鉴的修法 + +| # | 问题 | 后果 | 位置 | 可借鉴 | +| --- | --- | --- | --- | --- | +| 1 | 网关的 `The input you provided is invalid [code=30003]` 不在溢出识别规则里 | 超限时约七成直接失败，不压缩、不重试 | `packages/providers/src/utils/overflow.ts` 的 `OVERFLOW_PATTERNS` | codex 用结构化错误码；最小改法是补上这条文案。更稳的做法：400 且“估算 + 输出上限”已接近窗口时，按溢出处理一次 | +| 2 | 新增内容按“字符数 ÷ 4”估算，中文少算 2.45 倍 | 阈值判断和 `max_tokens` 夹紧同时失效，请求超限 | `estimateTokens()`（agent-core `compaction.ts`）、provider `estimateContextTokens`、CLM `live.estimate` | codex 用 UTF-8 字节数 ÷ 4；或者给 CJK 单独计价 | +| 3 | 阈值只留了很薄的余量，全靠估算准确 | 估算偏差超过约 5.3 万就会超限 | `trigger-policy.ts` 的 `responseHeadroomCeiling()` | deepseek-harness：`min(0.8×窗口, 窗口 − 输出上限 − 6.4万)` | +| 4 | CLM 维护请求 ≈ 整份上下文，排在任务前面，每 3 个回合又来一次 | 每次近满多花约 30 秒；近满时 CLM 比原生摘要还慢 | `auto-compaction.ts` | deepseek-harness 先裁剪工具输出（不调模型）；codex / deepseek-harness 让压缩请求复用前缀缓存 | +| 5 | 单个请求没有总时长上限，只有“300 秒无数据” | 服务端挂住时一直等，日志最长 19.5 分钟 | `http-dispatcher.ts`、`sdk.ts`（`timeoutMs`） | 给单次请求、整轮任务各加一个总时长上限 | +| 6 | 压缩失败后任务照样按满上下文发，下一条消息重来一遍 | 失败被放大：1 维护 + 4 摘要 + 1 满载任务 | `agent-session.ts`（`_compactForRequest`、`AUTO_COMPACTION_FAILURE_LIMIT`） | codex：压缩请求自己超长时删掉最老的一条再试 | +| 7 | 配置窗口 100 万，网关实际 104.8 万 | 值不准（目前方向偏保守，反而多出约 4.8 万容错） | `~/.stepcode/models.json` | 修正时要同时修 #2、#3，否则容错反而变小 | + +--- + +## 9. 更正记录 + +前几轮分析里说错或说过头的地方，已经按代码和真机结果改正： + +| 之前的说法 | 实际情况 | +| --- | --- | +| CLM 要等 2 × 90 秒 | 90 秒计时器只设一次，覆盖整段维护；超时直接结束 | +| 每次尝试最多 5 分钟，合计约 23 分钟 | 300 秒是“没收到任何数据”的空闲超时，单个请求没有总时长上限；23 分钟这个数不成立 | +| 1169.9 秒 ≈ 4 次 × 292 秒的重试链 | 是**单个请求**挂了 19.5 分钟，2 秒后重试得到 502 | +| CLM 最多只能省 5% | 5% 是**下限**，上限是“最大的 32 段”；实测一次省约 12% | +| 阈值只为输出预留 8,192，实际要 128,000，差 12 万 | provider 层有 `clampMaxTokensToContext` 夹紧；真正的问题是阈值和夹紧**用的是同一个偏低的估算** | +| “字符数 ÷ 4”对中文偏高、更保守 | **反了**：中文实测 0.61 token/字，被少算 2.45 倍 | +| 88 万规模 4/4 稳定失败 | 继续跑下去是 13 次里 10 次；而且只在估算偏低时出现，usage 准确就不会 | +| 卡顿是压缩引起的 | 挂起发生在服务端的单个请求上（26.9 万上下文时也出现过）；压缩只是让请求更多、更大，更容易碰上 | + +--- + +## 10. 怎么复跑 + +### 10.1 mock（不走网络，约 10 秒） + +```sh +cd packages/coding-agent +pnpm exec vitest --run test/repro/ +``` + +报告输出到 `/tmp/step-context-pressure-{scenarios,scale,stress}.md`。 + +### 10.2 真机（会发出真实请求，每次约 100 万 token） + +```sh +cd packages/coding-agent/test/repro +python3 real-run.py 60000 # 基线：约 6 秒 +python3 real-run.py 930000 # CLM 接受：维护请求约 97 万，34–62 秒 +python3 real-run.py 930000 --context-projection off # 原生摘要：约 19 秒 +SCALE=1.06 TAIL_CJK=220000 python3 real-run.py 760000 # 真实场景：中文尾巴，多数直接失败 +SCALE=1.06 TAIL_CJK=220000 python3 real-run.py 760000 --context-projection off +python3 real-run.py 880000 --context-projection off # 无可信 usage：约 7–8 成直接失败 +``` + +- 需要先构建好 `apps/cli/dist/main.js`，并配置好 provider； +- 加 `UNIQUE=<任意hex>` 可以强制冷缓存； +- 每次运行都会在 `/tmp/real-compaction/` 生成新会话（约 4MB）和 `last-report.json`，并在 `~/.stepcode/agent/live-context/` 下留一个镜像目录，跑完可以删掉。 + +### 10.3 本目录文件 + +| 文件 | 作用 | +| --- | --- | +| `README.md` | 本文 | +| `context-pressure-scenarios.test.ts` | 15 个压缩场景的请求序列 | +| `context-pressure-scale.test.ts` | 30/60/90 万规模的载荷与本地开销 | +| `context-pressure-stress.test.ts` | 重复稳定性、超时风暴、窗口扫描、延迟注入 | +| `real-run.py` | 真机压测脚本 | + +--- + +## 11. 修复方案与执行计划 + +原则：**能照搬 codex / deepseek-harness 现成做法的就照搬**，不自己发明；每项改动都能通过配置关掉，都有对应的复现命令验证。 + +### 11.1 先回答：阈值改成 85% 行不行？ + +**能改，建议改；但它只是加一层保护，单靠它治不了根。** + +阈值越低，估算可以偏差得越多（按 100 万配置窗口、104.8 万实际上限、12.8 万输出上限计算）： + +| 阈值 | 触发点 | 最坏情况下能容忍的估算偏差 | 实测场景（usage 准确 + 末尾 22 万字中文） | +| --- | --- | --- | --- | +| 90%（现在） | 90 万 | 5.3 万（5.3%） | 估算 86.1 万 < 90 万，不压缩，实际 108 万 → **失败** | +| **85%（提议）** | 85 万 | **7.2 万（7.2%）** | 估算 86.1 万 ≥ 85 万 → 先压缩 → 安全 | +| 80%（deepseek-harness） | 80 万 | 12.2 万（12.2%） | 先压缩 → 安全 | + +- 85% 让容错提高 36%，实测场景会先压缩；代价是少用 5 万 token 的上下文。速度上基本无感，85 万和 90 万的首字延迟差不多。 +- **但 85% 治标不治本**：如果估算刚好在 85 万下方，再来约 **20 万字**中文工具输出，还是会超限。根因是“字符数 ÷ 4”把中文少算了 2.45 倍，必须配合 11.3 的 ①。 +- **为什么不直接照搬 deepseek-harness 的 `窗口 − 输出上限 − 6.4 万`**：小窗口、大输出的模型会被压得太低。例如 `glm-5.1`（20 万窗口 / 12.8 万输出）只剩约 0.65 万；`kimi-k2.6`（25.6 万 / 6.4 万）只剩约 12.6 万，即 49%。deepseek-harness 自己的文档也说，小窗口要逐个模型单独配置。我们保留现有的“输出预留封顶 8,192 + provider 层夹紧”，只调比例，更稳。 +- **今天就能用，不用发版**：在 `~/.stepcode/config.toml` 加上 + + ```toml + [compaction] + triggerRatio = 0.85 + ``` + + CLM 默认跟随同一个阈值，不需要另外配。 + +### 11.2 总体安排：4 个 PR + +| PR | 目标 | 内容 | 参考 | 优先级 | +| --- | --- | --- | --- | --- | +| **PR1** | 不再“突然失败” | ① 中文估算改准；② 默认阈值 85%；③ 认出网关的另一种溢出报错 | codex、deepseek-harness | P0 | +| **PR2** | 不再“挂二三十分钟” | ④ 按事件计时的看门狗 | deepseek-harness | P1 | +| **PR3** | 不再“越满越慢” | ⑤ 先裁剪旧工具输出；⑥ 没有缓存可用时不发整份上下文的 CLM 维护请求 | deepseek-harness、codex | P2 | +| **PR4** | 收尾 | ⑦ 修正窗口配置；⑧ 推动网关统一错误码；⑨ 回馈 pi 上游 | — | P3 | + +### 11.3 PR1：不再“突然失败” + +**① token 估算改成“UTF-8 字节数 ÷ 4”（照搬 codex 的 `approx_token_count`）** + +- 现状：3 份估算代码都是“字符数 ÷ 4”，一个汉字只算 0.25 token，实测是 0.61。 +- 做法：在最底层的 `packages/providers` 加一个公共函数 `estimateTextTokens(text) = ceil(UTF-8 字节数 / 4)`，其他地方都改成调它。ASCII 结果完全不变；汉字（3 字节）算 0.75，略偏保守。 +- 要改的地方： + + | 文件 | 用途 | + | --- | --- | + | `packages/providers/src/utils/estimate.ts` | provider 层压 `max_tokens` 时用（`clampMaxTokensToContext`） | + | `packages/agent-core/src/harness/compaction/compaction.ts` 的 `estimateTokens` | harness 估算 | + | `packages/coding-agent/src/core/compaction/compaction.ts` 的 `estimateTokens` | 会话阈值判断、CLM 都用 | + | `packages/coding-agent/src/core/compaction/live-context/manager.ts` 的 `estimate()` | CLM 系统说明 + 工具定义部分 | + | `packages/coding-agent/src/core/agent-session.ts` 的 `estimateRequestOverheadTokens` | 系统说明 + 工具定义的开销 | + +- 分层：agent-core 和 coding-agent 本来就依赖 providers，不违反依赖方向。 +- 测试：新增单测覆盖 ASCII（与改前一致）、中文（约 0.75/字）、emoji、混合文本；跑现有的 compaction / CLM 相关测试，确认英文用例的数值没变。 + +**② 默认阈值 90% → 85%（在 codex 的 90% 和 deepseek-harness 的 80% 之间）** + +- 改 `packages/coding-agent/src/core/compaction/trigger-policy.ts` 的 `DEFAULT_COMPACTION_TRIGGER_RATIO`；用户自己配的 `triggerRatio`、`modelTriggerRatios` 仍然优先。 +- 小窗口不受影响：64k 窗口仍由“留输出空间”那一项决定（53,248）；200k 窗口从 18 万变成 17 万。 +- 文档：同步更新 `packages/coding-agent/docs/compaction.md`、`context-management.md` 里的 90% / 示例数字，以及 trigger-policy 注释里的表格；在 `CHANGELOG.md` 记一条。 +- 测试：更新阈值相关断言（`compaction-model-trigger-ratios-settings.test.ts`、`agent-session-compaction-trigger.test.ts` 等）。 + +**③ 认出网关的另一种溢出报错** + +- 现状：网关超限时有约七成概率返回 `invalid_request_error: The input you provided is invalid [... code=30003]`，任何规则都认不出来。摘要请求自带的“缩到 70% / 50% / 35% 再试”也因此不生效。 +- 参考做法： + - codex 按网关的**机器可读错误码**判断溢出（`context_length_exceeded` → `ContextWindowExceeded`）； + - deepseek-harness 在适配器这一层把各家措辞统一成 `CONTEXT_WINDOW_EXCEEDED`，上层只认这一个。 +- 做法分两层： + 1. 在 providers 层把“`invalid_request_error` + `code=30003`”**统一识别为可疑溢出**（适配器归一，学 deepseek-harness）； + 2. 再加一道大小门槛：只有“估算输入 + 本次 `max_tokens` ≥ 窗口 × 95%”时才按溢出处理（95% 取自 codex 的 `effective_context_window_percent`）。这样如果小请求真的格式错了，不会被误当成溢出去压缩。 +- 改动位置：`packages/providers/src/utils/overflow.ts`（识别）、`agent-session.ts` 的 `_getOverflowKind` / `_checkCompaction`（门槛判断）、`packages/coding-agent/src/core/compaction/compaction.ts` 第 774 行附近的摘要溢出缩减（同样的门槛）。 +- 识别成溢出之后的流程不改，沿用 pi 原有的“删掉失败回复 → 压缩 → 重试一次”，第二次再溢出就报错结束，不会死循环。 +- 测试：新增“30003 + 大请求 → 压缩重试”“30003 + 小请求 → 照常报错”“摘要请求遇到 30003 → 逐级缩减”。 +- 同时去问网关团队：30003 是否只表示超长？（见 PR4 ⑧） + +**PR1 验收**（真机，命令见第 10 节）： + +| 场景 | 修复前 | 修复后应当 | +| --- | --- | --- | +| `SCALE=1.06 TAIL_CJK=220000 real-run.py 760000`（真实中文场景） | 7 次失败 5 次 | 0 次失败：先压缩再发 | +| 同上加 `--context-projection off` | 4/4 失败 | 0 次失败 | +| `real-run.py 880000 --context-projection off`（没有可信 usage） | 13 次失败 10 次 | 0 次失败：要么先压缩，要么认出溢出后恢复 | +| `real-run.py 60000` | 5.8 秒 | 不变 | + +### 11.4 PR2：不再“挂二三十分钟” + +**④ 按事件计时的看门狗（照搬 deepseek-harness 的 `idleWatchdog`）** + +- 现状：只有 undici 的“300 秒收不到任何字节”这一层，网关的心跳会不断刷新它。日志里有一次只出了 22 个字，然后挂了约 15 分钟。 +- deepseek-harness 的做法（`packages/util/timeout/src/index.ts`，用在 `llm-pi-ai/src/adapter.ts`）： + - **每次等下一个解析出来的事件（文字 / 思考 / 工具参数）时开始计时**，心跳不产生事件，所以不会刷新计时； + - 计时只在“等事件”时走，我们自己处理事件的时间不算进去； + - 超时后**立刻结束这次等待**，不等底层读取返回（注释原话：undici 中止后底层读取可能永远挂着）； + - 默认 300 秒，可配置。 +- 我们的做法：在 `packages/coding-agent/src/core/sdk.ts` 的 `streamFn` 包装层里，对 provider 事件流套同样的看门狗。任务请求、CLM 维护请求、摘要请求都经过这里，改一处全部覆盖。超时报一个可重试的 transient 错误，复用现有重试逻辑。 +- 配置：新增 `retry.provider.streamIdleTimeoutMs`，默认 300,000（与 codex、deepseek-harness 一致），设为 0 表示关闭。 +- 效果：那次 19.5 分钟的挂起，约 9.5 分钟（270 秒出首字 + 300 秒没有新事件）后就会被结束并重试，至少省一半时间；如果想更早发现，可以把超时调到 120–180 秒。正常的长输出一直在出字，不受影响（日志里 13.7 分钟的那次就是这种情况）。 +- 测试：用 faux provider 造一个“出一个字后不再出事件”的流，确认按时超时、触发重试；再造一个“一直慢慢出字”的流，确认不会被误杀。 + +### 11.5 PR3：不再“越满越慢” + +**⑤ 压缩前先裁剪超长的旧工具输出（参考 deepseek-harness 的 `compaction-tool-result-pruner`）** + +- 触发压缩后，先**不调用模型**，把较早的、超长的工具结果截成“开头 + 结尾 + 关键行”。截断逻辑原生摘要里已有现成的 `truncateForSummary`。 +- 截完重新估算，如果已经低于阈值，就不再发 CLM / 摘要请求，等待时间为零。 +- 原始记录不动，只改发给模型的那份视图，和 CLM“草稿”的思路一致。 + +**⑥ 没有缓存可用时，不发整份上下文的 CLM 维护请求** + +- codex 和 deepseek-harness 都遵守同一条原则：**压缩请求的开头必须和正常请求一致，才能用上网关的缓存**。 +- 我们的 CLM 只有走 cached-json 时才满足这条。冷启动、恢复会话、草稿刚改过的时候，维护请求要把约 97.5 万 token 全部重算一遍。 +- 做法：拿不到可复用的前缀，并且已经过了阈值时，**跳过 CLM，直接走原生摘要**。实测 93 万时，CLM 要 34–62 秒，原生摘要只要 19 秒。 +- 可选：CLM 的验收标准从“至少省 5%”改为“压完要低于窗口的 70%”，避免刚压完又碰到阈值。 + +**PR3 验收**：`real-run.py 930000` 从 34–62 秒降到 20 秒左右；mock 场景里，近满时不再出现“冷缓存 + 整份上下文”的维护请求。 + +### 11.6 PR4：收尾 + +- **⑦ 修正窗口配置**（100 万 → 104.8 万）：**必须等 PR1 合入之后再改**。现在配置偏小，反而多出约 4.8 万的容错；如果先改窗口，容错会变小。 +- **⑧ 推动网关统一错误码**：同一种超长有两种报错，应统一成一个固定的机器可读码（类似 `context_length_exceeded`），之后 ③ 就能像 codex 那样只认错误码。 +- **⑨ 回馈 pi 上游**：①、③ 在 pi 里同样存在（估算方式和溢出识别同源），可以提给上游。 + +### 11.7 风险与回滚 + +| 改动 | 风险 | 回滚方式 | +| --- | --- | --- | +| ① 字节估算 | 中文多的会话更早压缩（多算约 23%，方向偏保守） | 代码回退；仅影响非 ASCII 文本 | +| ② 85% | 少用 5 万 token 上下文 | `triggerRatio = 0.9` | +| ③ 30003 识别 | 误判时多做一次压缩（有 95% 门槛和“只恢复一次”两道限制） | 门槛做成配置项，可以调高或关闭 | +| ④ 看门狗 | 模型“静默思考”超过 300 秒会被误杀 | `streamIdleTimeoutMs = 0` 关闭 | +| ⑤ ⑥ | 裁剪后细节变少；近满时少用 CLM | 配置开关 | + +### 11.8 执行顺序与验证 + +1. **今天**：建议用户在 `config.toml` 里设置 `triggerRatio = 0.85`，零成本缓解。 +2. **PR1**（约 1–1.5 天）：先写单测，再做 ① → ② → ③，然后跑第 10 节的真机验收命令。 +3. **PR2**（约 1 天）：④ + 单测，再用真机做一次长请求回归。 +4. **PR3**（约 2–3 天）：⑤ → ⑥，跑 `real-run.py 930000` 对比耗时。 +5. **PR4**：⑦ 在 PR1 之后做；⑧ ⑨ 同步推进。 + +每个 PR 都要跑：`pnpm exec vitest --run test/repro/`、相关单测、`./test.sh`、`npm run check`，并更新 `packages/coding-agent/docs/` 下对应的文档和 `CHANGELOG.md`。 diff --git a/packages/coding-agent/test/repro/context-pressure-scale.test.ts b/packages/coding-agent/test/repro/context-pressure-scale.test.ts new file mode 100644 index 000000000..653db281f --- /dev/null +++ b/packages/coding-agent/test/repro/context-pressure-scale.test.ts @@ -0,0 +1,95 @@ +/** + * Payload-size and local-CPU measurement at production context sizes. + * + * Run: + * cd packages/coding-agent && pnpm exec vitest --run test/repro/context-pressure-scale.test.ts + * + * Writes /tmp/step-context-pressure-scale.md. + */ +import { writeFileSync } from "node:fs"; +import type { AgentMessage } from "@step-harness/agent-core"; +import { fauxAssistantMessage, fauxToolCall } from "@step-harness/providers"; +import { afterAll, describe, expect, it } from "vitest"; +import { estimateTokens, serializeConversation } from "../../src/core/compaction/index.ts"; +import { + digestMessages, + renderLiveContext, + renderLiveContextIndex, +} from "../../src/core/compaction/live-context/document.ts"; +import { LiveContextManager } from "../../src/core/compaction/live-context/manager.ts"; +import { convertToLlm } from "../../src/core/messages.ts"; +import { SessionManager } from "../../src/core/session-manager.ts"; + +const REPORT = "/tmp/step-context-pressure-scale.md"; +const lines: string[] = []; +afterAll(() => writeFileSync(REPORT, lines.join("\n"), "utf8")); + +const chunk = "observed build output: src/parser.ts:42 exit code 1, assertion failed\n".repeat(200); + +function history(tokens: number): AgentMessage[] { + const messages: AgentMessage[] = []; + let total = 0; + let i = 0; + while (total < tokens) { + const assistant = fauxAssistantMessage([fauxToolCall("run_command", { command: "pnpm test" })], { + stopReason: "toolUse", + timestamp: 2 + i * 4, + }); + messages.push( + { role: "user", content: `STEP ${i}: inspect the failing build`, timestamp: 1 + i * 4 }, + assistant, + { + role: "toolResult", + toolCallId: (assistant.content[0] as { id: string }).id, + toolName: "run_command", + content: [{ type: "text", text: chunk }], + isError: false, + timestamp: 3 + i * 4, + }, + ); + total += Math.ceil(chunk.length / 4) + 30; + i++; + } + return messages; +} + +function ms(fn: () => void): number { + const start = performance.now(); + fn(); + return Math.round(performance.now() - start); +} + +describe("context pressure at production size", () => { + it("measures request payloads and local CPU cost", () => { + lines.push("# 载荷与本地 CPU 开销", ""); + for (const target of [300_000, 600_000, 900_000]) { + const messages = history(target); + const llm = convertToLlm(messages); + const summaryText = serializeConversation(llm); + const document = renderLiveContext(messages, 0, "session"); + const index = renderLiveContextIndex(document, "/tmp/LIVE_CONTEXT.md"); + const manager = new LiveContextManager(SessionManager.inMemory()); + const mirrorMs = ms(() => { + // prepare() renders the mirror and writes LIVE_CONTEXT.md + CONTEXT_INDEX.md. + void manager.prepare(messages).catch(() => undefined); + }); + const digestMs = ms(() => digestMessages(messages)); + const cloneMs = ms(() => { + JSON.parse(JSON.stringify({ systemPrompt: "x", messages, tools: [] })); + }); + const allEstimateMs = ms(() => { + for (const message of messages) estimateTokens(message); + }); + lines.push( + `## ${target.toLocaleString("en-US")} token 历史（${messages.length} 条消息）`, + `- 上下文估算（宿主启发式）：${messages.reduce((sum, message) => sum + estimateTokens(message), 0).toLocaleString("en-US")} tokens`, + `- 原生摘要载荷：${Math.ceil(summaryText.length / 4).toLocaleString("en-US")} tokens (${summaryText.length.toLocaleString("en-US")} chars) [工具结果截断到约 2.4k 字符]`, + `- CLM 维护载荷：${Math.ceil((JSON.stringify(llm).length + index.length) / 4).toLocaleString("en-US")} tokens [完整历史 + ${Math.ceil(index.length / 4).toLocaleString("en-US")} token 索引]`, + `- 每次请求写出的 mirror 文档：${Math.ceil(document.text.length / 4).toLocaleString("en-US")} tokens (${document.text.length.toLocaleString("en-US")} chars)`, + `- 本地 CPU：digestMessages=${digestMs}ms, JSON deep clone=${cloneMs}ms, mirror prepare(write)=${mirrorMs}ms, estimate all messages=${allEstimateMs}ms`, + "", + ); + } + expect(lines.length).toBeGreaterThan(3); + }, 180_000); +}); diff --git a/packages/coding-agent/test/repro/context-pressure-scenarios.test.ts b/packages/coding-agent/test/repro/context-pressure-scenarios.test.ts new file mode 100644 index 000000000..14fa5e62d --- /dev/null +++ b/packages/coding-agent/test/repro/context-pressure-scenarios.test.ts @@ -0,0 +1,431 @@ +/** + * Reproduction harness for near-full-context compaction behaviour. + * + * Drives the real AgentSession through every automatic/manual compaction path + * with a faux provider and records the ordered model-request sequence each + * scenario produces. Run: + * + * cd packages/coding-agent && pnpm exec vitest --run test/repro/context-pressure-scenarios.test.ts + * + * The report is written to /tmp/step-context-pressure-scenarios.md. + */ +import { writeFileSync } from "node:fs"; +import type { AgentMessage } from "@step-harness/agent-core"; +import type { Message } from "@step-harness/providers"; +import { type Context, fauxAssistantMessage, fauxToolCall } from "@step-harness/providers"; +import { afterAll, describe, expect, it } from "vitest"; +import { createHarness, type Harness } from "../suite/harness.ts"; + +const REPORT = "/tmp/step-context-pressure-scenarios.md"; +const lines: string[] = []; + +type ClmPolicy = "accept" | "no-edit" | "timeout" | "invalid"; +type SummaryPolicy = "ok" | "error" | "length"; +type TaskPolicy = "ok" | "overflow" | "overflow-then-ok"; + +interface Scenario { + title: string; + window: number; + ratio: number; + mode?: "off" | "lightweight-v1" | "clm-v1"; + autoClm?: boolean; + triggerPolicy?: "v2" | "legacy"; + clm: ClmPolicy; + summary: SummaryPolicy; + task: TaskPolicy; + maxRetries?: number; + prompts?: number; + manualCompact?: boolean; + /** Seed to 45% first, run one ordinary prompt, then grow past the threshold. */ + warmUp?: boolean; + /** Seed the whole history as a single turn so the cut point lands mid-turn. */ + splitTurn?: boolean; +} + +interface Recorded { + kind: "task" | "clm-tool" | "clm-cached-json" | "summary"; + messages: number; + tokens: number; + ms: number; + attempt: number; + note?: string; +} + +const active: Harness[] = []; +afterAll(() => { + writeFileSync(REPORT, lines.join("\n"), "utf8"); + for (const h of active.splice(0)) h.cleanup(); +}); + +function contentText(content: unknown): string { + if (typeof content === "string") return content; + if (!Array.isArray(content)) return ""; + return content + .map((part) => (part && typeof part === "object" && "text" in part ? String(part.text ?? "") : "")) + .join("\n"); +} + +function estimateTokens(context: Context): number { + const overhead = Math.ceil(((context.systemPrompt?.length ?? 0) + JSON.stringify(context.tools ?? []).length) / 4); + let chars = 0; + for (const message of context.messages) { + const content = (message as { content?: unknown }).content; + if (typeof content === "string") chars += content.length; + else if (Array.isArray(content)) + for (const part of content) { + if (!part || typeof part !== "object") continue; + const block = part as { text?: string; thinking?: string; name?: string; arguments?: unknown }; + chars += (block.text ?? block.thinking ?? "").length; + if (block.arguments !== undefined) chars += JSON.stringify(block.arguments).length; + } + } + return overhead + Math.ceil(chars / 4); +} + +/** Realistic history: tiny tool calls, huge tool results (read_file / run_command output). */ +function seedHistory(h: Harness, window: number, ratio: number, singleTurn = false): number { + const messages: AgentMessage[] = [...(h.session.agent.state.messages ?? [])]; + const target = Math.floor(window * ratio); + const chunk = "observed build output: src/parser.ts:42 exit code 1, assertion failed\n".repeat(200); + if (singleTurn && messages.length === 0) { + for (const message of [ + { role: "user", content: "Earlier turn: check the build", timestamp: 0 }, + fauxAssistantMessage("Earlier turn complete."), + { role: "user", content: "ONE HUGE TURN: investigate the build", timestamp: 1 }, + ] satisfies AgentMessage[]) { + messages.push(message); + h.sessionManager.appendMessage(message); + } + } + let i = messages.length; + while (i < 4000) { + const assistant: AgentMessage = { + ...fauxAssistantMessage([fauxToolCall("run_command", { command: "pnpm test" })], { + stopReason: "toolUse", + timestamp: 2 + i * 4, + }), + }; + const result: AgentMessage = { + role: "toolResult", + toolCallId: (assistant as { content: Array<{ id?: string }> }).content[0].id ?? `call-${i}`, + toolName: "run_command", + content: [{ type: "text", text: chunk }], + isError: false, + timestamp: 3 + i * 4, + }; + const fresh: Message[] = [assistant, result] as Message[]; + if (!singleTurn) { + fresh.unshift({ + role: "user", + content: [{ type: "text", text: `STEP ${i}: inspect the failing parser build and report exact errors` }], + timestamp: 1 + i * 4, + }); + } + for (const message of fresh) { + messages.push(message); + h.sessionManager.appendMessage(message); + } + h.session.agent.state.messages = messages; + i++; + const tokens = h.session.getContextUsage()?.tokens ?? 0; + if (tokens >= target) return tokens; + } + return h.session.getContextUsage()?.tokens ?? 0; +} + +function classify(context: Context): Recorded["kind"] { + if ((context.systemPrompt ?? "").includes("context summarization assistant")) return "summary"; + const last = context.messages.at(-1); + const text = contentText(last?.content); + if (text.includes("Reply with only JSON")) return "clm-cached-json"; + if (context.tools?.some((tool) => tool.name === "apply_context_edit")) return "clm-tool"; + return "task"; +} + +function offeredIds(context: Context): string[] { + const prompt = context.messages.map((message) => contentText(message.content)).join("\n"); + return [...prompt.matchAll(/- id=([^ ]+) role=\w+ chars=/g)].map((match) => match[1]); +} + +function sleep(ms: number): Promise { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +async function runScenario(scenario: Scenario): Promise { + const h = await createHarness({ + models: [{ id: "pressure-model", contextWindow: scenario.window, maxTokens: 8192 }], + settings: { + compaction: { + ...(scenario.mode === undefined ? {} : { contextProjection: scenario.mode }), + ...(scenario.triggerPolicy === undefined ? {} : { triggerPolicy: scenario.triggerPolicy }), + enabled: true, + reserveTokens: 2048, + keepRecentTokens: 4000, + autoClm: { + softThresholdRatio: 0.85, + ...(scenario.autoClm === undefined ? {} : { enabled: scenario.autoClm }), + timeoutMs: 150, + maxRequests: 2, + }, + }, + retry: { enabled: true, maxRetries: scenario.maxRetries ?? 1, baseDelayMs: 0 }, + }, + tools: [], + }); + active.push(h); + + const seeded = seedHistory(h, scenario.window, scenario.warmUp ? 0.45 : scenario.ratio, scenario.splitTurn); + const records: Recorded[] = []; + const started = Date.now(); + let taskCalls = 0; + + const respond = async (context: Context) => { + const kind = classify(context); + const record: Recorded = { + kind, + messages: context.messages.length, + tokens: estimateTokens(context), + ms: Date.now() - started, + attempt: 0, + }; + records.push(record); + record.attempt = records.filter((item) => item.kind === kind).length; + + if (kind === "summary") { + if (scenario.summary === "error") + return fauxAssistantMessage("", { stopReason: "error", errorMessage: "Headers Timeout Error" }); + if (scenario.summary === "length") return fauxAssistantMessage("partial", { stopReason: "length" }); + return fauxAssistantMessage("## User Goal\nPreserve the parser failure and remaining work."); + } + + if (kind === "clm-tool" || kind === "clm-cached-json") { + if (scenario.clm === "timeout") { + await sleep(400); + return kind === "clm-cached-json" + ? fauxAssistantMessage(JSON.stringify({ replacements: [] })) + : fauxAssistantMessage("no edit available"); + } + if (scenario.clm === "no-edit") + return kind === "clm-cached-json" + ? fauxAssistantMessage(JSON.stringify({ replacements: [] })) + : fauxAssistantMessage("no safe edit available"); + if (scenario.clm === "invalid") + return kind === "clm-cached-json" + ? fauxAssistantMessage("not json") + : fauxAssistantMessage(fauxToolCall("apply_context_edit", { replacements: [] }), { + stopReason: "toolUse", + }); + const text = "Prior investigation complete: keep the exact parser error and remaining work."; + const ids = offeredIds(context).slice(0, 12); + const replacements = ids.map((id) => ({ id, text })); + if (kind === "clm-cached-json") { + const body = JSON.stringify({ replacements }); + record.note = body.slice(0, 120); + return fauxAssistantMessage(body); + } + return fauxAssistantMessage(fauxToolCall("apply_context_edit", { replacements }), { + stopReason: "toolUse", + }); + } + + taskCalls++; + if (scenario.task === "overflow") { + return fauxAssistantMessage("", { + stopReason: "error", + errorMessage: "prompt is too long: 61234 tokens > 60000 maximum (context_length_exceeded)", + }); + } + if (scenario.task === "overflow-then-ok" && taskCalls === 1) { + return fauxAssistantMessage("", { + stopReason: "error", + errorMessage: "prompt is too long: 61234 tokens > 60000 maximum", + }); + } + return fauxAssistantMessage("done: trivial task completed"); + }; + + const prompts = scenario.prompts ?? 1; + if (scenario.warmUp) { + h.setResponses(Array.from({ length: 10 }, () => respond)); + await h.session.prompt("WARMUP: ordinary request below the threshold"); + seedHistory(h, scenario.window, scenario.ratio); + } + for (let i = 0; i < prompts; i++) { + h.setResponses(Array.from({ length: 40 }, () => respond)); + try { + if (scenario.manualCompact) await h.session.compact(); + await h.session.prompt(`TASK ${i + 1}: say hi`); + } catch (error) { + records.push({ + kind: "task", + messages: 0, + tokens: 0, + ms: Date.now() - started, + attempt: -1, + }); + lines.push(` 运行错误：${error instanceof Error ? error.message : String(error)}`); + } + } + + const seq = records.map((item) => `${item.kind}#${item.attempt}(${item.tokens}tok)`).join(" -> "); + const events = h.events + .filter((event) => ["auto_clm_start", "auto_clm_end", "compaction_start", "compaction_end"].includes(event.type)) + .map((event) => { + if (event.type === "auto_clm_end") + return `auto_clm_end(${event.result.reason},accepted=${event.result.accepted},transport=${event.result.transport ?? "-"})`; + return event.type; + }) + .join(","); + lines.push( + `\n### ${scenario.title}`, + `- window=${scenario.window} 已填充≈${seeded} token (${Math.round(scenario.ratio * 100)}%) mode=${scenario.mode ?? "default"} trigger=${scenario.triggerPolicy ?? "v2"} autoClm=${scenario.autoClm ?? true}`, + `- 请求序列（${records.length}）：${seq}`, + `- 事件：${events || "(无)"}`, + ); + const failures = (h.session as unknown as { _thresholdCompactionFailures: number })._thresholdCompactionFailures; + lines.push(`- 压缩失败计数=${failures}`); +} + +describe("near-full-context compaction scenarios", () => { + it("collects the request sequence for every compaction path", async () => { + lines.push("# 近满上下文压缩复现", ""); + const scenarios: Scenario[] = [ + { + title: "A. CLM 接受（冷前缀，private tool 传输）", + window: 200_000, + ratio: 0.93, + clm: "accept", + summary: "ok", + task: "ok", + }, + { + title: "B. CLM 接受后，第二个 prompt 复用 actor 前缀", + window: 200_000, + ratio: 0.93, + clm: "accept", + summary: "ok", + task: "ok", + prompts: 2, + }, + { + title: "C. CLM 无编辑 -> 回退原生摘要", + window: 200_000, + ratio: 0.93, + clm: "no-edit", + summary: "ok", + task: "ok", + }, + { + title: "D. CLM 返回非法 JSON -> 回退原生摘要", + window: 200_000, + ratio: 0.93, + clm: "invalid", + summary: "ok", + task: "ok", + }, + { + title: "E. CLM 超时（线上 90s）-> 回退原生摘要", + window: 200_000, + ratio: 0.93, + clm: "timeout", + summary: "ok", + task: "ok", + }, + { + title: "F. 仅原生压缩（contextProjection=off）", + window: 200_000, + ratio: 0.93, + mode: "off", + clm: "accept", + summary: "ok", + task: "ok", + }, + { + title: "G. 原生摘要失败（可重试超时），重试 3 次", + window: 200_000, + ratio: 0.93, + mode: "off", + clm: "accept", + summary: "error", + task: "ok", + maxRetries: 3, + prompts: 2, + }, + { + title: "H. 原生摘要撞输出上限（stopReason=length）", + window: 200_000, + ratio: 0.93, + mode: "off", + clm: "accept", + summary: "length", + task: "ok", + }, + { + title: "I. 低于阈值时任务请求被 provider 判溢出", + window: 200_000, + ratio: 0.5, + mode: "off", + clm: "accept", + summary: "ok", + task: "overflow-then-ok", + }, + { + title: "J. 阈值附近的 lightweight-v1 投影", + window: 200_000, + ratio: 0.93, + mode: "lightweight-v1", + clm: "accept", + summary: "ok", + task: "ok", + }, + { + title: "K. legacy 触发策略，CLM 接受", + window: 200_000, + ratio: 0.93, + triggerPolicy: "legacy", + clm: "accept", + summary: "ok", + task: "ok", + }, + { + title: "L. 阈值附近手动 /compact", + window: 200_000, + ratio: 0.93, + clm: "accept", + summary: "ok", + task: "ok", + manualCompact: true, + }, + { + title: "M. 普通回合后上下文越过阈值（复用 cached actor 前缀）", + window: 200_000, + ratio: 0.93, + clm: "accept", + summary: "ok", + task: "ok", + warmUp: true, + }, + { + title: "N. split turn：一个超大回合被拆成历史摘要 + 前缀摘要", + window: 200_000, + ratio: 0.93, + mode: "off", + clm: "accept", + summary: "ok", + task: "ok", + splitTurn: true, + }, + { + title: "O. 关闭自动 CLM -> 阈值处走原生压缩", + window: 200_000, + ratio: 0.93, + autoClm: false, + clm: "accept", + summary: "ok", + task: "ok", + }, + ]; + for (const scenario of scenarios) await runScenario(scenario); + expect(lines.length).toBeGreaterThan(scenarios.length); + }, 180_000); +}); diff --git a/packages/coding-agent/test/repro/context-pressure-stress.test.ts b/packages/coding-agent/test/repro/context-pressure-stress.test.ts new file mode 100644 index 000000000..91dc14bc8 --- /dev/null +++ b/packages/coding-agent/test/repro/context-pressure-stress.test.ts @@ -0,0 +1,252 @@ +/** + * Stability / stress reproduction. + * + * 1. Repeats the core compaction matrix 10x and checks the request sequence is identical. + * 2. Runs the "summary always times out" storm for 4 prompts (retry amplification + pause). + * 3. Sweeps context windows (64k..1M) at the trigger ratio to find where CLM is skipped. + * 4. Repeats with an artificial provider delay to prove no extra requests appear. + * + * Run: + * cd packages/coding-agent && pnpm exec vitest --run test/repro/context-pressure-stress.test.ts + */ +import { writeFileSync } from "node:fs"; +import type { AgentMessage } from "@step-harness/agent-core"; +import { type Context, fauxAssistantMessage, fauxToolCall } from "@step-harness/providers"; +import { afterAll, describe, expect, it } from "vitest"; +import { createHarness, type Harness } from "../suite/harness.ts"; + +const REPORT = "/tmp/step-context-pressure-stress.md"; +const out: string[] = []; +afterAll(() => writeFileSync(REPORT, out.join("\n"), "utf8")); + +const chunk = "observed build output: src/parser.ts:42 exit code 1, assertion failed\n".repeat(200); + +function text(content: unknown): string { + if (typeof content === "string") return content; + if (!Array.isArray(content)) return ""; + return content + .map((part) => (part && typeof part === "object" && "text" in part ? String(part.text ?? "") : "")) + .join("\n"); +} + +function estimate(context: Context): number { + let chars = (context.systemPrompt?.length ?? 0) + JSON.stringify(context.tools ?? []).length; + for (const message of context.messages) { + const content = (message as { content?: unknown }).content; + if (typeof content === "string") chars += content.length; + else if (Array.isArray(content)) + for (const part of content) { + const block = part as { text?: string; thinking?: string; arguments?: unknown }; + if (!block || typeof block !== "object") continue; + chars += (block.text ?? block.thinking ?? "").length; + if (block.arguments !== undefined) chars += JSON.stringify(block.arguments).length; + } + } + return Math.ceil(chars / 4); +} + +function seed(h: Harness, tokens: number): void { + const messages: AgentMessage[] = []; + let total = 0; + let i = 0; + while (total < tokens) { + const assistant = fauxAssistantMessage([fauxToolCall("run_command", { command: "pnpm test" })], { + stopReason: "toolUse", + timestamp: 2 + i * 4, + }); + const result: AgentMessage = { + role: "toolResult", + toolCallId: (assistant.content[0] as { id: string }).id, + toolName: "run_command", + content: [{ type: "text", text: chunk }], + isError: false, + timestamp: 3 + i * 4, + }; + const user: AgentMessage = { role: "user", content: `STEP ${i}: inspect the build`, timestamp: 1 + i * 4 }; + for (const message of [user, assistant, result]) { + messages.push(message); + h.sessionManager.appendMessage(message); + } + total += Math.ceil(chunk.length / 4) + 30; + i++; + } + h.session.agent.state.messages = messages; +} + +type Clm = "accept" | "none" | "timeout"; +type Summary = "ok" | "timeout"; + +interface Options { + window: number; + ratio: number; + mode?: "off" | "clm-v1"; + clm: Clm; + summary: Summary; + maxRetries?: number; + delayMs?: number; + prompts?: number; +} + +interface Result { + seq: string; + kinds: string; + ms: number; + compactions: number; + failures: number; + clmReason?: string; +} + +function sleep(ms: number): Promise { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +async function run(options: Options): Promise { + const h = await createHarness({ + models: [{ id: "stress-model", contextWindow: options.window, maxTokens: 8192 }], + settings: { + compaction: { + ...(options.mode === undefined ? {} : { contextProjection: options.mode }), + enabled: true, + reserveTokens: 2048, + keepRecentTokens: 4000, + autoClm: { timeoutMs: 120, maxRequests: 2 }, + }, + retry: { enabled: true, maxRetries: options.maxRetries ?? 1, baseDelayMs: 0 }, + }, + tools: [], + }); + seed(h, Math.floor(options.window * options.ratio)); + + const kinds: string[] = []; + const started = Date.now(); + const respond = async (context: Context) => { + const isSummary = (context.systemPrompt ?? "").includes("context summarization assistant"); + const last = text(context.messages.at(-1)?.content); + const cached = last.includes("Reply with only JSON"); + const tool = context.tools?.some((entry) => entry.name === "apply_context_edit"); + const kind = isSummary ? "summary" : cached ? "clm-json" : tool ? "clm-tool" : "task"; + kinds.push(`${kind}:${estimate(context)}`); + if (options.delayMs) await sleep(options.delayMs); + if (kind === "summary") { + return options.summary === "timeout" + ? fauxAssistantMessage("", { stopReason: "error", errorMessage: "Headers Timeout Error" }) + : fauxAssistantMessage("## User Goal\nKeep the parser failure."); + } + if (kind === "clm-tool" || kind === "clm-json") { + if (options.clm === "timeout") { + await sleep(300); + return fauxAssistantMessage("no edit"); + } + if (options.clm === "none") return fauxAssistantMessage("no safe edit"); + const transcript = context.messages.map((message) => text(message.content)).join("\n"); + const ids = [...transcript.matchAll(/- id=([^ ]+) role=\w+ chars=/g)].map((match) => match[1]); + const replacements = ids.map((id) => ({ id, text: "Kept: exact parser error." })); + if (kind === "clm-json") return fauxAssistantMessage(JSON.stringify({ replacements })); + return fauxAssistantMessage(fauxToolCall("apply_context_edit", { replacements }), { stopReason: "toolUse" }); + } + return fauxAssistantMessage("done"); + }; + + for (let i = 0; i < (options.prompts ?? 1); i++) { + h.setResponses(Array.from({ length: 60 }, () => respond)); + try { + await h.session.prompt(`TASK ${i + 1}: say hi`); + } catch { + kinds.push("run-error"); + } + } + const result: Result = { + seq: kinds.join(" -> "), + kinds: kinds.map((kind) => kind.split(":")[0]).join(" -> "), + ms: Date.now() - started, + compactions: h.events.filter((event) => event.type === "compaction_start").length, + failures: (h.session as unknown as { _thresholdCompactionFailures: number })._thresholdCompactionFailures, + clmReason: h.eventsOfType("auto_clm_end")[0]?.result.reason, + }; + h.cleanup(); + return result; +} + +describe("compaction stability", () => { + it("repeats the core matrix and reports sequence stability", async () => { + out.push("# 压缩请求序列的稳定性", ""); + const core: Array<[string, Options]> = [ + ["CLM 接受", { window: 200_000, ratio: 0.93, clm: "accept", summary: "ok" }], + ["CLM 无编辑", { window: 200_000, ratio: 0.93, clm: "none", summary: "ok" }], + ["CLM 超时", { window: 200_000, ratio: 0.93, clm: "timeout", summary: "ok" }], + ["原生摘要成功", { window: 200_000, ratio: 0.93, mode: "off", clm: "accept", summary: "ok" }], + [ + "原生摘要失败", + { window: 200_000, ratio: 0.93, mode: "off", clm: "accept", summary: "timeout", maxRetries: 3 }, + ], + ]; + for (const [title, options] of core) { + const runs: Result[] = []; + for (let i = 0; i < 10; i++) runs.push(await run(options)); + const counts = new Map(); + for (const result of runs) counts.set(result.kinds, (counts.get(result.kinds) ?? 0) + 1); + const times = runs.map((result) => result.ms); + out.push(`- ${title}：不同的请求序列=${counts.size}/10，耗时 ${Math.min(...times)}-${Math.max(...times)}ms`); + for (const [sequence, count] of counts) out.push(` 出现 ${count} 次：${sequence}`); + out.push(` 载荷示例：${runs[0].seq}`); + } + expect(out.length).toBeGreaterThan(5); + }, 300_000); + + it("storm: a summary that always times out, four prompts in a row", async () => { + out.push("", "## 超时风暴（原生模式，maxRetries=3）", ""); + const result = await run({ + window: 200_000, + ratio: 0.93, + mode: "off", + clm: "accept", + summary: "timeout", + maxRetries: 3, + prompts: 4, + }); + const attempts = result.seq.split(" -> ").filter((step) => step.startsWith("summary")).length; + out.push( + `- 4 个 prompt 共发出 ${result.seq.split(" -> ").length} 个请求（${attempts} 次摘要尝试）`, + `- compaction_start 次数=${result.compactions}，压缩失败计数=${result.failures}`, + `- 请求序列：${result.seq}`, + ); + expect(attempts).toBeGreaterThan(0); + }, 180_000); + + it("sweeps the window size at the trigger ratio", async () => { + out.push("", "## 触发点附近的窗口/占用扫描", ""); + for (const window of [64_000, 100_000, 200_000, 500_000, 1_000_000]) { + const result = await run({ window, ratio: 0.9, clm: "accept", summary: "ok" }); + const steps = result.seq.split(" -> "); + out.push(`- window=${window}：${steps.length} 个请求，CLM=${result.clmReason ?? "-"}`); + out.push(` ${result.seq}`); + } + for (const ratio of [0.85, 0.9, 0.93, 0.96, 0.99]) { + const result = await run({ window: 200_000, ratio, clm: "accept", summary: "ok" }); + const steps = result.seq.split(" -> "); + out.push(`- 200k @ ${Math.round(ratio * 100)}%：${steps.length} 个请求，CLM=${result.clmReason ?? "-"}`); + out.push(` ${result.seq}`); + } + for (const ratio of [0.92, 0.96, 0.99]) { + const result = await run({ window: 1_000_000, ratio, clm: "accept", summary: "ok" }); + const steps = result.seq.split(" -> "); + out.push(`- 1M @ ${Math.round(ratio * 100)}%：${steps.length} 个请求，CLM=${result.clmReason ?? "-"}`); + out.push(` ${result.seq}`); + } + expect(out.length).toBeGreaterThan(8); + }, 300_000); + + it("adds a provider delay without changing the request sequence", async () => { + out.push("", "## provider 延迟（不产生额外请求）", ""); + const base = await run({ window: 200_000, ratio: 0.93, clm: "none", summary: "ok" }); + const delayed = await run({ window: 200_000, ratio: 0.93, clm: "none", summary: "ok", delayMs: 40 }); + out.push( + `- 无延迟：${base.seq.split(" -> ").length} 个请求，耗时 ${base.ms}ms`, + `- 每个请求 40ms：${delayed.seq.split(" -> ").length} 个请求，耗时 ${delayed.ms}ms`, + `- 请求类型序列一致：${base.kinds === delayed.kinds}`, + ); + // Compare request kinds, not payload sizes: the estimate carries a timestamp digit that + // can differ by one token between runs and says nothing about the sequence. + expect(delayed.kinds).toBe(base.kinds); + }, 180_000); +}); diff --git a/packages/coding-agent/test/repro/real-run.py b/packages/coding-agent/test/repro/real-run.py new file mode 100644 index 000000000..fc3bb5276 --- /dev/null +++ b/packages/coding-agent/test/repro/real-run.py @@ -0,0 +1,219 @@ +#!/usr/bin/env python3 +"""Generate a real large session, run the real StepCode CLI against it, and report timings. + +Usage (from anywhere): + python3 real-run.py [cli flags...] +Env: + SCALE=1.06 scale recorded usage to match the gateway's real token count + TAIL_CJK=220000 append a final tool result of N Chinese characters after the last usage + UNIQUE= make the content unique so the gateway cache is cold +Output: /tmp/real-compaction/session-*.jsonl and /tmp/real-compaction/last-report.json +Requires a built CLI (apps/cli/dist/main.js) and a configured provider; it sends real requests. +""" +import json +import os +import subprocess +import sys +import time +import uuid + +REPO = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../..")) +OUT_DIR = "/tmp/real-compaction" +CLI = os.path.join(REPO, "apps/cli/dist/main.js") + + +def generate(path: str, target_tokens: int, scale: float = 1.0) -> dict: + sid = str(uuid.uuid4()) + now = int(time.time() * 1000) + entries = [ + {"type": "session", "version": 3, "id": sid, "timestamp": "2026-11-10T04:00:00.000Z", "cwd": REPO}, + { + "type": "model_change", + "id": uuid.uuid4().hex[:8], + "parentId": None, + "timestamp": "2026-11-10T04:00:00.100Z", + "provider": "stepcode-anthropic", + "modelId": "deepseek-v4.1-flash-api", + }, + ] + entries.append( + { + "type": "thinking_level_change", + "id": uuid.uuid4().hex[:8], + "parentId": entries[1]["id"], + "timestamp": "2026-11-10T04:00:00.100Z", + "thinkingLevel": "high", + } + ) + parent = entries[-1]["id"] + tag = (os.environ.get("UNIQUE") or "")[:8] + chunk = (f"[{tag}] " if tag else "") + "observed build output: src/parser.ts:42 exit code 1, assertion failed\n" * 200 + tokens = 0 + i = 0 + ts = now + while tokens < target_tokens: + ts += 1000 + u = { + "type": "message", + "id": uuid.uuid4().hex[:8], + "parentId": parent, + "timestamp": "2026-11-10T04:10:00.000Z", + "message": { + "role": "user", + "content": [{"type": "text", "text": f"STEP {i}: inspect the failing parser build and report the exact errors"}], + "timestamp": ts, + }, + } + entries.append(u) + parent = u["id"] + ts += 1000 + call_id = f"call_{i:04d}" + a = { + "type": "message", + "id": uuid.uuid4().hex[:8], + "parentId": parent, + "timestamp": "2026-11-10T04:10:00.000Z", + "message": { + "role": "assistant", + "content": [{"type": "toolCall", "id": call_id, "name": "run_command", "arguments": {"command": "pnpm test"}}], + "api": "anthropic-messages", + "provider": "stepcode-anthropic", + "model": "deepseek-v4.1-flash-api", + "usage": { + "input": 2, + "output": 20, + "cacheRead": int(tokens * scale), + "cacheWrite": 0, + "totalTokens": int(tokens * scale) + 22, + "cost": {"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0, "total": 0}, + }, + "stopReason": "toolUse", + "timestamp": ts, + }, + } + entries.append(a) + parent = a["id"] + ts += 1000 + r = { + "type": "message", + "id": uuid.uuid4().hex[:8], + "parentId": parent, + "timestamp": "2026-11-10T04:10:00.000Z", + "message": { + "role": "toolResult", + "toolCallId": call_id, + "toolName": "run_command", + "content": [{"type": "text", "text": chunk}], + "isError": False, + "timestamp": ts, + }, + } + entries.append(r) + parent = r["id"] + tokens += len(chunk) // 4 + 20 + i += 1 + tail_cjk = int(os.environ.get("TAIL_CJK", "0") or 0) + if tail_cjk > 0: + ts += 1000 + u = {"type": "message", "id": uuid.uuid4().hex[:8], "parentId": parent, "timestamp": "2026-11-10T04:10:00.000Z", + "message": {"role": "user", "content": [{"type": "text", "text": "读取构建日志的中文说明"}], "timestamp": ts}} + entries.append(u); parent = u["id"] + ts += 1000 + a = {"type": "message", "id": uuid.uuid4().hex[:8], "parentId": parent, "timestamp": "2026-11-10T04:10:00.000Z", + "message": {"role": "assistant", "content": [{"type": "toolCall", "id": "call_cjk", "name": "run_command", "arguments": {"command": "cat 说明.md"}}], + "api": "anthropic-messages", "provider": "stepcode-anthropic", "model": "deepseek-v4.1-flash-api", + "usage": {"input": 2, "output": 20, "cacheRead": int(tokens * scale), "cacheWrite": 0, "totalTokens": int(tokens * scale) + 22, + "cost": {"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0, "total": 0}}, + "stopReason": "toolUse", "timestamp": ts}} + entries.append(a); parent = a["id"] + ts += 1000 + sentence = "构建失败：解析器在第四十二行抛出断言错误，退出码为一，需要检查输入格式与边界条件。" + text = (sentence * (tail_cjk // len(sentence) + 1))[:tail_cjk] + r = {"type": "message", "id": uuid.uuid4().hex[:8], "parentId": parent, "timestamp": "2026-11-10T04:10:00.000Z", + "message": {"role": "toolResult", "toolCallId": "call_cjk", "toolName": "run_command", + "content": [{"type": "text", "text": text}], "isError": False, "timestamp": ts}} + entries.append(r); parent = r["id"] + with open(path, "w") as handle: + for entry in entries: + handle.write(json.dumps(entry, ensure_ascii=False) + "\n") + return {"messages": len(entries), "approxTokens": tokens, "bytes": os.path.getsize(path)} + + +def summarize(path: str, since: float) -> dict: + rows = [json.loads(line) for line in open(path) if line.strip()] + out = {"autoClm": [], "provenance": [], "compaction": [], "errors": []} + for entry in rows: + if entry.get("type") == "custom" and entry.get("customType", "").startswith("step-auto-clm"): + data = entry.get("data", {}) + if entry["customType"] == "step-auto-clm": + out["autoClm"].append( + { + "at": entry["timestamp"], + "reason": data.get("reason"), + "accepted": data.get("accepted"), + "requests": data.get("requests"), + "transport": data.get("transport"), + "contextTokens": data.get("contextTokens"), + "before": (data.get("outcome") or {}).get("beforeTokens"), + "after": (data.get("outcome") or {}).get("afterTokens"), + "usage": {k: (data.get("usage") or {}).get(k) for k in ("input", "cacheRead", "output")}, + } + ) + if entry.get("type") == "custom" and entry.get("customType") == "step.usage_provenance": + data = entry.get("data", {}) + out["provenance"].append( + { + "at": entry["timestamp"], + "durationMs": data.get("durationMs"), + "ttftMs": data.get("ttftMs"), + "outcome": data.get("outcome"), + "status": data.get("statusCode"), + } + ) + if entry.get("type") == "compaction": + data = entry.get("data", {}) + out["compaction"].append({"at": entry["timestamp"], "tokensBefore": data.get("tokensBefore")}) + if entry.get("type") == "message" and entry["message"].get("role") == "assistant": + if entry["message"].get("stopReason") == "error": + out["errors"].append( + {"at": entry["timestamp"], "error": str(entry["message"].get("errorMessage"))[:200]} + ) + return out + + +def main() -> None: + target = int(sys.argv[1]) + extra = sys.argv[2:] + stamp = time.strftime("%H%M%S") + os.makedirs(OUT_DIR, exist_ok=True) + path = f"{OUT_DIR}/session-{target}-{stamp}.jsonl" + import os as _os + info = generate(path, target, float(_os.environ.get("SCALE", "1") or 1)) + started = time.time() + started_iso = time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(started)) + proc = subprocess.run( + ["node", CLI, "--session", path, "-p", "Reply with exactly: OK", *extra], + cwd=REPO, + capture_output=True, + text=True, + timeout=1500, + ) + elapsed = time.time() - started + report = { + "target": target, + "flags": extra, + "generated": info, + "elapsedSeconds": round(elapsed, 1), + "startedIso": started_iso, + "stdout": proc.stdout.strip()[-300:], + "stderr": proc.stderr.strip()[-500:], + "exit": proc.returncode, + "session": path, + "details": summarize(path, started), + } + print(json.dumps(report, ensure_ascii=False, indent=1)) + with open(f"{OUT_DIR}/last-report.json", "w") as handle: + json.dump(report, handle, ensure_ascii=False, indent=1) + + +main()