From d54f86e856fdfc24312bb3594d371152858bd82e Mon Sep 17 00:00:00 2001 From: probe Date: Mon, 5 Oct 2026 11:29:33 +0900 Subject: [PATCH 1/4] fix(ai): retry incomplete Codex tool calls once --- ...codex-timeout-incomplete-toolcall-retry.md | 3 + .../src/providers/openai-codex-responses.ts | 44 ++++++- .../openai-codex-truncated-toolcall.test.ts | 110 ++++++++++++++++++ 3 files changed, 153 insertions(+), 4 deletions(-) create mode 100644 packages/ai/changelog.d/codex-timeout-incomplete-toolcall-retry.md diff --git a/packages/ai/changelog.d/codex-timeout-incomplete-toolcall-retry.md b/packages/ai/changelog.d/codex-timeout-incomplete-toolcall-retry.md new file mode 100644 index 00000000000..80bb2de1344 --- /dev/null +++ b/packages/ai/changelog.d/codex-timeout-incomplete-toolcall-retry.md @@ -0,0 +1,3 @@ +### Fixed + +- Retry Codex Responses streams once when a request timeout leaves only incomplete tool-call output. diff --git a/packages/ai/src/providers/openai-codex-responses.ts b/packages/ai/src/providers/openai-codex-responses.ts index 9c722d26ed6..793ecfc609f 100644 --- a/packages/ai/src/providers/openai-codex-responses.ts +++ b/packages/ai/src/providers/openai-codex-responses.ts @@ -489,6 +489,7 @@ interface CodexStreamRuntime { partialToolCallReplayAttempted: boolean; bufferedEvents: AssistantMessageEvent[]; eventsReleased: boolean; + incompleteToolCallRetryAttempted: boolean; toolChoiceFallbackAttempted: boolean; /** * Stale-anchor recovery is one-shot. Once the anchor is cleared the replay no @@ -1258,6 +1259,7 @@ function createCodexStreamRuntime(initial: { partialToolCallReplayAttempted: false, bufferedEvents: [], eventsReleased: false, + incompleteToolCallRetryAttempted: false, toolChoiceFallbackAttempted: initial.toolChoiceFallbackApplied === true, previousResponseRecoveryAttempted: false, sentPreviousResponseId: initial.sentPreviousResponseId === true, @@ -2349,12 +2351,44 @@ async function recoverCodexStreamError( if (await tryReplayWebsocketFailureOverSse(context, runtime, error)) { return true; } + if (isCodexIncompleteToolCallTimeoutRetryable(context, runtime, error)) { + runtime.incompleteToolCallRetryAttempted = true; + const retried = await tryRetryCodexProviderError(context, runtime, error, true); + if (retried) return true; + } if (await tryRetryCodexProviderError(context, runtime, error)) { return true; } return false; } +function isCodexIncompleteToolCallTimeoutRetryable( + context: CodexStreamProcessingContext, + runtime: CodexStreamRuntime, + error: unknown, +): boolean { + if (runtime.incompleteToolCallRetryAttempted || !isCodexTransientStreamClose(error)) return false; + const providerCode = + error instanceof CodexProviderStreamError + ? error.code?.toLowerCase() + : (error as { providerCode?: string }).providerCode?.toLowerCase(); + if (providerCode !== "request_timeout") return false; + const toolCalls = context.output.content.filter((block): block is ToolCall => block.type === "toolCall"); + return ( + toolCalls.length > 0 && + runtime.finalizedToolCallIds.size === 0 && + !runtime.toolArgumentCorrelationFailed && + context.output.content.every( + block => + block.type === "thinking" || + (block.type === "toolCall" && + !runtime.finalizedToolCallIds.has(block.id) && + (block as ToolCall & { argumentsComplete?: boolean }).argumentsComplete !== true) || + (block.type === "text" && block.text === ""), + ) + ); +} + async function tryRetryWithoutForcedToolChoice( context: CodexStreamProcessingContext, runtime: CodexStreamRuntime, @@ -2634,6 +2668,7 @@ async function tryRetryCodexProviderError( context: CodexStreamProcessingContext, runtime: CodexStreamRuntime, error: unknown, + allowIncompleteToolCallOutput = false, ): Promise { const hasUnfinalizedToolCall = context.output.content.some( block => block.type === "toolCall" && !runtime.finalizedToolCallIds.has(block.id), @@ -2644,9 +2679,10 @@ async function tryRetryCodexProviderError( hasUnfinalizedToolCall && !runtime.partialToolCallReplayAttempted && isCodexPartialOutputReplayEligible(context.output, runtime); + const canRetryWithOutput = canReplayPartialToolCall || allowIncompleteToolCallOutput; if ( - (!isRetryableCodexProviderError(error) && !canReplayPartialToolCall) || - (context.output.content.length > 0 && !canReplayPartialToolCall) || + (!isRetryableCodexProviderError(error) && !canRetryWithOutput) || + (context.output.content.length > 0 && !canRetryWithOutput) || runtime.providerRetryAttempt >= resolveRetryBudget(context.options?.streamMaxRetries, CODEX_MAX_RETRIES) || context.options?.signal?.aborted || context.options?.fallbackManaged || @@ -2656,7 +2692,7 @@ async function tryRetryCodexProviderError( } runtime.providerRetryAttempt += 1; - if (context.output.content.length > 0 && canReplayPartialToolCall) runtime.partialToolCallReplayAttempted = true; + if (context.output.content.length > 0 && canRetryWithOutput) runtime.partialToolCallReplayAttempted = true; const websocketState = context.requestContext.websocketState; if (runtime.transport === "websocket" && websocketState) { resetCodexWebSocketAppendState(websocketState); @@ -2677,7 +2713,7 @@ async function tryRetryCodexProviderError( runtime.nativeOutputItemOutputIndexes.length = 0; runtime.finalizedToolCallIds.clear(); runtime.toolArgumentCorrelationFailed = false; - if (canReplayPartialToolCall) discardCodexEvents(runtime, true); + if (canRetryWithOutput) discardCodexEvents(runtime, true); resetOutputState(context.output); context.firstTokenTime = undefined; await scheduler.wait(CODEX_RETRY_DELAY_MS * runtime.providerRetryAttempt, { diff --git a/packages/ai/test/openai-codex-truncated-toolcall.test.ts b/packages/ai/test/openai-codex-truncated-toolcall.test.ts index 00831569c24..13839a24d4f 100644 --- a/packages/ai/test/openai-codex-truncated-toolcall.test.ts +++ b/packages/ai/test/openai-codex-truncated-toolcall.test.ts @@ -52,6 +52,16 @@ function mockFetchOnce(body: string): void { global.fetch = Object.assign(fn, { preconnect: originalFetch.preconnect }); } +function mockFetchSequence(bodies: string[]): { requests: () => number } { + let requests = 0; + const fn = async (): Promise => { + const body = bodies[Math.min(requests++, bodies.length - 1)]; + return new Response(body, { status: 200, headers: { "content-type": "text/event-stream" } }); + }; + global.fetch = Object.assign(fn, { preconnect: originalFetch.preconnect }); + return { requests: () => requests }; +} + const USAGE = { input_tokens: 5, output_tokens: 3, total_tokens: 8, input_tokens_details: { cached_tokens: 0 } }; describe("openai-codex: truncated tool-call detection", () => { @@ -171,4 +181,104 @@ describe("openai-codex: truncated tool-call detection", () => { tools = result.content.filter((b): b is ToolCall => b.type === "toolCall"); expect(tools[0].incompleteArguments).toBeFalsy(); }); + + it("retries a timeout after only an incomplete function call", async () => { + setAgentDir(TempDir.createSync("@pi-codex-trunc-").path()); + const timeout = sse([ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "read_file", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_1", output_index: 0, delta: '{"path":"' }, + { + type: "error", + code: "request_timeout", + message: "stream disconnected before completion: stream closed before response.completed", + }, + ]); + const success = sse([ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "function_call", id: "fc_2", call_id: "call_2", name: "read_file", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_2", output_index: 0, delta: '{"path":"a.ts"}' }, + { + type: "response.function_call_arguments.done", + item_id: "fc_2", + output_index: 0, + arguments: '{"path":"a.ts"}', + }, + { + type: "response.output_item.done", + output_index: 0, + item: { + type: "function_call", + id: "fc_2", + call_id: "call_2", + name: "read_file", + arguments: '{"path":"a.ts"}', + }, + }, + { type: "response.completed", response: { status: "completed", usage: USAGE } }, + ]); + const fetches = mockFetchSequence([timeout, success]); + + const result = await streamOpenAICodexResponses(model(), context(), { apiKey: token() }).result(); + expect(fetches.requests()).toBe(2); + expect(result.stopReason).toBe("toolUse"); + expect(result.content.filter((block): block is ToolCall => block.type === "toolCall")).toHaveLength(1); + }); + + it("does not retry a timeout when non-empty text was emitted", async () => { + setAgentDir(TempDir.createSync("@pi-codex-trunc-").path()); + const fetches = mockFetchSequence([ + sse([ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "message", id: "msg_1", content: [] }, + }, + { + type: "response.content_part.added", + item_id: "msg_1", + output_index: 0, + part: { type: "output_text", text: "hello" }, + }, + { type: "response.output_text.delta", item_id: "msg_1", output_index: 0, delta: "hello" }, + { + type: "error", + code: "request_timeout", + message: "stream disconnected before completion: stream closed before response.completed", + }, + ]), + ]); + + const result = await streamOpenAICodexResponses(model(), context(), { apiKey: token() }).result(); + expect(fetches.requests()).toBe(1); + expect(result.stopReason).toBe("error"); + }); + + it("does not retry a second consecutive timeout", async () => { + setAgentDir(TempDir.createSync("@pi-codex-trunc-").path()); + const timeout = sse([ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "read_file", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_1", output_index: 0, delta: '{"path":"' }, + { + type: "error", + code: "request_timeout", + message: "stream disconnected before completion: stream closed before response.completed", + }, + ]); + const fetches = mockFetchSequence([timeout, timeout]); + + const result = await streamOpenAICodexResponses(model(), context(), { apiKey: token() }).result(); + expect(fetches.requests()).toBe(2); + expect(result.stopReason).toBe("error"); + }); }); From 9035173b24ea381ad8f06ae0fe139c27b9080f23 Mon Sep 17 00:00:00 2001 From: probe Date: Mon, 5 Oct 2026 17:28:31 +0800 Subject: [PATCH 2/4] fix(ai): guard incomplete Codex call replay --- .../src/providers/openai-codex-responses.ts | 13 ++- packages/ai/test/openai-codex-stream.test.ts | 78 ++++++++++++++++ .../openai-codex-truncated-toolcall.test.ts | 92 ++++++++++++++++++- 3 files changed, 180 insertions(+), 3 deletions(-) diff --git a/packages/ai/src/providers/openai-codex-responses.ts b/packages/ai/src/providers/openai-codex-responses.ts index 793ecfc609f..603c72d29db 100644 --- a/packages/ai/src/providers/openai-codex-responses.ts +++ b/packages/ai/src/providers/openai-codex-responses.ts @@ -2367,7 +2367,14 @@ function isCodexIncompleteToolCallTimeoutRetryable( runtime: CodexStreamRuntime, error: unknown, ): boolean { - if (runtime.incompleteToolCallRetryAttempted || !isCodexTransientStreamClose(error)) return false; + if ( + runtime.incompleteToolCallRetryAttempted || + runtime.partialToolCallReplayAttempted || + runtime.eventsReleased || + !isCodexTransientStreamClose(error) + ) { + return false; + } const providerCode = error instanceof CodexProviderStreamError ? error.code?.toLowerCase() @@ -2679,7 +2686,9 @@ async function tryRetryCodexProviderError( hasUnfinalizedToolCall && !runtime.partialToolCallReplayAttempted && isCodexPartialOutputReplayEligible(context.output, runtime); - const canRetryWithOutput = canReplayPartialToolCall || allowIncompleteToolCallOutput; + const canRetryWithOutput = + canReplayPartialToolCall || + (allowIncompleteToolCallOutput && !runtime.partialToolCallReplayAttempted && !runtime.eventsReleased); if ( (!isRetryableCodexProviderError(error) && !canRetryWithOutput) || (context.output.content.length > 0 && !canRetryWithOutput) || diff --git a/packages/ai/test/openai-codex-stream.test.ts b/packages/ai/test/openai-codex-stream.test.ts index bab8ab83f7c..4c92ff7b5d9 100644 --- a/packages/ai/test/openai-codex-stream.test.ts +++ b/packages/ai/test/openai-codex-stream.test.ts @@ -789,6 +789,84 @@ describe("openai-codex streaming", () => { ]); }); + it("does not replay a released partial call after a timeout retry", async () => { + const firstPartial = [ + { + type: "response.output_item.added", + item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "old_tool", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"old":' }, + ]; + const secondTimeout = createCodexErrorSse([ + { + type: "response.output_item.added", + item: { type: "function_call", id: "fc_2", call_id: "call_2", name: "old_tool", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_2", delta: '{"old":' }, + { type: "error", code: "request_timeout", message: "stream closed before response.completed" }, + ]); + let requestCount = 0; + global.fetch = vi.fn(async (_input, _init) => { + requestCount += 1; + if (requestCount === 1) return createSocketCloseCodexSse(undefined, firstPartial); + return new Response(secondTimeout, { status: 200, headers: { "content-type": "text/event-stream" } }); + }) as unknown as typeof fetch; + vi.spyOn(scheduler, "wait").mockResolvedValue(undefined); + + const stream = streamOpenAICodexResponses( + { ...createCodexTestModel("https://chatgpt.com/backend-api"), preferWebsockets: false }, + createCodexTestContext(), + { apiKey: createCodexTestToken() }, + ); + const events: AssistantMessageEvent[] = []; + for await (const event of stream) events.push(event); + const result = await stream.result(); + + expect(requestCount).toBe(2); + expect(result.stopReason).toBe("error"); + expect(events.filter(event => event.type === "toolcall_start")).toHaveLength(1); + }); + + it("does not replay a partial call after timeout retry consumes the replay", async () => { + const firstTimeout = createCodexErrorSse([ + { + type: "response.output_item.added", + item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "old_tool", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"old":' }, + { type: "error", code: "request_timeout", message: "stream closed before response.completed" }, + ]); + const secondPartial = [ + { + type: "response.output_item.added", + item: { type: "function_call", id: "fc_2", call_id: "call_2", name: "old_tool", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_2", delta: '{"old":' }, + ]; + let requestCount = 0; + global.fetch = vi.fn(async (_input, _init) => { + requestCount += 1; + if (requestCount === 1) { + return new Response(firstTimeout, { status: 200, headers: { "content-type": "text/event-stream" } }); + } + return createSocketCloseCodexSse(undefined, secondPartial); + }) as unknown as typeof fetch; + vi.spyOn(scheduler, "wait").mockResolvedValue(undefined); + + const stream = streamOpenAICodexResponses( + { ...createCodexTestModel("https://chatgpt.com/backend-api"), preferWebsockets: false }, + createCodexTestContext(), + { apiKey: createCodexTestToken() }, + ); + const events: AssistantMessageEvent[] = []; + for await (const event of stream) events.push(event); + const result = await stream.result(); + + expect(requestCount).toBe(2); + expect(result.stopReason).toBe("error"); + expect(events.filter(event => event.type === "toolcall_start")).toHaveLength(1); + }); + it("does not replay an ECONNRESET socket close after visible text", async () => { const partial = [ { diff --git a/packages/ai/test/openai-codex-truncated-toolcall.test.ts b/packages/ai/test/openai-codex-truncated-toolcall.test.ts index 13839a24d4f..ca65dcad5ef 100644 --- a/packages/ai/test/openai-codex-truncated-toolcall.test.ts +++ b/packages/ai/test/openai-codex-truncated-toolcall.test.ts @@ -228,7 +228,11 @@ describe("openai-codex: truncated tool-call detection", () => { const result = await streamOpenAICodexResponses(model(), context(), { apiKey: token() }).result(); expect(fetches.requests()).toBe(2); expect(result.stopReason).toBe("toolUse"); - expect(result.content.filter((block): block is ToolCall => block.type === "toolCall")).toHaveLength(1); + const tools = result.content.filter((block): block is ToolCall => block.type === "toolCall"); + expect(tools).toHaveLength(1); + expect(tools[0].id).toBe("call_2|fc_2"); + expect(tools[0].arguments).toEqual({ path: "a.ts" }); + expect(tools[0].incompleteArguments).toBeFalsy(); }); it("does not retry a timeout when non-empty text was emitted", async () => { @@ -281,4 +285,90 @@ describe("openai-codex: truncated tool-call detection", () => { expect(fetches.requests()).toBe(2); expect(result.stopReason).toBe("error"); }); + + it("does not retry an incomplete timeout when retries are exhausted", async () => { + setAgentDir(TempDir.createSync("@pi-codex-trunc-").path()); + const fetches = mockFetchSequence([ + sse([ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "read_file", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_1", output_index: 0, delta: '{"path":"' }, + { type: "error", code: "request_timeout", message: "stream closed before response.completed" }, + ]), + ]); + + const result = await streamOpenAICodexResponses(model(), context(), { + apiKey: token(), + streamMaxRetries: 0, + }).result(); + + expect(fetches.requests()).toBe(1); + expect(result.stopReason).toBe("error"); + }); + + it("does not retry a finalized tool call followed by timeout", async () => { + setAgentDir(TempDir.createSync("@pi-codex-trunc-").path()); + const fetches = mockFetchSequence([ + sse([ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "read_file", arguments: "" }, + }, + { + type: "response.function_call_arguments.delta", + item_id: "fc_1", + output_index: 0, + delta: '{"path":"a.ts"}', + }, + { + type: "response.output_item.done", + output_index: 0, + item: { + type: "function_call", + id: "fc_1", + call_id: "call_1", + name: "read_file", + arguments: '{"path":"a.ts"}', + }, + }, + { type: "error", code: "request_timeout", message: "stream closed before response.completed" }, + ]), + ]); + + const result = await streamOpenAICodexResponses(model(), context(), { apiKey: token() }).result(); + + expect(fetches.requests()).toBe(1); + expect(result.stopReason).toBe("toolUse"); + }); + + it("does not retry an incomplete timeout after abort", async () => { + setAgentDir(TempDir.createSync("@pi-codex-trunc-").path()); + const abort = new AbortController(); + const fetches = mockFetchSequence([ + sse([ + { + type: "response.output_item.added", + output_index: 0, + item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "read_file", arguments: "" }, + }, + { type: "response.function_call_arguments.delta", item_id: "fc_1", output_index: 0, delta: '{"path":"' }, + { type: "error", code: "request_timeout", message: "stream closed before response.completed" }, + ]), + ]); + + const result = await streamOpenAICodexResponses(model(), context(), { + apiKey: token(), + signal: abort.signal, + onSseEvent: event => { + if (event.data.includes('"request_timeout"')) abort.abort(); + }, + }).result(); + + expect(fetches.requests()).toBe(1); + expect(result.stopReason).toBe("aborted"); + }); }); From 713c4b99eaebe59bcff328ca88b351e1a1e6317c Mon Sep 17 00:00:00 2001 From: probe Date: Mon, 5 Oct 2026 17:50:31 +0800 Subject: [PATCH 3/4] fix(repo): generate docs index before workspace typechecks --- packages/ai/package.json | 1 + packages/coding-agent/package.json | 1 + packages/natives/package.json | 1 + packages/orchestration-token-benchmark/package.json | 1 + packages/typescript-edit-benchmark/package.json | 1 + 5 files changed, 5 insertions(+) diff --git a/packages/ai/package.json b/packages/ai/package.json index dfd67c16c22..eb3bcbcdbb3 100644 --- a/packages/ai/package.json +++ b/packages/ai/package.json @@ -30,6 +30,7 @@ }, "scripts": { "check": "biome check . && bun run check:types", + "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test", diff --git a/packages/coding-agent/package.json b/packages/coding-agent/package.json index 442351a5c6b..a31c84a459d 100644 --- a/packages/coding-agent/package.json +++ b/packages/coding-agent/package.json @@ -32,6 +32,7 @@ "build": "bun run verify:markit-vendor && bun scripts/build-binary.ts", "check": "bun run verify:markit-vendor && biome check . && bun run check:types", "check:runtime": "bun run generate-hotkeys-docs --check && bun run verify:sdk-canonicalization", + "precheck:types": "bun run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "check:autorouting-map": "bun scripts/check-autorouting-tier-map.ts", "lint": "biome lint .", diff --git a/packages/natives/package.json b/packages/natives/package.json index 51f613acb33..851b5703332 100644 --- a/packages/natives/package.json +++ b/packages/natives/package.json @@ -31,6 +31,7 @@ "scripts": { "build": "bun scripts/build-native.ts", "check": "biome check . && bun run check:types", + "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test", diff --git a/packages/orchestration-token-benchmark/package.json b/packages/orchestration-token-benchmark/package.json index c10fc1c1aae..5c237a13533 100644 --- a/packages/orchestration-token-benchmark/package.json +++ b/packages/orchestration-token-benchmark/package.json @@ -14,6 +14,7 @@ "main": "./src/index.ts", "scripts": { "check": "biome check . && bun run check:types", + "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test", diff --git a/packages/typescript-edit-benchmark/package.json b/packages/typescript-edit-benchmark/package.json index 3e46d5b4465..cf05d6ac506 100644 --- a/packages/typescript-edit-benchmark/package.json +++ b/packages/typescript-edit-benchmark/package.json @@ -17,6 +17,7 @@ }, "scripts": { "check": "biome check . && bun run check:types", + "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test", From 433b01197f45d99039c5ced08b267a61def20b11 Mon Sep 17 00:00:00 2001 From: probe Date: Mon, 5 Oct 2026 18:00:19 +0800 Subject: [PATCH 4/4] Revert "fix(repo): generate docs index before workspace typechecks" This reverts commit 713c4b99eaebe59bcff328ca88b351e1a1e6317c. --- packages/ai/package.json | 1 - packages/coding-agent/package.json | 1 - packages/natives/package.json | 1 - packages/orchestration-token-benchmark/package.json | 1 - packages/typescript-edit-benchmark/package.json | 1 - 5 files changed, 5 deletions(-) diff --git a/packages/ai/package.json b/packages/ai/package.json index eb3bcbcdbb3..dfd67c16c22 100644 --- a/packages/ai/package.json +++ b/packages/ai/package.json @@ -30,7 +30,6 @@ }, "scripts": { "check": "biome check . && bun run check:types", - "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test", diff --git a/packages/coding-agent/package.json b/packages/coding-agent/package.json index a31c84a459d..442351a5c6b 100644 --- a/packages/coding-agent/package.json +++ b/packages/coding-agent/package.json @@ -32,7 +32,6 @@ "build": "bun run verify:markit-vendor && bun scripts/build-binary.ts", "check": "bun run verify:markit-vendor && biome check . && bun run check:types", "check:runtime": "bun run generate-hotkeys-docs --check && bun run verify:sdk-canonicalization", - "precheck:types": "bun run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "check:autorouting-map": "bun scripts/check-autorouting-tier-map.ts", "lint": "biome lint .", diff --git a/packages/natives/package.json b/packages/natives/package.json index 851b5703332..51f613acb33 100644 --- a/packages/natives/package.json +++ b/packages/natives/package.json @@ -31,7 +31,6 @@ "scripts": { "build": "bun scripts/build-native.ts", "check": "biome check . && bun run check:types", - "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test", diff --git a/packages/orchestration-token-benchmark/package.json b/packages/orchestration-token-benchmark/package.json index 5c237a13533..c10fc1c1aae 100644 --- a/packages/orchestration-token-benchmark/package.json +++ b/packages/orchestration-token-benchmark/package.json @@ -14,7 +14,6 @@ "main": "./src/index.ts", "scripts": { "check": "biome check . && bun run check:types", - "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test", diff --git a/packages/typescript-edit-benchmark/package.json b/packages/typescript-edit-benchmark/package.json index cf05d6ac506..3e46d5b4465 100644 --- a/packages/typescript-edit-benchmark/package.json +++ b/packages/typescript-edit-benchmark/package.json @@ -17,7 +17,6 @@ }, "scripts": { "check": "biome check . && bun run check:types", - "precheck:types": "bun --cwd=../coding-agent run generate-docs-index", "check:types": "tsc -p tsconfig.json --noEmit", "lint": "biome lint .", "test": "bun test",