[bug] ModelUsabilityBudgetError: gpt-6-astra cannot resume (required 1152965 tokens)

[jc01rho]

Symptom

• Model: gpt-6-astra
• Action: attempting to resume an existing session throws ModelUsabilityBudgetError
• Error: target context window 850000 tokens is 302965 tokens short of the 1152965-token requirement

Highlight: requiredTokens = 1,152,965 (~1.15M)

The resume admission check demands 1,152,965 tokens, which exceeds the model's 850,000-token context window by 302,965 tokens:

Component	Tokens
Live context	965,016
System prompt	5,810
Active tool schemas	11,947
Output reserve	128,000
Compaction reserve	34,000
Speculation lead	0
Safety margin (default profile)	8,192
Required total	1,152,965
Model context window	850,000
Shortfall	302,965

In other words, the live context alone (~965K) plus the fixed reserves (~170K) already sum to ~1.15M, so resume is rejected at the admission stage before any work can proceed.

Full projection

{
  "model": "gpt-6-astra",
  "contextWindow": 850000,
  "liveContextTokens": 965016,
  "systemPromptTokens": 5810,
  "activeToolSchemaTokens": 11947,
  "outputReserveTokens": 128000,
  "compactionReserveTokens": 34000,
  "speculationLeadTokens": 0,
  "safetyMarginTokens": 8192,
  "safetyMarginProfile": "default",
  "requiredTokens": 1152965,
  "shortfallTokens": 302965,
  "usable": false,
  "admission": "resume"
}

Stack trace

at assertModelUsable (agent-session.js:3715:19)
at createAgentSession (sdk.js:373:17)

Environment

• Bun v1.4.2 (Linux x64)
• omo-ai installed via mise (node 26.7.0 path)

Expected behavior

• Before rejecting resume outright, shrink the live context via compaction (or adjust the reserve calculation) so the session can resume.
• At minimum, guide the user to a recovery path (e.g. compact, then retry) instead of a hard admission failure with no actionable next step.

[code-yeongyu]

I am working on this through implementation, verification, and merge. The current resume path still rejects a restored transcript when liveContextTokens exceeds contextWindow, before recovery can run. I am checking the existing work in #1430 against current main rather than assuming it is ready to merge.

The target behavior is to preserve the original session history, recover an over-budget session without sending an oversized ordinary request, preserve tool-call/result boundaries, and revalidate the actual request budget before continuing. Unrecoverable fixed overhead must produce an actionable error without damaging the session. I will post updates here at reproduction, implementation/QA, and merge milestones.

[code-yeongyu]

Update: I audited current main and corrected two earlier assumptions before editing. #1430 is not merge-ready: it conflicts with current sdk.ts/changes.md and its changelog gate is red. Also, the existing summarization overflow path pre-sizes input before the first attempt and halves bounded retries, so I am not claiming a fixed number of large billed requests without payload evidence.

The implementation target is now stricter: deterministic bounded recovery at resume admission, original history and tool-call/result boundaries preserved, atomic failure/cancellation, idempotent reopen, and an independent post-recovery budget check before the first ordinary provider request. I am capturing a true RED on current main before the production change.

[code-yeongyu]

Progress: reproduced and fixed, verification in flight.

RED (before any production edit): a new regression drives a persisted session whose measured live context is 979,364 tokens against an 850,000-token window (required 1,158,762 - the same band as this report). It failed exactly where you did, in assertModelUsable via createAgentSession.

Fix: when a restored context is larger than the window itself, resume now performs a deterministic, no-LLM context reduction before the session opens. It reuses the existing cut-point selection, so a retained tool result always keeps its originating tool call; the recorded transcript is left byte-for-byte intact and only the live context is reduced; the reduction is accepted only when the post-reduction projection leaves room for an ordinary request, so no oversized provider call is issued. If no safe cut fits under the fixed overhead, the original actionable budget error is raised and nothing is written. Sessions with compaction disabled keep the existing refusal.

GREEN: the same regression file passes 4/4, and 92 adjacent test files (731 tests) covering resume admission, the model usability budget, session persistence and compaction mechanics stay green. Mutation proof, real CLI/RPC QA, static checks and the PR follow.

[code-yeongyu]

Verification update, including two corrections to my own work.

The fix is green: the new regression passes 4/4 and 92 adjacent test files (731 tests) covering resume admission, the model usability budget, session persistence and compaction mechanics stay green.

I then ran a mutation pass over every new assertion, which caught two of them being unable to fail:

1. The transcript assertion only counted in-memory entries, so it survived every mutation. It now counts message records in the persisted session file as well. Breaking history visibility or truncating the file both fail it.
2. The budget assertion only required the context to fit beside the output reserve, which is looser than what the code enforces. It now pins the full uncompacted requirement: live context plus system prompt, tool schemas, output reserve, compaction reserve and safety margin must fit the window. Removing the post-reduction budget check now fails it.

That pass also invalidated part of my first implementation. I had added a preserveTranscript flag to SessionManager.appendCompaction believing compaction truncates the session file. It does not: the trim only affects the in-memory mirror, and entry reads reload the full history from the file once the mirror is trimmed. The flag protected nothing, so it and its call-site argument were reverted; the persistence API is untouched. The transcript guarantee holds through existing behavior, now pinned by tests that fail if it regresses.

Remaining before I open the PR: static checks and build, and a real CLI/RPC run against a persisted oversized session.

[code-yeongyu]

Real-surface QA is green, so the fix is now proven outside the unit tests.

A new senpi-qa scenario drives the actual CLI against a scripted local provider: it starts a session, inflates the persisted transcript past the model window, then resumes with --continue. Measured on the wire, not in-process:

• restored context ~156,380 tokens against a 120,000-token window
• resumed turn completes with exit 0 and no ModelUsabilityBudgetError
• the outgoing provider request is ~45,423 tokens, inside the 112,000 budget left beside the output reserve
• all 60 inflated transcript records are still on disk afterwards
• resuming a second time works and the reduction is recorded exactly once
• the real credential file is untouched

Static checks and the package build also pass (exit 0). An earlier red build was my remote test tree carrying 6,056 stale files from an older checkout, not this change; it is green on a clean tree.

Next: rebase onto current main, open the PR, and carry it through CI to merge.

[code-yeongyu]

PR is up: #1538 (rebased onto current main).

It carries four commits: the fix, the regression that pins it, the real-CLI QA scenario, and the tracker/changelog records. The changelog gate passes locally and the rebased tree re-runs the resume suites green (21 tests across the new regression, the earlier oversized-resume regression, and the model usability budget). I am watching CI now and will report the result here, then merge and close this issue once every required check is green.

[code-yeongyu]

Fixed and merged: #1538 landed on main as de4a6bd, and this issue closed with it.

What changes for you: a session whose restored transcript is larger than the model window now opens. Before the first prompt, resume reduces the live context deterministically and without any provider request, keeping the newest turns that fit. Your session file is untouched, tool calls keep their results, and the reduction is only accepted when the remaining context still leaves room for the system prompt, tool schemas, output reserve, compaction reserve and safety margin, so the first request cannot overflow. Interactive mode tells you the reduction happened. If even the fixed overhead cannot fit, you still get the original actionable error and nothing is written, and sessions with compaction disabled keep refusing rather than silently dropping context.

Verification: the regression captured your failure first (measured live 979,364 against an 850,000-token window, required 1,158,762) and passes after the change; 92 adjacent test files with 731 tests stay green; static checks and the build pass; and a real CLI run resumed an over-window session with the outgoing request measured at ~45,423 tokens inside a 112,000 budget while all inflated records stayed on disk. A mutation pass over the new assertions also forced two of them to be rewritten and removed one unnecessary change to the persistence API.

This ships in the next release. If you hit anything similar on a different model or window, please reopen with the projection block again.