fix(proxy): strip empty optional fields from streamed tool inputs

gpt-5.5 occasionally emits unused optional fields (e.g. "pages":"" on
the Read tool) when generating function calls. The proxy was forwarding
each input_json_delta as-is, so the polluted input reached claudecode
and the model in subsequent turns kept rationalizing "the tool layer
brought in empty pages" — issue #95.

Buffer function_call_arguments deltas until output_item.done, drop
top-level keys whose value is "" or null, then emit the cleaned JSON
as a single input_json_delta before content_block_stop. Also apply the
same cleanup when reconstructing tool_use blocks from non-streaming
response.completed payloads and when re-encoding historical assistant
tool_use blocks back into upstream function_call items.

Empty objects/arrays and whitespace strings are preserved (some tools
treat those as meaningful). Trade-off: claudecode no longer sees tool
arguments stream char-by-char, but tool JSON is small enough that the
UX delta is imperceptible.

Author: james-6-23

proxy/anthropic.go

@@ -410,7 +410,9 @@ func appendAssistantBlocks(input []any, blocks []anthropicContentBlock) []any {
 			}
 			args := "{}"
 			if len(b.Input) > 0 {
-				args = string(b.Input)
+				if cleaned := sanitizeToolInputJSON(string(b.Input)); cleaned != "" {
+					args = cleaned
+				}
 			}
 			input = append(input, map[string]any{
 				"type":      "function_call",
@@ -530,18 +532,19 @@ func convertAnthropicToolChoice(raw json.RawMessage) any {
 
 // anthropicStreamTranslator 有状态的流式响应翻译器（Codex → Anthropic）
 type anthropicStreamTranslator struct {
-	model              string
-	responseID         string
-	messageStartSent   bool
-	contentBlockIndex  int
-	contentBlockOpen   bool
-	currentBlockType   string // "text" | "thinking" | "tool_use"
-	currentToolUseID   string
-	currentToolUseName string
-	hasToolUse         bool
-	inputTokens        int
-	outputTokens       int
-	cachedTokens       int
+	model                   string
+	responseID              string
+	messageStartSent        bool
+	contentBlockIndex       int
+	contentBlockOpen        bool
+	currentBlockType        string // "text" | "thinking" | "tool_use"
+	currentToolUseID        string
+	currentToolUseName      string
+	currentToolInputBuffer  strings.Builder
+	hasToolUse              bool
+	inputTokens             int
+	outputTokens            int
+	cachedTokens            int
 }
 
 // newAnthropicStreamTranslator 创建流式翻译器
@@ -749,22 +752,17 @@ func (t *anthropicStreamTranslator) handleThinkingDelta(data []byte) []anthropic
 	return events
 }
 
-// handleToolInputDelta 处理工具调用参数增量
+// handleToolInputDelta 缓冲工具调用参数增量。
+// 不直接转发为 input_json_delta：上游模型偶尔会塞入空可选字段（如 gpt-5.5
+// 给 Read 工具加 "pages":""），逐片透传后下游会看到污染后的入参。统一在
+// closeCurrentBlock 时整段清洗后一次性下发。
 func (t *anthropicStreamTranslator) handleToolInputDelta(data []byte) []anthropicStreamEvent {
 	delta := gjson.GetBytes(data, "delta").String()
 	if delta == "" {
 		return nil
 	}
-
-	idx := t.contentBlockIndex - 1
-	return []anthropicStreamEvent{{
-		Type:  "content_block_delta",
-		Index: &idx,
-		Delta: &anthropicDelta{
-			Type:        "input_json_delta",
-			PartialJSON: delta,
-		},
-	}}
+	t.currentToolInputBuffer.WriteString(delta)
+	return nil
 }
 
 // handleContentDone 处理内容完成（文本/推理块）
@@ -844,17 +842,70 @@ func (t *anthropicStreamTranslator) handleFailed() []anthropicStreamEvent {
 	return events
 }
 
-// closeCurrentBlock 关闭当前打开的 content block
+// closeCurrentBlock 关闭当前打开的 content block。
+// 关闭 tool_use 块时会先把累积的 arguments JSON 整段清洗（删除空字符串/null
+// 的可选字段），再作为单次 input_json_delta 下发。
 func (t *anthropicStreamTranslator) closeCurrentBlock() []anthropicStreamEvent {
 	if !t.contentBlockOpen {
 		return nil
 	}
 	t.contentBlockOpen = false
 	idx := t.contentBlockIndex - 1
-	return []anthropicStreamEvent{{
+
+	var events []anthropicStreamEvent
+	if t.currentBlockType == "tool_use" && t.currentToolInputBuffer.Len() > 0 {
+		cleaned := sanitizeToolInputJSON(t.currentToolInputBuffer.String())
+		if cleaned != "" {
+			events = append(events, anthropicStreamEvent{
+				Type:  "content_block_delta",
+				Index: &idx,
+				Delta: &anthropicDelta{
+					Type:        "input_json_delta",
+					PartialJSON: cleaned,
+				},
+			})
+		}
+		t.currentToolInputBuffer.Reset()
+	}
+
+	events = append(events, anthropicStreamEvent{
 		Type:  "content_block_stop",
 		Index: &idx,
-	}}
+	})
+	return events
+}
+
+// sanitizeToolInputJSON 清洗工具调用 arguments JSON：
+// 仅删除顶层值为空字符串("")或 null 的字段。
+// 不动空对象 {} / 空数组 []（部分工具语义上允许这两者）。
+// 上游 gpt-5.5 偶尔会给 Read 工具加 "pages":""，导致 claudecode 看到的入参
+// 带上无效空字段，模型在后续轮次里反复纠结"工具层带入了空 pages"。在代理
+// 层统一清掉，比让客户端去兼容更简单。
+func sanitizeToolInputJSON(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return raw
+	}
+	var obj map[string]json.RawMessage
+	if err := json.Unmarshal([]byte(raw), &obj); err != nil {
+		return raw
+	}
+	changed := false
+	for k, v := range obj {
+		s := strings.TrimSpace(string(v))
+		if s == `""` || s == "null" {
+			delete(obj, k)
+			changed = true
+		}
+	}
+	if !changed {
+		return raw
+	}
+	out, err := json.Marshal(obj)
+	if err != nil {
+		return raw
+	}
+	return string(out)
 }
 
 // finalize 在流结束时补齐缺失的事件
@@ -948,7 +999,9 @@ func buildAnthropicResponseFromCompleted(completedData []byte, model string) *an
 			callID := fromCodexCallID(item.Get("call_id").String())
 			name := item.Get("name").String()
 			args := item.Get("arguments").String()
-			if args == "" {
+			if cleaned := sanitizeToolInputJSON(args); cleaned != "" {
+				args = cleaned
+			} else {
 				args = "{}"
 			}
 			content = append(content, anthropicContentBlock{

proxy/anthropic_test.go

@@ -129,3 +129,156 @@ func TestTranslateAnthropicToCodexDoesNotCanonicalizeDisabledModelAlias(t *testi
 		t.Fatalf("translated model = %q, want gpt5-4", out.Model)
 	}
 }
+
+func TestSanitizeToolInputJSON(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "drops empty string optional field",
+			in:   `{"file_path":"/etc/hosts","pages":""}`,
+			want: `{"file_path":"/etc/hosts"}`,
+		},
+		{
+			name: "drops null field",
+			in:   `{"file_path":"/etc/hosts","limit":null}`,
+			want: `{"file_path":"/etc/hosts"}`,
+		},
+		{
+			name: "drops multiple empties",
+			in:   `{"file_path":"/x","pages":"","limit":null,"offset":0}`,
+			want: `{"file_path":"/x","offset":0}`,
+		},
+		{
+			name: "preserves empty object",
+			in:   `{"options":{}}`,
+			want: `{"options":{}}`,
+		},
+		{
+			name: "preserves empty array",
+			in:   `{"items":[]}`,
+			want: `{"items":[]}`,
+		},
+		{
+			name: "preserves whitespace strings",
+			in:   `{"sep":" "}`,
+			want: `{"sep":" "}`,
+		},
+		{
+			name: "no-op when nothing to drop",
+			in:   `{"file_path":"/etc/hosts"}`,
+			want: `{"file_path":"/etc/hosts"}`,
+		},
+		{
+			name: "invalid JSON returned as-is",
+			in:   `{"file_path":`,
+			want: `{"file_path":`,
+		},
+		{
+			name: "empty input returned as-is",
+			in:   ``,
+			want: ``,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := sanitizeToolInputJSON(tc.in)
+			// Compare as JSON to ignore key ordering.
+			if !jsonEqual(t, got, tc.want) {
+				t.Fatalf("sanitizeToolInputJSON(%q) = %q, want equivalent to %q",
+					tc.in, got, tc.want)
+			}
+		})
+	}
+}
+
+func jsonEqual(t *testing.T, a, b string) bool {
+	t.Helper()
+	if a == b {
+		return true
+	}
+	var av, bv any
+	if err := json.Unmarshal([]byte(a), &av); err != nil {
+		return a == b
+	}
+	if err := json.Unmarshal([]byte(b), &bv); err != nil {
+		return a == b
+	}
+	ab, _ := json.Marshal(av)
+	bb, _ := json.Marshal(bv)
+	return string(ab) == string(bb)
+}
+
+// TestAnthropicStreamTranslator_ToolInputBufferedAndCleaned 模拟 gpt-5.5 把
+// "pages":"" 拆成多片 SSE 推送：translator 应缓冲到 tool_use 块关闭时再
+// 整段清洗，并以单次 input_json_delta 发出，下游收到的 JSON 不含空 pages。
+func TestAnthropicStreamTranslator_ToolInputBufferedAndCleaned(t *testing.T) {
+	tr := newAnthropicStreamTranslator("claude-sonnet-4-5")
+
+	// response.created
+	tr.translateEvent([]byte(`{"type":"response.created"}`))
+	// output_item.added — 启动 tool_use 块
+	tr.translateEvent([]byte(`{
+		"type":"response.output_item.added",
+		"output_index":0,
+		"item":{"type":"function_call","call_id":"call_abc","name":"Read"}
+	}`))
+
+	// 三片 function_call_arguments.delta，分别是开头/中段/结尾
+	deltas := []string{
+		`{"file_path":"/etc/hosts"`,
+		`,"pages":""`,
+		`}`,
+	}
+	var streamed []anthropicStreamEvent
+	for _, d := range deltas {
+		evt := []byte(`{"type":"response.function_call_arguments.delta","delta":` +
+			mustJSONString(d) + `}`)
+		streamed = append(streamed, tr.translateEvent(evt)...)
+	}
+
+	// delta 阶段不应该泄漏任何 input_json_delta
+	for _, evt := range streamed {
+		if evt.Type == "content_block_delta" {
+			t.Fatalf("expected no content_block_delta during streaming, got %+v", evt)
+		}
+	}
+
+	// output_item.done 触发 closeCurrentBlock，整段清洗
+	closing := tr.translateEvent([]byte(`{"type":"response.output_item.done"}`))
+
+	var sawDelta bool
+	var sawStop bool
+	for _, evt := range closing {
+		if evt.Type == "content_block_delta" {
+			sawDelta = true
+			if evt.Delta == nil || evt.Delta.Type != "input_json_delta" {
+				t.Fatalf("expected input_json_delta, got %+v", evt.Delta)
+			}
+			want := `{"file_path":"/etc/hosts"}`
+			if !jsonEqual(t, evt.Delta.PartialJSON, want) {
+				t.Fatalf("cleaned tool input = %q, want equivalent to %q",
+					evt.Delta.PartialJSON, want)
+			}
+		}
+		if evt.Type == "content_block_stop" {
+			sawStop = true
+		}
+	}
+	if !sawDelta {
+		t.Fatalf("expected one content_block_delta with cleaned input on close")
+	}
+	if !sawStop {
+		t.Fatalf("expected content_block_stop on close")
+	}
+}
+
+func mustJSONString(s string) string {
+	b, err := json.Marshal(s)
+	if err != nil {
+		panic(err)
+	}
+	return string(b)
+}