agentfuse v0.5.0: iteration amendments + regression tests

Author: SuperMarioYL

LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 SuperMarioYL
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

internal/proxy/anthropic.go

@@ -32,7 +32,11 @@ type anthropicResponse struct {
 		InputTokens  int `json:"input_tokens"`
 		OutputTokens int `json:"output_tokens"`
 	} `json:"usage"`
-	Model string `json:"model"`
+	Model   string `json:"model"`
+	Content []struct {
+		Type string `json:"type"`
+		Text string `json:"text"`
+	} `json:"content"`
 }
 
 func anthropicHandler(s *Server) http.Handler {
@@ -144,11 +148,18 @@ func anthropicHandler(s *Server) http.Handler {
 				// Both upstream usage AND a local estimate are available — record
 				// the comparison so the §8 >25% accuracy criterion is measurable.
 				// v0.4: use EstimateCompletion (the estimator the fallback actually
-				// bills with, incl. the +100 round-up) on the completion text — the
+				// bills with, incl. +100 round-up) on the completion text — the
 				// harness must measure the estimator the cap uses, not EstimatePrompt
 				// run on completion text (wrong side + no round-up = biased-low).
-				tokens.RecordSample("anthropic", model,
-					tokens.EstimateCompletion(model, completionText), outTok)
+				// v0.5.0: guard — skip the sample when completionText is still "".
+				// An empty completion yields EstimateCompletion(model,"")=100
+				// (roundUp n<=0 -> step), which false-triggers the §8 >25% kill
+				// criterion the harness was built to make evaluable. There is
+				// nothing meaningful to compare against outTok in that case.
+				if completionText != "" {
+					tokens.RecordSample("anthropic", model,
+						tokens.EstimateCompletion(model, completionText), outTok)
+				}
 			}
 			usd := budget.CostFromUsageWithProvider("anthropic", model, inTok, outTok)
 			if _, err := s.led.CommitDelta(s.projectRoot, estimate, inTok, outTok, usd); err != nil {
@@ -199,7 +210,14 @@ func parseAnthropicUsage(body []byte) (int, int, string, string) {
 	if err := json.Unmarshal(body, &unary); err == nil &&
 		(unary.Usage.InputTokens > 0 || unary.Usage.OutputTokens > 0 || unary.Model != "") {
 		if unary.Usage.InputTokens > 0 || unary.Usage.OutputTokens > 0 {
-			return unary.Usage.InputTokens, unary.Usage.OutputTokens, "", unary.Model
+			// v0.5.0: fix-accuracy-harness-empty-completion-unary — the unary
+			// branch previously returned "" for completionText, so RecordSample
+			// measured EstimateCompletion(model, "")=100 on every unary response
+			// regardless of real completion length, false-triggering the §8 >25%
+			// kill criterion. Extract the content-block text so the harness
+			// measures a real estimate on unary traffic too.
+			return unary.Usage.InputTokens, unary.Usage.OutputTokens,
+				anthropicContentText(unary.Content), unary.Model
 		}
 	}
 
@@ -248,6 +266,25 @@ func parseAnthropicUsage(body []byte) (int, int, string, string) {
 	return inTok, outTok, text.String(), model
 }
 
+// anthropicContentText flattens the content blocks of a unary Anthropic
+// response into one string, so the accuracy harness can EstimateCompletion on
+// the real completion text instead of "" (which rounds up to 100 and
+// false-triggers the §8 >25% kill criterion on unary traffic). Text blocks
+// contribute their text; non-text blocks (tool_use, etc.) contribute nothing —
+// they are not billed as completion tokens by the estimator.
+func anthropicContentText(blocks []struct {
+	Type string `json:"type"`
+	Text string `json:"text"`
+}) string {
+	var b strings.Builder
+	for _, blk := range blocks {
+		if blk.Type == "text" || blk.Type == "" {
+			b.WriteString(blk.Text)
+		}
+	}
+	return b.String()
+}
+
 // anthropicPromptText flattens an Anthropic Messages request body into one big
 // string for tiktoken estimation when the upstream omits usage entirely.
 func anthropicPromptText(body []byte) string {
@@ -291,9 +328,27 @@ func estimatePromptTokens(body []byte) int {
 func copyHeader(dst, src http.Header) {
 	for k, vv := range src {
 		// Drop hop-by-hop and host headers; let Go re-set transport.
+		// Accept-Encoding is also dropped: Go's http transport only
+		// auto-decompresses a gzipped response when IT added the
+		// Accept-Encoding header. A caller-set value (Go/Node/fetch add
+		// "gzip" by default) is forwarded verbatim, the upstream then
+		// gzips the unary JSON body, and the transport passes the raw
+		// \x1f\x8b bytes through untouched — so io.ReadAll(resp.Body)
+		// yields gzip bytes, parseAnthropicUsage/parseDeepSeekUsage
+		// json.Unmarshal them into an error (in=0, out=0,
+		// completionText=""), and the per-side fallback bills
+		// promptTokens + EstimateCompletion(model, "")=100 instead of
+		// the real usage. For a unary response with thousands of real
+		// output tokens that under-bills by orders of magnitude, so
+		// realized spend can exceed the cap without tripping it
+		// (fail-open) — the exact property this product exists to
+		// prevent. Stripping it here lets the proxy's own transport
+		// manage gzip (adds Accept-Encoding, decompresses, strips
+		// Content-Encoding) for all five handlers that share this
+		// copier. v0.5.0: fix-gzip-accept-encoding-forwarded.
 		if k == "Connection" || k == "Keep-Alive" || k == "Proxy-Connection" ||
 			k == "Te" || k == "Trailer" || k == "Transfer-Encoding" || k == "Upgrade" ||
-			k == "Host" || k == "Content-Length" {
+			k == "Host" || k == "Content-Length" || k == "Accept-Encoding" {
 			continue
 		}
 		for _, v := range vv {

internal/proxy/deepseek.go

@@ -173,7 +173,16 @@ func parseDeepSeekUsage(body []byte) (int, int, string, string) {
 			outTok = unary.Usage.OutputTokens
 		}
 		if inTok > 0 || outTok > 0 {
-			return inTok, outTok, "", unary.Model
+			// v0.5.0: fix-accuracy-harness-empty-completion-unary — extract
+			// choices[].message.content so RecordSample (called by openai.go,
+			// which reuses this parser) measures a real
+			// EstimateCompletion(model, completionText) instead of
+			// EstimateCompletion(model, "")=100 on unary traffic.
+			var text strings.Builder
+			for _, c := range unary.Choices {
+				text.WriteString(c.Message.Content)
+			}
+			return inTok, outTok, text.String(), unary.Model
 		}
 	}
 

internal/proxy/gzip_accept_encoding_test.go

@@ -0,0 +1,133 @@
+package proxy
+
+import (
+	"bytes"
+	"compress/gzip"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/SuperMarioYL/agentfuse/internal/account"
+	"github.com/SuperMarioYL/agentfuse/internal/budget"
+)
+
+// TestGzipAcceptEncodingNotForwarded is the v0.5.0 regression for the HIGH
+// fail-open cap-correctness defect fix-gzip-accept-encoding-forwarded.
+//
+// copyHeader forwarded the inbound "Accept-Encoding: gzip" (which Go/Node/fetch
+// HTTP clients add by default) onto upReq.Header on all five handlers. Go's
+// http transport only auto-decompresses a gzipped response when IT added the
+// Accept-Encoding header; a caller-set value is passed through untouched, so a
+// gzipped unary JSON body is read raw by io.ReadAll(resp.Body).
+// parseAnthropicUsage then json.Unmarshals the gzip bytes into an error
+// (in=0, out=0, completionText=""), the per-side fallback bills promptTokens +
+// EstimateCompletion(model, "")=100, and realized spend exceeds the cap without
+// tripping it (fail-open) — the exact property the product exists to prevent.
+//
+// This test reproduces the defect hermetically: the httptest upstream HONORS
+// Accept-Encoding: gzip (the existing tests' upstreams never did, which is why
+// the defect slipped past them). The inbound client request sets
+// Accept-Encoding: gzip. Without the fix the proxy forwards it, the upstream
+// gzips, the proxy reads raw \x1f\x8b bytes, parsing fails, and the ledger
+// bills the fallback (outTok=100) instead of the real usage (outTok=500). With
+// the fix copyHeader strips Accept-Encoding, the proxy's own transport manages
+// gzip (re-adds Accept-Encoding, decompresses, strips Content-Encoding), and
+// the usage parser sees plain JSON — the ledger bills the real 1000/500.
+func TestGzipAcceptEncodingNotForwarded(t *testing.T) {
+	var upstreamSawAcceptEncoding string
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		upstreamSawAcceptEncoding = r.Header.Get("Accept-Encoding")
+		payload, _ := json.Marshal(map[string]any{
+			"id":    "msg_01",
+			"model": "claude-sonnet-4",
+			"usage": map[string]int{"input_tokens": 1000, "output_tokens": 500},
+			"content": []map[string]string{
+				{"type": "text", "text": "unary gzipped response"},
+			},
+		})
+		if strings.Contains(upstreamSawAcceptEncoding, "gzip") {
+			// Honor the advertised encoding — this is what a real upstream
+			// (api.anthropic.com, api.openai.com, …) does for a non-streamed
+			// request that advertised gzip.
+			var buf bytes.Buffer
+			gz := gzip.NewWriter(&buf)
+			_, _ = gz.Write(payload)
+			_ = gz.Close()
+			w.Header().Set("Content-Type", "application/json")
+			w.Header().Set("Content-Encoding", "gzip")
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write(buf.Bytes())
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write(payload)
+	}))
+	defer upstream.Close()
+
+	prev := AnthropicUpstream
+	AnthropicUpstream = upstream.URL
+	defer func() { AnthropicUpstream = prev }()
+
+	led := mustOpenLedger(t)
+	cfg := &budget.Config{CapUSD: 5.00, Window: "project"}
+	s := New("/proj/gzip", cfg, led, &account.File{Accounts: map[string]account.Account{}})
+	if err := s.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+		_ = s.Stop(ctx)
+	}()
+
+	body := []byte(`{"model":"claude-sonnet-4","max_tokens":256,"messages":[{"role":"user","content":"hi"}]}`)
+	req, _ := http.NewRequest(http.MethodPost, "http://"+s.Addr()+"/anthropic/v1/messages", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("x-api-key", "sk-ant-test-1234567890")
+	// Simulate a caller (Go/Node/fetch default) that advertises gzip. Before
+	// the fix, copyHeader forwarded this verbatim and the upstream gzipped the
+	// unary JSON body, which Go's transport then handed to the handler raw
+	// (no auto-decompress for a caller-set header).
+	req.Header.Set("Accept-Encoding", "gzip")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, _ = io.Copy(io.Discard, resp.Body)
+	_ = resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("status=%d", resp.StatusCode)
+	}
+
+	// Sanity: the test is only meaningful if the upstream actually received a
+	// gzip advertisement and gzipped the body. Without this, the defect would
+	// not reproduce and the test would pass vacuously.
+	if !strings.Contains(upstreamSawAcceptEncoding, "gzip") {
+		t.Fatalf("test setup broken: upstream never saw Accept-Encoding: gzip (got %q) — defect not exercised", upstreamSawAcceptEncoding)
+	}
+
+	got, err := led.ProjectTotal("/proj/gzip")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The defect: a forwarded Accept-Encoding: gzip made the upstream gzip the
+	// unary JSON, the parser read raw \x1f\x8b bytes, json.Unmarshal errored,
+	// and the per-side fallback billed promptTokens + EstimateCompletion(model,
+	// "")=100 instead of the real 1000/500. Asserting the REAL usage lands
+	// proves the skip-list fix let the proxy transport manage gzip.
+	if got.TokensIn != 1000 || got.TokensOut != 500 {
+		t.Fatalf("gzipped unary response not parsed — ledger has in=%d out=%d (want 1000/500); "+
+			"copyHeader is still forwarding caller-set Accept-Encoding and the parser is reading raw gzip bytes",
+			got.TokensIn, got.TokensOut)
+	}
+	if got.USD <= 0 {
+		t.Fatalf("gzipped unary response billed $0 — fail-open defect still present")
+	}
+}

internal/proxy/openai.go

@@ -31,6 +31,18 @@ type openaiResponse struct {
 		OutputTokens     int `json:"output_tokens"`
 	} `json:"usage"`
 	Model string `json:"model"`
+	// Choices carries the assistant message on a unary (non-streamed) Chat
+	// Completions response. v0.5.0: fix-accuracy-harness-empty-completion-unary
+	// — the unary parseDeepSeekUsage branch (reused by openai.go) returned ""
+	// for completionText, so RecordSample measured EstimateCompletion(model,
+	// "")=100 on every unary OpenAI/DeepSeek response. Extracting
+	// choices[].message.content here lets the harness measure a real estimate.
+	Choices []struct {
+		Message struct {
+			Role    string `json:"role"`
+			Content string `json:"content"`
+		} `json:"message"`
+	} `json:"choices"`
 }
 
 func openaiHandler(s *Server) http.Handler {
@@ -135,8 +147,15 @@ func openaiHandler(s *Server) http.Handler {
 				// with, incl. +100 round-up) on the completion text — previously
 				// EstimatePrompt(completionText) compared against outTok, which is
 				// the wrong side + structurally biased low (no round-up).
-				tokens.RecordSample("openai", model,
-					tokens.EstimateCompletion(model, completionText), outTok)
+				// v0.5.0: guard — skip the sample when completionText is still "".
+				// An empty completion yields EstimateCompletion(model,"")=100
+				// (roundUp n<=0 -> step), which false-triggers the §8 >25% kill
+				// criterion the harness was built to make evaluable. There is
+				// nothing meaningful to compare against outTok in that case.
+				if completionText != "" {
+					tokens.RecordSample("openai", model,
+						tokens.EstimateCompletion(model, completionText), outTok)
+				}
 			}
 			usd := budget.CostFromUsageWithProvider("openai", model, inTok, outTok)
 			if _, err := s.led.CommitDelta(s.projectRoot, estimate, inTok, outTok, usd); err != nil {