test(provider): cover Bedrock and scanner edge cases for tool argument repair

commit: 145189ecc9773205fd6d04781126176d389a0312
author: brice · 20d ago · 2026-10-02 04:46 UTC
committer: brice · 20d ago · 2026-10-02 07:44 UTC
parent: 3aa968f
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

1 file · +37 -11

M packages/provider/tool_args_test.go +37 -11

@@ -1,7 +1,9 @@
1	1		package provider
2	2
3	3		import (
	4	+	"bytes"
4	5		"context"
	6	+	"encoding/binary"
5	7		"encoding/json"
6	8		"io"
7	9		"net/http"

@@ -23,6 +25,8 @@ func TestNormalizeToolArgs(t *testing.T) {
23	25		{name: "other control char", in: `{"s":"` + bell + `"}`, want: `{"s":"\u0007"}`},
24	26		{name: "whitespace outside strings untouched", in: "{" + nl + tab + `"s":"` + tab + `"}`, want: "{" + nl + tab + `"s":"\t"}`},
25	27		{name: "escaped quote keeps string state", in: `{"s":"\"` + tab + `"}`, want: `{"s":"\"\t"}`},
	28	+	{name: "escaped backslash closes string", in: `{"a":"x\\"` + tab + `}`, want: `{"a":"x\\"` + tab + `}`},
	29	+	{name: "multibyte utf-8 kept", in: `{"a":"é` + tab + `"}`, want: `{"a":"é\t"}`},
26	30		{name: "unrepairable", in: `{"s":`, want: `{}`},
27	31		}
28	32		for _, tt := range tests {

@@ -38,15 +42,6 @@ func TestNormalizeToolArgs(t *testing.T) {
38	42		}
39	43		}
40	44
41		-	func TestNormalizedToolArgsKeepMessageSerializable(t *testing.T) {
42		-	msg := Message{Role: RoleAssistant, Content: []Content{ToolCallBlock{
43		-	ID: "call-1", Name: "edit", Arguments: normalizeToolArgs(`{"old":"` + string(rune(9)) + `x"}`),
44		-	}}}
45		-	if _, err := json.Marshal(msg); err != nil {
46		-	t.Fatalf("marshal message: %v", err)
47		-	}
48		-	}
49		-
50	45		func TestAnthropicStreamRepairsRawTabInToolArgs(t *testing.T) {
51	46		// partial_json is a JSON string carrying the model's raw argument text;
52	47		// "\\t" below decodes to a real tab byte inside the argument string.

@@ -57,12 +52,43 @@ func TestAnthropicStreamRepairsRawTabInToolArgs(t *testing.T) {
57	52		resp := &http.Response{Body: io.NopCloser(strings.NewReader(body))}
58	53		out := make(chan Event, 16)
59	54		go (&anthropicClient{}).runStream(context.Background(), resp, Request{Model: "test"}, out)
	55	+	assertToolArgOld(t, out, "\tx")
	56	+	}
	57	+
	58	+	func TestBedrockStreamRepairsRawTabInToolArgs(t *testing.T) {
	59	+	// Header-less event-stream frames; the reader takes the event type from
	60	+	// the wrapped payload and does not validate CRCs. The `\t` escape in the input
	61	+	// field decodes to a real tab byte inside the argument string.
	62	+	var body bytes.Buffer
	63	+	for _, payload := range []string{
	64	+	`{"contentBlockStart":{"contentBlockIndex":0,"start":{"toolUse":{"toolUseId":"call-1","name":"edit"}}}}`,
	65	+	`{"contentBlockDelta":{"contentBlockIndex":0,"delta":{"toolUse":{"input":"{\"old\":\"\tx\"}"}}}}`,
	66	+	`{"contentBlockStop":{"contentBlockIndex":0}}`,
	67	+	`{"messageStop":{"stopReason":"tool_use"}}`,
	68	+	} {
	69	+	var prelude [12]byte
	70	+	binary.BigEndian.PutUint32(prelude[0:4], uint32(16+len(payload)))
	71	+	body.Write(prelude[:])
	72	+	body.WriteString(payload)
	73	+	body.Write(make([]byte, 4))
	74	+	}
	75	+	resp := &http.Response{Body: io.NopCloser(&body)}
	76	+	out := make(chan Event, 16)
	77	+	go (&bedrockClient{}).runStream(context.Background(), resp, Request{Model: "test"}, out)
	78	+	assertToolArgOld(t, out, "\tx")
	79	+	}
	80	+
	81	+	func assertToolArgOld(t *testing.T, out <-chan Event, want string) {
	82	+	t.Helper()
60	83		var done EventDone
61	84		for ev := range out {
62	85		if d, ok := ev.(EventDone); ok {
63	86		done = d
64	87		}
65	88		}
	89	+	if done.Err != nil {
	90	+	t.Fatalf("stream error: %v", done.Err)
	91	+	}
66	92		if len(done.Message.Content) != 1 {
67	93		t.Fatalf("content = %#v, want one tool call", done.Message.Content)
68	94		}

@@ -74,7 +100,7 @@ func TestAnthropicStreamRepairsRawTabInToolArgs(t *testing.T) {
74	100		if err := json.Unmarshal(tc.Arguments, &args); err != nil {
75	101		t.Fatalf("arguments %q not valid JSON: %v", tc.Arguments, err)
76	102		}
77		-	if args.Old != "\tx" {
78		-	t.Fatalf("old = %q, want tab preserved", args.Old)
	103	+	if args.Old != want {
	104	+	t.Fatalf("old = %q, want %q", args.Old, want)
79	105		}
80	106		}

 package provider
 import (
+	"bytes"
 	"context"
+	"encoding/binary"
 	"encoding/json"
 	"io"
 	"net/http"
 		{name: "other control char", in: `{"s":"` + bell + `"}`, want: `{"s":"\u0007"}`},
 		{name: "whitespace outside strings untouched", in: "{" + nl + tab + `"s":"` + tab + `"}`, want: "{" + nl + tab + `"s":"\t"}`},
 		{name: "escaped quote keeps string state", in: `{"s":"\"` + tab + `"}`, want: `{"s":"\"\t"}`},
+		{name: "escaped backslash closes string", in: `{"a":"x\\"` + tab + `}`, want: `{"a":"x\\"` + tab + `}`},
+		{name: "multibyte utf-8 kept", in: `{"a":"é` + tab + `"}`, want: `{"a":"é\t"}`},
 		{name: "unrepairable", in: `{"s":`, want: `{}`},
 	}
 	for _, tt := range tests {
 	}
 }
-func TestNormalizedToolArgsKeepMessageSerializable(t *testing.T) {
-	msg := Message{Role: RoleAssistant, Content: []Content{ToolCallBlock{
-		ID: "call-1", Name: "edit", Arguments: normalizeToolArgs(`{"old":"` + string(rune(9)) + `x"}`),
-	}}}
-	if _, err := json.Marshal(msg); err != nil {
-		t.Fatalf("marshal message: %v", err)
-	}
-}
 func TestAnthropicStreamRepairsRawTabInToolArgs(t *testing.T) {
 	// partial_json is a JSON string carrying the model's raw argument text;
 	// "\\t" below decodes to a real tab byte inside the argument string.
 	resp := &http.Response{Body: io.NopCloser(strings.NewReader(body))}
 	out := make(chan Event, 16)
 	go (&anthropicClient{}).runStream(context.Background(), resp, Request{Model: "test"}, out)
+	assertToolArgOld(t, out, "\tx")
+}
+func TestBedrockStreamRepairsRawTabInToolArgs(t *testing.T) {
+	// Header-less event-stream frames; the reader takes the event type from
+	// the wrapped payload and does not validate CRCs. The `\t` escape in the input
+	// field decodes to a real tab byte inside the argument string.
+	var body bytes.Buffer
+	for _, payload := range []string{
+		`{"contentBlockStart":{"contentBlockIndex":0,"start":{"toolUse":{"toolUseId":"call-1","name":"edit"}}}}`,
+		`{"contentBlockDelta":{"contentBlockIndex":0,"delta":{"toolUse":{"input":"{\"old\":\"\tx\"}"}}}}`,
+		`{"contentBlockStop":{"contentBlockIndex":0}}`,
+		`{"messageStop":{"stopReason":"tool_use"}}`,
+	} {
+		var prelude [12]byte
+		binary.BigEndian.PutUint32(prelude[0:4], uint32(16+len(payload)))
+		body.Write(prelude[:])
+		body.WriteString(payload)
+		body.Write(make([]byte, 4))
+	}
+	resp := &http.Response{Body: io.NopCloser(&body)}
+	out := make(chan Event, 16)
+	go (&bedrockClient{}).runStream(context.Background(), resp, Request{Model: "test"}, out)
+	assertToolArgOld(t, out, "\tx")
+}
+func assertToolArgOld(t *testing.T, out <-chan Event, want string) {
+	t.Helper()
 	var done EventDone
 	for ev := range out {
 		if d, ok := ev.(EventDone); ok {
 			done = d
 		}
 	}
+	if done.Err != nil {
+		t.Fatalf("stream error: %v", done.Err)
+	}
 	if len(done.Message.Content) != 1 {
 		t.Fatalf("content = %#v, want one tool call", done.Message.Content)
 	}
 	if err := json.Unmarshal(tc.Arguments, &args); err != nil {
 		t.Fatalf("arguments %q not valid JSON: %v", tc.Arguments, err)
 	}
-	if args.Old != "\tx" {
+	if args.Old != want {
-		t.Fatalf("old = %q, want tab preserved", args.Old)
+		t.Fatalf("old = %q, want %q", args.Old, want)
 	}
 }