Function Pack

internal/ctx/ctx.go:140–188

Pack keeps whole messages newest-first until the budget is full, then returns them chronologically. The newest message is always kept, even if it alone exceeds the budget. Two clean-up passes then keep the wire well-formed: dropDanglingToolCalls drops an assistant whose tool_calls weren't all answer

(history []Message, budget int)

// last, rewriting any surviving system note to a user message: the wire is always
// prefixed by the embedded system prompt, so a fourth shape (a second, non-leading
// system message) 400s strict backends, and that note is only ever a soft-nudge.
func Pack(history []Message, budget int) PackResult {
	kept := make([]Message, 0, len(history))
	used := 0
	// walk newest to oldest
	for i := len(history) - 1; i >= 0; i-- {
		cost := history[i].Tokens()
		if len(kept) > 0 && used+cost > budget {
			break
		}
		kept = append(kept, history[i])
		used += cost
	}
	slices.Reverse(kept)
	// Dangling assistant first: dropping it can orphan its partial tool results,
	// which the following dropOrphanTools pass then cleans up.
	kept = dropDanglingToolCalls(kept)
	kept = dropOrphanTools(kept)
	// The cleanup passes can lose the current turn's tool exchange when the
	// newest tool result's owning assistant fell just past the budget cut: the
	// budget walk keeps the lone tool result (plus any trailing system nudge),
	// then the orphan drop removes it, so the next request would silently lose
	// the whole conversation mid-turn (reachable on small-ctx profiles after a
	// big tool output). Keyed on "nothing substantive survived", NOT on
	// len(kept)==0: a failure/runaway nudge (or the empty assistant reply the
	// empty-reply nudge answers) survives the cleanup as the sole keeper and
	// would otherwise mask exactly this loss - and nothing substantive
	// surviving already implies the newest tool result didn't. A surviving
	// user message or real assistant reply instead means the conversation
	// moved past the exchange, ordinary budget trimming, no over-budget
	// resurrection. Recover the newest assistant+tool-results group whole,
	// over budget if need be, with the same deliberately-over-budget
	// guarantee a newest user message already gets.
	if i := newestToolIndex(history); i >= 0 && onlyNonSubstantive(kept) {
		// Recover the group over budget, then re-run the same two passes the
		// normal path uses: a partially-answered parallel set (owner issued c1,c2
		// but only c1 came back before an abort) would otherwise reach the wire as
		// a dangling assistant and 400 every backend. Fully-answered groups pass
		// through untouched; an unpairable partial empties to nothing. Survivors
		// in kept are all newer than the recovered group (the budget walk keeps a
		// suffix), so prepending keeps the order chronological.
		group := newestToolGroup(history[:i+1])
		group = dropDanglingToolCalls(group)
		group = dropOrphanTools(group)
		kept = append(group, kept...)
	}
	kept = anchorUserMessage(kept, history)
	kept = demoteSystemMessages(kept)
	return PackResult{Messages: kept}
}

// anchorUserMessage guarantees the packed window carries a user-role message