feat(coref): co-reference-aware compaction

apply/anthropic_toolrole_test.go

@@ -0,0 +1,122 @@
+package apply_test
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	bschemas "github.com/maximhq/bifrost/core/schemas"
+	"github.com/tidwall/gjson"
+
+	"github.com/rossoctl/context-guru/apply"
+	"github.com/rossoctl/context-guru/components"
+	"github.com/rossoctl/context-guru/store"
+)
+
+// A count-changing component (summarize) TOGETHER WITH one that rewrites tool text (format) on
+// ANTHROPIC wire bytes. This combination is what live traffic always runs, and it exposed a defect
+// that neither component shows alone:
+//
+//	400 messages: Unexpected role "tool"
+//
+// A synthetic role=tool message is an internal representation only; Anthropic has no such role. The
+// rebuild emits a message verbatim only when it byte-matches its pre-pipeline form, so once format
+// rewrote a tool message's text it fell through to a fresh marshal and leaked role="tool" onto the
+// wire. Measured live at 12 of 39 runs, and it only became visible after the tool-call-id fix stopped
+// these messages from being deleted outright -- one defect had been masking the other.
+func TestAnthropicCountChangeNeverLeaksToolRole(t *testing.T) {
+	rows := make([]map[string]any, 0, 40)
+	for i := 0; i < 40; i++ {
+		rows = append(rows, map[string]any{
+			"id": 100000 + i, "path": "src/auth.py", "sym": "TOKEN_GRACE_41ab",
+			"status": "ok", "note": "row that format can restructure",
+		})
+	}
+	bigB, _ := json.MarshalIndent(rows, "", "  ")
+	big := string(bigB)
+	msgs := []map[string]any{{"role": "user", "content": "start"}}
+	for i := 0; i < 8; i++ {
+		a, b := "pa_"+string(rune('a'+i)), "pb_"+string(rune('a'+i))
+		msgs = append(msgs,
+			map[string]any{"role": "assistant", "content": []map[string]any{
+				{"type": "text", "text": "calling two"},
+				{"type": "tool_use", "id": a, "name": "Read", "input": map[string]any{}},
+				{"type": "tool_use", "id": b, "name": "Read", "input": map[string]any{}},
+			}},
+			map[string]any{"role": "user", "content": []map[string]any{
+				{"type": "tool_result", "tool_use_id": a, "content": big},
+				{"type": "tool_result", "tool_use_id": b, "content": big},
+			}})
+	}
+	msgs = append(msgs, map[string]any{"role": "user", "content": "final question"})
+	body, _ := json.Marshal(map[string]any{"model": "claude-x", "messages": msgs})
+
+	rewroteAny := false
+	for _, keep := range []int{1, 2, 3, 4} {
+		cfg := pipe(t, "pipeline: [format, summarize]\ncomponents:\n  summarize: {keep_last: "+
+			string(rune('0'+keep))+", start_from_message: 0, min_tokens: 1}\n")
+		p, _ := cfg.Build(nil)
+		out, changed := apply.BodyWithModel(context.Background(), p,
+			store.NewMemory(store.Options{}), bschemas.Anthropic, body, "", false,
+			components.ModelSpec{Incoming: stubModel{resp: "essential facts"}})
+		if !changed {
+			continue
+		}
+		// PRECONDITION. If no tool_result text was rewritten, the failing path is never entered and
+		// a pass proves nothing -- the first version of this test passed with the fix removed for
+		// exactly that reason. Fail loudly rather than pass vacuously.
+		rewrote := false
+		gjson.GetBytes(out, "messages").ForEach(func(_, m gjson.Result) bool {
+			m.Get("content").ForEach(func(_, blk gjson.Result) bool {
+				if blk.Get("type").String() == "tool_result" &&
+					blk.Get("content").String() != big && blk.Get("content").Exists() {
+					rewrote = true
+				}
+				return true
+			})
+			return true
+		})
+		if rewrote {
+			rewroteAny = true
+		}
+		arr := gjson.GetBytes(out, "messages").Array()
+		for i, m := range arr {
+			if r := m.Get("role").String(); r != "user" && r != "assistant" && r != "system" {
+				t.Fatalf("keep_last=%d: wire message %d has role %q -- Anthropic rejects this",
+					keep, i, r)
+			}
+			var uses []string
+			m.Get("content").ForEach(func(_, blk gjson.Result) bool {
+				if blk.Get("type").String() == "tool_use" {
+					uses = append(uses, blk.Get("id").String())
+				}
+				return true
+			})
+			if len(uses) == 0 {
+				continue
+			}
+			answered := map[string]bool{}
+			if i+1 < len(arr) {
+				arr[i+1].Get("content").ForEach(func(_, blk gjson.Result) bool {
+					if blk.Get("type").String() == "tool_result" {
+						answered[blk.Get("tool_use_id").String()] = true
+					}
+					return true
+				})
+			}
+			for _, u := range uses {
+				if !answered[u] {
+					t.Fatalf("keep_last=%d: wire message %d declares %q unanswered", keep, i, u)
+				}
+			}
+		}
+	}
+	// Asserted ONCE, across all keep_last values: at least one case must have carried a rewritten
+	// tool_result through a count change, or the role-leak path was never entered and a pass proves
+	// nothing. The first version of this test passed with the fix removed for exactly that reason,
+	// which is the same vacuous-check trap recorded twice in docs/experiments/loca/.
+	if !rewroteAny {
+		t.Fatal("no case produced a rewritten tool_result surviving a count change, so this test " +
+			"cannot detect the defect it exists for; fix the fixture")
+	}
+}

apply/apply.go

@@ -315,6 +315,7 @@ func BodyOpts(ctx context.Context, pipe *components.Pipeline, st store.Store, o
 		// provider's cap of four counts them all (issue #32, defect 2).
 		ExistingBreakpoints: wireBreakpoints(body),
 		Mode:                mode,
+		PrefixAsk:           o.PrefixAsk,
 	}
 	tr.Session, tr.CacheAware, tr.MaxCachedIdx, tr.Messages = sessionID, cacheAware, maxCachedIdx, len(norm)
 	// The eligible (attempted) denominator: what age/supersession offloaders were
@@ -343,7 +344,37 @@ func BodyOpts(ctx context.Context, pipe *components.Pipeline, st store.Store, o
 	// retained message's ORIGINAL raw bytes (byte-lossless, incl. Anthropic
 	// tool_result) and marshaling only genuinely new messages (the summary).
 	if len(chat.Input) != len(norm) {
-		nb, ok := rebuildCountChanged(body, msgsRaw.Array(), normPre, slots, chat.Input)
+		// Write Anthropic tool_result text rewrites into the BODY before rebuilding.
+		//
+		// A synthetic role=tool message cannot be marshaled into an Anthropic request — the
+		// provider answers `messages: Unexpected role "tool"`. The rebuild below emits a message
+		// verbatim only when it byte-matches its pre-pipeline form, so a tool message whose text a
+		// component rewrote (format rewrites hundreds per run) would fall through to a fresh
+		// marshal and produce exactly that rejection. Measured live: 12 of 39 runs, immediately
+		// after the tool-call-id fix stopped these messages from being silently deleted — one
+		// defect had been masking the other.
+		//
+		// The write-back is the same mechanism the equal-count path uses (sjson at the block's
+		// exact path), applied here first so the rebuild only ever has to decide which messages
+		// to keep, never how to serialize one.
+		pre := body
+		for i := range norm {
+			if i >= len(slots) || slots[i].kind != anthropicToolText {
+				continue
+			}
+			id := norm[i].ChatToolMessage
+			if id == nil || id.ToolCallID == nil {
+				continue
+			}
+			newText, found := toolTextByID(chat.Input, *id.ToolCallID)
+			if !found || newText == slots[i].preText {
+				continue
+			}
+			if nb, err := sjson.SetBytes(pre, slots[i].path, newText); err == nil {
+				pre = nb
+			}
+		}
+		nb, ok := rebuildCountChanged(pre, gjson.GetBytes(pre, "messages").Array(), normPre, slots, norm, chat.Input)
 		if !ok && systemSplit {
 			res.Body, res.Changed = body, true // keep the split even when the rebuild declined
 			return res
@@ -670,6 +701,56 @@ func normalize(provider bschemas.ModelProvider, arr []gjson.Result) (norm []bsch
 		if err := json.Unmarshal([]byte(m.Raw), &cm); err != nil {
 			continue // unparseable message — leave it in the body untouched
 		}
+		// Recover ANTHROPIC tool calls, which bifrost's schema cannot represent.
+		//
+		// An Anthropic assistant turn carries its calls as `tool_use` CONTENT BLOCKS, and
+		// bschemas.ChatContentBlock has no such type — its Type enum is text/image_url/
+		// input_audio/file/refusal — so the ids are simply absent from the unmarshaled message.
+		// Anything that reasons about tool pairing therefore saw an assistant message with ZERO
+		// calls on every Anthropic request, which produced two defects from one cause:
+		//
+		//   - dropOrphanedToolResults builds its answerable set from ToolCalls alone, so on
+		//     Anthropic traffic the set was always empty, EVERY tool_result looked orphaned, and
+		//     the "repair" deleted all of them. The provider then rejected the request for the
+		//     unanswered calls that remained. Measured live: 28 of 75 runs
+		//     (docs/experiments/loca/iter011/results.md).
+		//   - schema.ValidateShape was blind to the same ids, so it could not see the breakage —
+		//     which is why a test asserting all 11 presets emit shape-valid requests stayed green
+		//     while live Anthropic traffic failed.
+		//
+		// Populating ToolCalls here fixes the whole class at the point where the dialect is still
+		// known, rather than teaching each consumer about Anthropic. The ids are what pairing
+		// needs; arguments are carried for completeness. Note this deliberately makes the
+		// `lossless` check below FALSE for such messages, which is honest — bifrost genuinely
+		// cannot round-trip them — and it only makes the write-back guard more conservative.
+		if provider == bschemas.Anthropic && cm.Role == bschemas.ChatMessageRoleAssistant &&
+			m.Get("content").IsArray() {
+			var calls []bschemas.ChatAssistantMessageToolCall
+			for _, blk := range m.Get("content").Array() {
+				if blk.Get("type").String() != "tool_use" {
+					continue
+				}
+				id, name := blk.Get("id").String(), blk.Get("name").String()
+				if id == "" {
+					continue
+				}
+				idc, namec, args := id, name, blk.Get("input").Raw
+				calls = append(calls, bschemas.ChatAssistantMessageToolCall{
+					ID: &idc,
+					Function: bschemas.ChatAssistantMessageToolCallFunction{
+						Name: &namec, Arguments: args,
+					},
+				})
+			}
+			if len(calls) > 0 {
+				if cm.ChatAssistantMessage == nil {
+					cm.ChatAssistantMessage = &bschemas.ChatAssistantMessage{}
+				}
+				if len(cm.ChatAssistantMessage.ToolCalls) == 0 {
+					cm.ChatAssistantMessage.ToolCalls = calls
+				}
+			}
+		}
 		preMarshal, _ := json.Marshal(cm)
 		norm = append(norm, cm)
 		slots = append(slots, slot{
@@ -713,7 +794,18 @@ func jsonEqual(a, b []byte) bool {
 // normalized message (a survivor) is emitted as its ORIGINAL body raw bytes
 // (byte-lossless); genuinely new messages (the summary) are marshaled fresh.
 // Fail-open (returns body,false) if any survivor can't be mapped to the body.
-func rebuildCountChanged(body []byte, orig []gjson.Result, normPre [][]byte, slots []slot, out []bschemas.ChatMessage) ([]byte, bool) {
+// toolTextByID finds the post-pipeline text of the synthetic tool message answering id.
+func toolTextByID(msgs []bschemas.ChatMessage, id string) (string, bool) {
+	for i := range msgs {
+		tm := msgs[i].ChatToolMessage
+		if tm != nil && tm.ToolCallID != nil && *tm.ToolCallID == id {
+			return schema.MessageText(msgs[i]), true
+		}
+	}
+	return "", false
+}
+
+func rebuildCountChanged(body []byte, orig []gjson.Result, normPre [][]byte, slots []slot, norm, out []bschemas.ChatMessage) ([]byte, bool) {
 	// The rebuild emits ONLY slot-mapped messages, so a body message normalize skipped
 	// (unparseable — it has no slot) would be silently DELETED from the forwarded
 	// request. Deleting a message is an ALTERED request, not a fail-open one, so decline
@@ -740,10 +832,23 @@ func rebuildCountChanged(body []byte, orig []gjson.Result, normPre [][]byte, slo
 			return body, false
 		}
 		matched := -1
-		for k := range normPre {
+		// A synthetic Anthropic tool message is matched by tool_call_id, NOT by bytes: its text may
+		// have been rewritten by a component, and that rewrite has already been written into the
+		// body above. Byte-matching it would fail and send it down the fresh-marshal path, which
+		// emits `role: "tool"` and is rejected outright by Anthropic.
+		if tm := out[i].ChatToolMessage; tm != nil && tm.ToolCallID != nil {
+			for k := range norm {
+				ntm := norm[k].ChatToolMessage
+				if !used[k] && ntm != nil && ntm.ToolCallID != nil &&
+					*ntm.ToolCallID == *tm.ToolCallID {
+					matched = k
+					break
+				}
+			}
+		}
+		for k := 0; matched < 0 && k < len(normPre); k++ {
 			if !used[k] && bytes.Equal(mb, normPre[k]) {
 				matched = k
-				break
 			}
 		}
 		if matched < 0 {

apply/ctxmgmt_preserved_test.go

@@ -0,0 +1,66 @@
+package apply_test
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	bschemas "github.com/maximhq/bifrost/core/schemas"
+	"github.com/tidwall/gjson"
+
+	"github.com/rossoctl/context-guru/apply"
+	"github.com/rossoctl/context-guru/components"
+	"github.com/rossoctl/context-guru/store"
+)
+
+// LOCA's context clearing is Anthropic's SERVER-SIDE context_management feature, passed as a request
+// parameter (clear_tool_uses_20250919 with trigger input_tokens). If a count-changing component
+// dropped that parameter while rewriting the body, the provider's clearing would be silently
+// disabled -- and since the proxy also shrinks the request below the trigger, nothing would keep an
+// oversized transcript legal. Five runs in the 128k arms died on "prompt is too long" at up to 6M
+// tokens, so whether this survives is a product question, not a formality.
+func TestContextManagementParamSurvivesCountChange(t *testing.T) {
+	big := strings.Repeat("verbose tool output line\n", 200)
+	msgs := []map[string]any{{"role": "user", "content": "go"}}
+	for i := 0; i < 6; i++ {
+		id := "t" + string(rune('a'+i))
+		msgs = append(msgs,
+			map[string]any{"role": "assistant", "content": []map[string]any{
+				{"type": "text", "text": "calling"},
+				{"type": "tool_use", "id": id, "name": "Read", "input": map[string]any{}}}},
+			map[string]any{"role": "user", "content": []map[string]any{
+				{"type": "tool_result", "tool_use_id": id, "content": big}}})
+	}
+	msgs = append(msgs, map[string]any{"role": "user", "content": "final"})
+	body, _ := json.Marshal(map[string]any{
+		"model":    "claude-x",
+		"messages": msgs,
+		"context_management": map[string]any{"edits": []map[string]any{{
+			"type":          "clear_tool_uses_20250919",
+			"trigger":       map[string]any{"type": "input_tokens", "value": 128000},
+			"keep":          map[string]any{"type": "tool_uses", "value": 3},
+			"clear_at_least": map[string]any{"type": "input_tokens", "value": 20000},
+		}}},
+	})
+	cfg := pipe(t, "pipeline: [format, summarize]\ncomponents:\n  summarize: {keep_last: 2, start_from_message: 0, min_tokens: 1}\n")
+	p, _ := cfg.Build(nil)
+	out, changed := apply.BodyWithModel(context.Background(), p, store.NewMemory(store.Options{}),
+		bschemas.Anthropic, body, "", false,
+		components.ModelSpec{Incoming: stubModel{resp: "essential facts"}})
+	if !changed {
+		t.Skip("summarize did not act")
+	}
+	got := gjson.GetBytes(out, "context_management")
+	if !got.Exists() {
+		t.Fatal("context_management was DROPPED by the rewrite: the provider's own clearing would be " +
+			"silently disabled while the proxy also keeps requests under its trigger")
+	}
+	want := gjson.GetBytes(body, "context_management")
+	if got.Raw != want.Raw {
+		t.Errorf("context_management was altered:\n got %s\nwant %s", got.Raw, want.Raw)
+	}
+	if v := got.Get("edits.0.trigger.value").Int(); v != 128000 {
+		t.Errorf("trigger value changed to %d", v)
+	}
+}

apply/normalize_toolcalls_test.go

@@ -0,0 +1,57 @@
+package apply
+
+import (
+	"encoding/json"
+	"testing"
+
+	bschemas "github.com/maximhq/bifrost/core/schemas"
+	"github.com/tidwall/gjson"
+)
+
+// Does normalize populate ChatAssistantMessage.ToolCalls for an ANTHROPIC assistant message whose
+// tool calls arrive as  CONTENT BLOCKS? dropOrphanedToolResults builds its "answerable"
+// set exclusively from that field, so if it is empty on Anthropic traffic then every tool_result
+// looks orphaned and the repair DELETES them all -- which is exactly what the instrumented rebuild
+// showed (out contained no tool messages at all).
+//
+// The offload-level tests passed because they hand-build ChatMessages with ToolCalls populated, i.e.
+// the OpenAI-shaped representation. That is why unit tests were green while live Anthropic traffic
+// failed 28/75.
+func TestNormalizePopulatesToolCallsForAnthropicBlocks(t *testing.T) {
+	body, _ := json.Marshal(map[string]any{
+		"model": "claude-x",
+		"messages": []map[string]any{
+			{"role": "user", "content": "go"},
+			{"role": "assistant", "content": []map[string]any{
+				{"type": "text", "text": "calling"},
+				{"type": "tool_use", "id": "t1", "name": "Read", "input": map[string]any{}},
+			}},
+			{"role": "user", "content": []map[string]any{
+				{"type": "tool_result", "tool_use_id": "t1", "content": "the output"},
+			}},
+		},
+	})
+	arr := gjson.GetBytes(body, "messages").Array()
+	norm, _ := normalize(bschemas.Anthropic, arr)
+	for i, m := range norm {
+		n := 0
+		if m.ChatAssistantMessage != nil {
+			n = len(m.ChatAssistantMessage.ToolCalls)
+		}
+		id := ""
+		if m.ChatToolMessage != nil && m.ChatToolMessage.ToolCallID != nil {
+			id = *m.ChatToolMessage.ToolCallID
+		}
+		t.Logf("norm[%d] role=%-9s ToolCalls=%d answers=%q", i, m.Role, n, id)
+	}
+	var calls int
+	for _, m := range norm {
+		if m.ChatAssistantMessage != nil {
+			calls += len(m.ChatAssistantMessage.ToolCalls)
+		}
+	}
+	if calls == 0 {
+		t.Errorf("no assistant ToolCalls recovered from Anthropic tool_use blocks: "+
+			"dropOrphanedToolResults will treat every tool_result as an orphan and delete it")
+	}
+}