revert(anthropic): drop the streamed tool-argument validation, keep the rest

lidge-jun · lidge-jun · commit 95d8ed77fd7c · 2026-07-31T11:13:35.000+09:00
Two attempts at making the streaming path agree with the non-stream path about malformed tool arguments, both rejected by review for a real reason. Stopping at the third rather than pushing another patch at the same spot. Attempt one buffered `input_json_delta` fragments and validated at block close. That broke the streaming contract: `src/bridge.ts:628` turns each adapter delta into a client-visible `response.function_call_arguments.delta` frame, and `tests/responses-stream-tool-events.test.ts:30` pins that split fragments stay split. A started call would show empty arguments until block close. Attempt two kept fragments flowing and errored the turn when the assembled JSON did not parse. Also wrong: the bridge's `error` case closes an open tool call anyway (`src/bridge.ts:771`), emitting `response.function_call_arguments.done` and an `output_item.done` with `status:"completed"` BEFORE `response.failed`. The client is still told the call completed. The fix belongs in the bridge -- a terminal error mode that cancels rather than closes an open tool call. That is out of scope for an Anthropic adapter PR, affects every adapter's error path, and touches code whose comment records that `JSON.parse("")` once poisoned whole sessions. It deserves its own cycle with that history read first, not a third patch from this end. Kept, because both stand on their own: the non-stream `toolUseArguments` degradation to `{}`, which fixes the half of #765 that is actually fixable here, and the EOF stop-reason regression test that exposed the two existing EOF tests as vacuous. Reverted: every streaming-path change. That path now behaves exactly as it did before this round, so nothing regressed -- the known defect is simply still there, and #765 stays open for it. Reasoning recorded in devlog/_plan/260731_pr_merge_round/021.
diff --git a/devlog/_plan/260731_pr_merge_round/021_stream_tool_argument_validation.md b/devlog/_plan/260731_pr_merge_round/021_stream_tool_argument_validation.md
@@ -0,0 +1,63 @@
+# 021 — 스트림 tool 인자 검증을 이번 라운드에서 뺀 이유
+
+#765를 태우면서 파생된 문제 하나를 세 번 고치려다 실패했다. 세 번째에서
+멈추고 되돌렸다. 기록으로 남긴다 — 다음 사람이 같은 길을 다시 걷지 않도록.
+
+## 발단
+
+`toolUseArguments()`가 파싱 불가능한 문자열 input을 JSON **문자열**로 재인코딩했다
+(`src/adapters/anthropic.ts:269`). tool 계약은 객체를 요구하므로
+`"not json at all"`이 그대로 전달된다. #765가 보고한 이중 인코딩이다.
+`{}`로 떨어뜨리는 것으로 고쳤고, 이건 남아 있다.
+
+그런데 리뷰어가 짚었다: **스트리밍 경로는 그대로다.** `input_json_delta`의
+`partial_json`을 그대로 흘려보내므로(`:836`) 같은 깨진 페이로드가
+`parseResponse`로는 `{}`, `parseStream`으로는 `"not json"`이 된다. 한 결함에
+두 답.
+
+## 세 번의 시도
+
+**1차 — 조각을 버퍼링해서 블록 종료 시 검증.** 두 경로가 같은 헬퍼를 타게 만들었다.
+리뷰어가 거부: `src/bridge.ts:628`이 어댑터 delta 하나하나를 클라이언트가 보는
+`response.function_call_arguments.delta` 프레임으로 바꾼다. 조각을 붙들면
+시작된 함수 호출이 블록이 끝날 때까지 빈 인자로 보인다.
+`tests/responses-stream-tool-events.test.ts:30`이 쪼개진 프레임 유지를 고정하고 있다.
+일관성을 얻으려고 프로토콜을 깬 것이다.
+
+**2차 — 증분 전달은 유지하고, 조립본이 파싱 안 되면 턴을 에러로.** 계약은 복구됐다.
+리뷰어가 다시 거부: 어댑터가 `tool_call_end` 없이 `error`를 내도
+`src/bridge.ts:771`의 error 케이스가 열린 tool call을 닫는다.
+`closeCurrentToolCall()`이 `response.function_call_arguments.done`과
+`status:"completed"`인 `response.output_item.done`을 `response.failed` **앞에**
+내보낸다. 즉 클라이언트는 여전히 "완료된 호출"을 본다.
+
+**3차 — 없음.** 여기서 멈췄다.
+
+## 왜 멈췄나
+
+실제 수정 지점이 `src/bridge.ts`다. 열린 tool call을 닫지 말고 취소하는
+터미널 에러 모드를 새로 만들어야 하는데, 그건:
+
+- 이 PR(#765, Anthropic 어댑터)의 범위 밖이다.
+- 모든 어댑터의 error 경로에 영향을 준다. Anthropic만의 문제가 아니다.
+- Codex가 다음 턴에 호출을 돌려보낼 때의 동작을 바꾼다.
+  `closeCurrentToolCall()`의 주석이 왜 빈 인자를 `"{}"`로 직렬화하는지 설명한다 —
+  `JSON.parse("")`가 세션 전체를 400으로 오염시킨 이력이 있다. 이 경로는
+  건드리기 전에 그 이력을 먼저 이해해야 한다.
+
+같은 결함을 두 번 연속 고치지 못했으면 패치를 멈추고 근본 원인으로 가라는 게
+규칙이다. 세 번째는 계획을 바꾸는 자리지 세 번째 패치를 미는 자리가 아니다.
+
+## 지금 상태
+
+- **유지**: non-stream `toolUseArguments` → `{}` 수정과 그 테스트.
+  독립적으로 옳고, #765가 보고한 절반을 실제로 고친다.
+- **유지**: EOF stop-reason 회귀 테스트. 기존 EOF 테스트 둘 다 stop reason을
+  안 보내서 fallback을 되돌려도 통과한다 — 무력한 테스트였다. 새 테스트는
+  fallback을 끄면 실패한다(14 pass / 1 fail 확인).
+- **되돌림**: 스트리밍 경로 변경 전부. 지금 동작은 이 라운드 이전과 같다.
+
+**남은 결함**: 스트리밍 경로는 여전히 깨진 `partial_json`을 그대로 흘린다.
+#765는 그래서 열어둔다. 다음 사이클의 단위는 "Anthropic 어댑터"가 아니라
+**"bridge의 터미널 에러가 열린 tool call을 어떻게 처리해야 하는가"**다.
+어댑터부터 손대면 또 같은 벽에 부딪힌다.
diff --git a/src/adapters/anthropic.ts b/src/adapters/anthropic.ts
@@ -284,23 +284,6 @@ function toolUseArguments(input: unknown): string {
   return JSON.stringify(input ?? {});
 }
 
-/**
- * Whether the arguments assembled from a stream's `input_json_delta` fragments are usable.
- * A tool block that sent no fragments at all is fine -- that is a no-argument call. Anything
- * else has to parse, because unlike the non-stream path the fragments have already been
- * forwarded to the client and cannot be repaired after the fact.
- */
-function streamedToolArgumentsParse(assembled: string): boolean {
-  const trimmed = assembled.trim();
-  if (!trimmed) return true;
-  try {
-    JSON.parse(trimmed);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 function anthropicKeyUsesBearer(provider: OcxProviderConfig): boolean {
   return provider.apiKeyTransport === "bearer";
 }
@@ -782,7 +765,6 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
       let currentBlockType = "";
       let currentToolCallId = "";
       let currentToolCallName = "";
-      let currentToolCallJson = "";
       let pendingUsage: Record<string, number> | undefined;
       let pendingStopReason: string | undefined;
       let emittedDone = false;
@@ -826,7 +808,6 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                 if (block.type === "tool_use") {
                   currentToolCallId = block.id ?? synthesizeToolUseId();
                   currentToolCallName = toolNames.fromWire(block.name ?? "");
-                  currentToolCallJson = "";
                   yield { type: "tool_call_start", id: currentToolCallId, name: currentToolCallName };
                 }
                 if (block.type === "redacted_thinking" && typeof block.data === "string") {
@@ -852,31 +833,14 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   // so a stray signature on a non-thinking block can never be captured.
                   yield { type: "thinking_signature", signature: delta.signature };
                 } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string" && currentBlockType === "tool_use") {
-                  // Forwarded immediately: the bridge maps each delta to a client-visible
-                  // response.function_call_arguments.delta frame, so withholding fragments until
-                  // block close would leave a started call showing empty arguments. A copy is kept
-                  // to validate the assembled payload at content_block_stop.
-                  currentToolCallJson += delta.partial_json;
                   yield { type: "tool_call_delta", arguments: delta.partial_json };
                 }
                 break;
               }
               case "content_block_stop": {
                 if (currentBlockType === "tool_use") {
-                  // The non-stream path repairs an unparseable payload in toolUseArguments(); the
-                  // stream cannot, because the fragments are already downstream. Fail the turn
-                  // instead of ending a tool call whose arguments will not parse -- a client that
-                  // received `not json` must not be told the call completed normally.
-                  if (!streamedToolArgumentsParse(currentToolCallJson)) {
-                    yield {
-                      type: "error",
-                      message: "Anthropic stream sent malformed tool_use arguments (invalid JSON)",
-                    };
-                    return;
-                  }
                   yield { type: "tool_call_end" };
                   currentToolCallId = "";
-                  currentToolCallJson = "";
                 }
                 currentBlockType = "";
                 break;
diff --git a/tests/anthropic-stream-hardening.test.ts b/tests/anthropic-stream-hardening.test.ts
@@ -104,102 +104,11 @@ describe("anthropic non-stream tool_use input", () => {
     });
   });
 
-  test("malformed streamed tool arguments fail the turn instead of completing the call", async () => {
-    // The stream forwards fragments as they arrive (the bridge turns each into a client-visible
-    // frame), so a malformed payload cannot be repaired the way the non-stream path repairs it.
-    // It must not end the call normally either: a client that already received `not json` would
-    // be told the tool call completed. The turn errors instead.
-    const response = new Response([
-      "event: content_block_start\n",
-      'data: {"type":"content_block_start","content_block":{"type":"tool_use","id":"toolu_9","name":"get_weather"}}\n\n',
-      "event: content_block_delta\n",
-      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"not "}}\n\n',
-      "event: content_block_delta\n",
-      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"json"}}\n\n',
-      "event: content_block_stop\n",
-      'data: {"type":"content_block_stop"}\n\n',
-      "event: message_stop\n",
-      'data: {"type":"message_stop"}\n\n',
-    ].join(""));
-    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
-    expect(events.at(-1)?.type).toBe("error");
-    expect(events.some(e => e.type === "tool_call_end")).toBe(false);
-    expect(events.some(e => e.type === "done")).toBe(false);
-  });
-
-  test("valid streamed tool arguments still arrive as incremental deltas", async () => {
-    // The bridge maps each adapter delta to response.function_call_arguments.delta, so the
-    // fragments must keep flowing as they arrive rather than being withheld until block close.
-    // Both fragments, in order, and the call ends normally.
-    const response = new Response([
-      "event: content_block_start\n",
-      'data: {"type":"content_block_start","content_block":{"type":"tool_use","id":"toolu_10","name":"get_weather"}}\n\n',
-      "event: content_block_delta\n",
-      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"{\\"city\\":"}}\n\n',
-      "event: content_block_delta\n",
-      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"\\"Paris\\"}"}}\n\n',
-      "event: content_block_stop\n",
-      'data: {"type":"content_block_stop"}\n\n',
-      "event: message_stop\n",
-      'data: {"type":"message_stop"}\n\n',
-    ].join(""));
-    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
-    expect(events.filter(e => e.type === "tool_call_delta")).toMatchObject([
-      { type: "tool_call_delta", arguments: '{"city":' },
-      { type: "tool_call_delta", arguments: '"Paris"}' },
-    ]);
-    expect(events.some(e => e.type === "tool_call_end")).toBe(true);
-    expect(events.at(-1)?.type).toBe("done");
-  });
-
-  test("two tool_use blocks in one message keep separate argument buffers", async () => {
-    // The validation buffer is per block; a leak would make the second block inherit the first
-    // block's JSON and could fail a well-formed call.
-    const response = new Response([
-      "event: content_block_start\n",
-      'data: {"type":"content_block_start","content_block":{"type":"tool_use","id":"toolu_a","name":"one"}}\n\n',
-      "event: content_block_delta\n",
-      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"{\\"one\\":1}"}}\n\n',
-      "event: content_block_stop\n",
-      'data: {"type":"content_block_stop"}\n\n',
-      "event: content_block_start\n",
-      'data: {"type":"content_block_start","content_block":{"type":"tool_use","id":"toolu_b","name":"two"}}\n\n',
-      "event: content_block_delta\n",
-      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"{\\"two\\":2}"}}\n\n',
-      "event: content_block_stop\n",
-      'data: {"type":"content_block_stop"}\n\n',
-      "event: message_stop\n",
-      'data: {"type":"message_stop"}\n\n',
-    ].join(""));
-    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
-    expect(events.filter(e => e.type === "tool_call_delta")).toMatchObject([
-      { type: "tool_call_delta", arguments: '{"one":1}' },
-      { type: "tool_call_delta", arguments: '{"two":2}' },
-    ]);
-    expect(events.filter(e => e.type === "tool_call_end")).toHaveLength(2);
-    expect(events.at(-1)?.type).toBe("done");
-  });
-
-  test("a tool_use block with no argument fragments is not treated as malformed", async () => {
-    // A no-argument tool call sends no input_json_delta at all. An empty buffer must stay valid.
-    const response = new Response([
-      "event: content_block_start\n",
-      'data: {"type":"content_block_start","content_block":{"type":"tool_use","id":"toolu_c","name":"now"}}\n\n',
-      "event: content_block_stop\n",
-      'data: {"type":"content_block_stop"}\n\n',
-      "event: message_stop\n",
-      'data: {"type":"message_stop"}\n\n',
-    ].join(""));
-    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
-    expect(events.some(e => e.type === "error")).toBe(false);
-    expect(events.some(e => e.type === "tool_call_end")).toBe(true);
-    expect(events.at(-1)?.type).toBe("done");
-  });
-
   test("EOF after message_delta.stop_reason settles instead of erroring", async () => {
-    // The blocker the other EOF tests could not see: they assert the pre-existing error path, so
-    // reverting the stop-reason fallback leaves them green. This drives the fallback itself -- a
-    // stream that reported why it stopped but never sent message_stop.
+    // The other two EOF tests assert the pre-existing error path and never send a stop reason,
+    // so they stay green with this fallback reverted -- they do not test the change they shipped
+    // with. This drives the fallback itself: a stream that reported why it stopped but never
+    // sent message_stop.
     const response = new Response([
       "event: content_block_start\n",
       'data: {"type":"content_block_start","content_block":{"type":"text","text":""}}\n\n',
