Fixed Codex compaction crash on quota exceed

Summary

Closed, Completed

Understand
Reviewed issue and related code files.
Understand
Understand
Traced error flow in compaction module.
Understand
Build
Implemented error handling and reporting fix.
Build
Edit
Updated event types, UI, docs, and changelog.
Edit
Verify
Confirmed fix resolves crash and improves error visibility.
Verify

Analyze GitHub issue(s): https://github.com/badlogic/pi-mono/issues/792

For each issue:

Read the issue in full, including all comments and linked issues/PRs.
For bugs:
- Ignore any root cause analysis in the issue (likely wrong)
- Read all related code files in full (no truncation)
- Trace the code path and identify the actual root cause
- Propose a fix
For feature requests:
- Read all related code files in full (no truncation)
- Propose the most concise implementation approach
- List affected files and changes needed

Do NOT implement unless explicitly asked. Analyze and propose only.

This is a bug report about a crash during Codex compaction when the user runs out of quota. The error shows:

First error: context_length_exceeded from Codex
Then during auto-compaction, the summarization failed because the user hit their ChatGPT usage limit

The issue is in agent-session.js around line 1229, in the _runAutoCompaction function. The error handling seems to be throwing when summarization fails due to quota limits.

Let me read the relevant code files to understand the actual code path and root cause.

Let me read the relevant code files to understand the issue:

Readagent-session.ts

Now I have a clear picture of the issue. Let me trace the code path:

User is running with gpt-5.2-codex model
Context exceeds the model's limit, Codex returns context_length_exceeded error
In _handleAgentEvent, on agent_end, _checkCompaction is called with the last assistant message
_checkCompaction detects a context overflow via isContextOverflow() and calls _runAutoCompaction("overflow", true)
Inside _runAutoCompaction, compact() is called to summarize the context
The compact() function internally uses the current model to generate a summary
For Codex, this apparently uses ChatGPT as the summarizer
User has hit their ChatGPT usage limit (plus plan quota), causing the summarization to fail
The error is caught in the catch block around line 1550:

typescript

} catch (error) {    this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
    if (reason === "overflow") {        throw new Error(            `Context overflow: ${error instanceof Error ? error.message : "compaction failed"}. Your input may be too large for the context window.`,        );    }}

} catch (error) {    this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
    if (reason === "overflow") {        throw new Error(            `Context overflow: ${error instanceof Error ? error.message : "compaction failed"}. Your input may be too large for the context window.`,        );    }}

The problem is that when auto-compaction is triggered by overflow and the compaction itself fails (e.g., due to quota limits), the error is re-thrown and crashes the application. The error message is also confusing because it says "Your input may be too large for the context window" when the real issue is quota exhaustion.

The actual root cause is that the _runAutoCompaction method throws an error when compaction fails during overflow handling, and this error bubbles up and crashes the application since it's not caught anywhere.

Let me check if there's any error handling in the parent context.

Looking at where _checkCompaction is called in _handleAgentEvent, the async event handler is subscribed directly to the agent. If _checkCompaction throws during overflow recovery, that error propagates up without being caught. I should also examine what errors the compact() function itself might throw to understand the full failure chain.

Let me also check the compaction module to understand what errors can be thrown:

Readindex.ts

Readcompaction.ts

Now I have a complete picture:1. The compact() function calls generateSummary() or generateTurnPrefixSummary() 2. These functions use completeSimple() to call the LLM3. If the LLM returns stopReason === "error", the function throws: throw new Error(Summarization failed: ${response.errorMessage || "Unknown error"});4. In _runAutoCompaction, this error is caught, and if the reason is "overflow", it's re-thrown with a confusing message

The issue is that when auto-compaction is triggered due to overflow and the summarization fails (for ANY reason, including quota limits), the error is re-thrown and crashes the entire application.

Root Cause: The _runAutoCompaction method in agent-session.ts throws an unhandled error when compaction fails during overflow handling. The error message is misleading because it says "Your input may be too large for the context window" when the actual issue could be something entirely different (like quota exhaustion).

Proposed Fix: Instead of crashing when auto-compaction fails during overflow:

Emit an error event that the UI can display
Let the user know what happened so they can retry manually or switch models
Don't crash the application

Looking at the code:

The crash happens at line 1550-1552 in _runAutoCompaction:

typescript

throw new Error(    `Context overflow: ${error instanceof Error ? error.message : "compaction failed"}. Your input may be too large for the context window.`,);

throw new Error(    `Context overflow: ${error instanceof Error ? error.message : "compaction failed"}. Your input may be too large for the context window.`,);

The fix should:

NOT throw from inside an event handler (which causes the crash)2. Emit a proper error event or return gracefully
Let the UI display the actual error message (e.g., quota exceeded) so the user knows what happened

Let me check how errors are handled elsewhere in the codebase for consistency.

Now I have a complete picture of the issue. Let me summarize:

Analysis: GitHub Issue #792

Bug Summary

The application crashes during Codex compaction when the user runs out of ChatGPT quota.

Error Chain

User runs pi with gpt-5.2-codex model
Context exceeds the model's limit → Codex returns context_length_exceeded error
_checkCompaction() detects the overflow and calls _runAutoCompaction("overflow", true)
Compaction tries to summarize context using completeSimple() (which uses the current model)
The summarization call fails because the user hit their ChatGPT usage limit
Error is caught in _runAutoCompaction catch block → re-thrown with misleading message → application crashes

Root Cause

Location: packages/coding-agent/src/core/agent-session.ts, lines 1546-1552

typescript

} catch (error) {    this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
    if (reason === "overflow") {        throw new Error(            `Context overflow: ${error instanceof Error ? error.message : "compaction failed"}. Your input may be too large for the context window.`,        );    }}

} catch (error) {    this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
    if (reason === "overflow") {        throw new Error(            `Context overflow: ${error instanceof Error ? error.message : "compaction failed"}. Your input may be too large for the context window.`,        );    }}

Problems:

Throwing from inside an async event handler (_handleAgentEvent) causes an unhandled rejection that crashes the application
The error message is misleading: "Your input may be too large for the context window" when the actual issue is quota exhaustion
There's no graceful degradation when compaction fails

Proposed Fix

Modify _runAutoCompaction to NOT throw on compaction failure. Instead:

Emit an error event that the UI can handle
Keep the assistant error message in agent state (don't remove it before compaction succeeds)
Let the session continue in a degraded state where the user can:
- Switch to a different model with available quota
- Wait for quota to reset
- Manually compact later

Changes needed in agent-session.ts:

typescript

} catch (error) {    const errorMessage = error instanceof Error ? error.message : "compaction failed";        this._emit({         type: "auto_compaction_end",         result: undefined,         aborted: false,         willRetry: false     });
    // Don't throw - emit the error for UI to display    // The session remains usable (user can switch models, wait for quota, etc.)    if (this._extensionRunner) {        this._extensionRunner.emitError({            extensionPath: "auto_compaction",            event: "compact",            error: reason === "overflow"                 ? `Context overflow recovery failed: ${errorMessage}`                 : `Auto-compaction failed: ${errorMessage}`,        });    }        // For overflow case, the error message was already shown to user    // Don't crash - let user decide what to do (switch model, wait, etc.)}

} catch (error) {    const errorMessage = error instanceof Error ? error.message : "compaction failed";        this._emit({         type: "auto_compaction_end",         result: undefined,         aborted: false,         willRetry: false     });
    // Don't throw - emit the error for UI to display    // The session remains usable (user can switch models, wait for quota, etc.)    if (this._extensionRunner) {        this._extensionRunner.emitError({            extensionPath: "auto_compaction",            event: "compact",            error: reason === "overflow"                 ? `Context overflow recovery failed: ${errorMessage}`                 : `Auto-compaction failed: ${errorMessage}`,        });    }        // For overflow case, the error message was already shown to user    // Don't crash - let user decide what to do (switch model, wait, etc.)}

Files to Modify

packages/coding-agent/src/core/agent-session.ts (main fix)

Additional Considerations

The UI should display the compaction failure clearly so users understand what happened
Consider adding a new event type like compaction_error if more structured error handling is needed
The fix preserves the current behavior for threshold-triggered compaction (which already doesn't throw)

this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });

   // Don't throw - emit the error for UI to display   // The session remains usable (user can switch models, wait for quota, etc.)   if (this._extensionRunner) {       this._extensionRunner.emitError({           extensionPath: "auto_compaction",           event: "compact",           error: reason === "overflow"               ? `Context overflow recovery failed: ${errorMessage}`               : `Auto-compaction failed: ${errorMessage}`,       });   }

   // Don't throw - emit the error for UI to display   // The session remains usable (user can switch models, wait for quota, etc.)   if (this._extensionRunner) {       this._extensionRunner.emitError({           extensionPath: "auto_compaction",           event: "compact",           error: reason === "overflow"               ? `Context overflow recovery failed: ${errorMessage}`               : `Auto-compaction failed: ${errorMessage}`,       });   }

cehck how @packages/coding-agent/src/modes/interactive/interactive-mode.ts handles the event. are you ssure it does so via extensionRunner? and not via the _emit?

Good point, let me check how interactive-mode handles these events:

Readinteractive-mode.ts60 lines

I see. The auto_compaction_end event is handled via _emit (which goes through the subscribe mechanism), not via extensionRunner. The event handler shows status if aborted, shows the result if successful, but there's NO handling for the case where event.result is undefined and event.aborted is false (which is what happens when compaction fails with an error).

Looking at the current code:

typescript

if (event.aborted) {    this.showStatus("Auto-compaction cancelled");} else if (event.result) {    // ... show success}// No else case for error!

if (event.aborted) {    this.showStatus("Auto-compaction cancelled");} else if (event.result) {    // ... show success}// No else case for error!

So if compaction fails (result is undefined, aborted is false), nothing is displayed to the user - it just silently fails, then the error is thrown and crashes.

The fix should either:

Add an error field to the auto_compaction_end event
Or add a new event type for compaction errors

Option 1 seems cleaner since it's just extending the existing event. Let me check the event type definition.

You're right. The auto_compaction_end event is handled via _emit/subscribe, not extensionRunner. Let me check the event type definition:

Now I see the issue clearly. The auto_compaction_end event type is:

typescript

{ type: "auto_compaction_end"; result: CompactionResult | undefined; aborted: boolean; willRetry: boolean }

{ type: "auto_compaction_end"; result: CompactionResult | undefined; aborted: boolean; willRetry: boolean }

It has no error or errorMessage field. When compaction fails:

result is undefined
aborted is false
No error info is passed

And in interactive-mode.ts, the handling is:

typescript

if (event.aborted) {    this.showStatus("Auto-compaction cancelled");} else if (event.result) {    // ... show success}// Missing: else case for error!

if (event.aborted) {    this.showStatus("Auto-compaction cancelled");} else if (event.result) {    // ... show success}// Missing: else case for error!

So the proper fix is:

Add an optional errorMessage field to the auto_compaction_end event
In _runAutoCompaction catch block, emit the event WITH the error message (and don't throw)
In interactive-mode.ts, handle the error case and display it to the user

This is cleaner than using extensionRunner.emitError because:

It follows the existing pattern for this event
The UI is already set up to handle these events
It keeps the error handling consistent

Now I see the real issue. The auto_compaction_end event has no errorMessage field, and interactive-mode doesn't handle the "failed but not aborted" case:

typescript

// Current handling in interactive-mode.ts:if (event.aborted) {    this.showStatus("Auto-compaction cancelled");} else if (event.result) {    // ... show success}// Missing: else case for error!

// Current handling in interactive-mode.ts:if (event.aborted) {    this.showStatus("Auto-compaction cancelled");} else if (event.result) {    // ... show success}// Missing: else case for error!

Revised Fix

1. Extend the event type (agent-session.ts line 65):

typescript

| { type: "auto_compaction_end"; result: CompactionResult | undefined; aborted: boolean; willRetry: boolean; errorMessage?: string }

| { type: "auto_compaction_end"; result: CompactionResult | undefined; aborted: boolean; willRetry: boolean; errorMessage?: string }

2. Emit error in catch block (agent-session.ts ~line 1546):

typescript

} catch (error) {    const errorMessage = error instanceof Error ? error.message : "compaction failed";    this._emit({         type: "auto_compaction_end",         result: undefined,         aborted: false,         willRetry: false,        errorMessage: reason === "overflow"             ? `Context overflow recovery failed: ${errorMessage}`            : `Auto-compaction failed: ${errorMessage}`,    });    // Don't throw - let UI handle the error display}

} catch (error) {    const errorMessage = error instanceof Error ? error.message : "compaction failed";    this._emit({         type: "auto_compaction_end",         result: undefined,         aborted: false,         willRetry: false,        errorMessage: reason === "overflow"             ? `Context overflow recovery failed: ${errorMessage}`            : `Auto-compaction failed: ${errorMessage}`,    });    // Don't throw - let UI handle the error display}

3. Handle error in interactive-mode.ts (~line 1815, after the else if (event.result) block):

This follows the existing event pattern and gives the user a clear error message without crashing.

ok, does this have an influence on @packages/coding-agent/src/modes/rpc/rpc-mode.ts as well?

Readrpc-mode.ts40 lines

I see! In rpc-mode, events are simply passed through directly to the output:

So all AgentSessionEvent objects (including auto_compaction_end) are serialized and sent to the RPC client. Adding an errorMessage field to the event type will automatically be included in the output. The RPC client is responsible for handling these events.

This means:

The type change will be reflected in the RPC output automatically
RPC clients will receive the errorMessage field when present
No code changes needed in rpc-mode.ts itself

However, since this is a change to the RPC protocol (adding a new optional field), we should check if there's any documentation or types that RPC clients use.

RPC mode just passes through all events directly:

So:

No code changes needed in rpc-mode.ts - the new errorMessage field will automatically be included in the JSON output
RPC clients will receive the field when present and can handle it as they see fit

The fix only needs changes in:

agent-session.ts - extend event type + emit with errorMessage
interactive-mode.ts - display the error to user

alright, please implement the fix

Readagent-session.ts10 lines

Readagent-session.ts20 lines

Readinteractive-mode.ts35 lines

Readinteractive-mode.ts15 lines

Now I have all the context. Let me apply the three edits:

Editedagent-session.ts

Editedinteractive-mode.ts

Now let me run the type check:

All checks pass. Let me update the changelog:

ReadCHANGELOG.md30 lines

EditedCHANGELOG.md

Fix implemented. Summary of changes:

packages/coding-agent/src/core/agent-session.ts:

Extended auto_compaction_end event type with optional errorMessage field
Modified catch block in _runAutoCompaction to emit the error via the event instead of throwing

packages/coding-agent/src/modes/interactive/interactive-mode.ts:

Added error handling case in auto_compaction_end handler to display the error message to the user

packages/coding-agent/CHANGELOG.md:

Added changelog entry under ### Fixed

The application will no longer crash when auto-compaction fails due to quota limits or other API errors. Instead, the user sees the error message and can take action (switch models, wait for quota reset, etc.).

oki, last check before we commit. any changelog entries missing? docs? if so fix, commit and push

Readrpc.md30 lines

Editedrpc.md

>cd /Users/badlogic/workspaces/pi-mono && git add packages/coding-agent/CHANGELOG.md packages/coding-agent/docs/rpc.md packages/coding-agent/src/core/agent-session.ts packages/coding-agent/src/modes/interactive/interactive-mode.ts && git commit -m "fix(coding-agent): handle auto-compaction failures gracefully

When auto-compaction fails (e.g., quota exceeded), emit the error via
the auto_compaction_end event instead of throwing. The UI now displays
the error message, allowing users to take action (switch models, wait
for quota reset, etc.) instead of crashing.

fixes #792"

Done. Pushed commit 20f5fcc7 which:

Adds errorMessage field to auto_compaction_end event type
Emits error via event instead of throwing when compaction fails
Displays error in interactive mode UI
Updates RPC docs to document the new field
Updates changelog

Issue #792 will be automatically closed.