fix(anthropic): preserve unsafe integer tool inputs (#83063)

leno23 · amknight · web-flow · commit e399a92e6cc9 · 2026-05-22T13:48:38.000+10:00
* fix(anthropic): preserve unsafe integer tool inputs Fixes #47229 * docs: add Anthropic unsafe integer changelog * fix: narrow Anthropic partial JSON type --------- Co-authored-by: Alex Knight <aknight@atlassian.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -24,6 +24,7 @@ Docs: https://docs.openclaw.ai
 
 ### Fixes
 
+- Agents/Anthropic: preserve unsafe integer tool-call input values in streamed Anthropic tool-use JSON, preventing Discord-style IDs from being rounded before dispatch. Fixes #47229. (#83063) Thanks @leno23.
 - CLI/agents: allow `openclaw agent --session-key` to target explicit session keys, including agent-scoped legacy keys. (#85121) Thanks @Kaspre.
 - Auto-reply/ACP: wait for same-channel block reply delivery before starting tool work, while still honoring ACP dispatch aborts so stopped turns do not wait on slow channel sends. (#83722) Thanks @IWhatsskill.
 - Codex/ACP: mark required child-run completions that only report progress, omit a final deliverable, or fail requester delivery as blocked while preserving real final reports. (#85110) Thanks @IWhatsskill.
diff --git a/src/agents/anthropic-transport-stream.test.ts b/src/agents/anthropic-transport-stream.test.ts
@@ -416,6 +416,63 @@ describe("anthropic transport stream", () => {
     expect(result.errorMessage).toBe("OpenClaw transport error: malformed_streaming_fragment");
   });
 
+  it("preserves unsafe integer Anthropic tool-use input deltas", async () => {
+    guardedFetchMock.mockResolvedValueOnce(
+      createSseResponse([
+        {
+          type: "message_start",
+          message: { id: "msg_unsafe", usage: { input_tokens: 10, output_tokens: 0 } },
+        },
+        {
+          type: "content_block_start",
+          index: 0,
+          content_block: {
+            type: "tool_use",
+            id: "tool_unsafe",
+            name: "send_message",
+            input: {},
+          },
+        },
+        {
+          type: "content_block_delta",
+          index: 0,
+          delta: {
+            type: "input_json_delta",
+            partial_json:
+              '{"to":1481220477346119781,"safe":42,"maxSafe":9007199254740991,"nested":{"ids":[9007199254740993,-9007199254740992]}}',
+          },
+        },
+        { type: "content_block_stop", index: 0 },
+        {
+          type: "message_delta",
+          delta: { stop_reason: "tool_use" },
+          usage: { input_tokens: 10, output_tokens: 5 },
+        },
+      ]),
+    );
+
+    const result = await runTransportStream(
+      makeAnthropicTransportModel(),
+      {
+        messages: [{ role: "user", content: "message this channel" }],
+      } as AnthropicStreamContext,
+      {
+        apiKey: "sk-ant-api",
+      } as AnthropicStreamOptions,
+    );
+
+    const toolCall = findRecord(
+      result.content,
+      (record) => record.type === "toolCall" && record.name === "send_message",
+    );
+    expect(toolCall.arguments).toEqual({
+      to: "1481220477346119781",
+      safe: 42,
+      maxSafe: 9007199254740991,
+      nested: { ids: ["9007199254740993", "-9007199254740992"] },
+    });
+  });
+
   it("preserves Anthropic OAuth identity and tool-name remapping with transport overrides", async () => {
     guardedFetchMock.mockResolvedValueOnce(
       createSseResponse([
diff --git a/src/agents/anthropic-transport-stream.ts b/src/agents/anthropic-transport-stream.ts
@@ -16,6 +16,7 @@ import {
   resolveAnthropicPayloadPolicy,
 } from "./anthropic-payload-policy.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./copilot-dynamic-headers.js";
+import { parseJsonObjectPreservingUnsafeIntegers } from "./json-unsafe-integers.js";
 import { resolveProviderEndpoint } from "./provider-attribution.js";
 import { buildGuardedModelFetch } from "./provider-transport-fetch.js";
 import { transformTransportMessages } from "./transport-message-transform.js";
@@ -497,6 +498,10 @@ function convertAnthropicTools(tools: Context["tools"], isOAuthToken: boolean) {
   return converted;
 }
 
+function parseAnthropicToolCallArguments(inputJson: string): unknown {
+  return parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson);
+}
+
 function mapStopReason(reason: string | undefined): string {
   switch (reason) {
     case "end_turn":
@@ -1267,8 +1272,9 @@ export function createAnthropicMessagesTransportStreamFn(): StreamFn {
               delta?.type === "input_json_delta" &&
               typeof delta.partial_json === "string"
             ) {
-              block.partialJson += delta.partial_json;
-              block.arguments = parseStreamingJson(block.partialJson);
+              const partialJson = `${block.partialJson ?? ""}${delta.partial_json}`;
+              block.partialJson = partialJson;
+              block.arguments = parseAnthropicToolCallArguments(partialJson);
               stream.push({
                 type: "toolcall_delta",
                 contentIndex: index,
@@ -1316,7 +1322,7 @@ export function createAnthropicMessagesTransportStreamFn(): StreamFn {
             }
             if (block.type === "toolCall") {
               if (typeof block.partialJson === "string" && block.partialJson.length > 0) {
-                block.arguments = parseStreamingJson(block.partialJson);
+                block.arguments = parseAnthropicToolCallArguments(block.partialJson);
               }
               delete block.partialJson;
               stream.push({
diff --git a/src/agents/json-unsafe-integers.ts b/src/agents/json-unsafe-integers.ts
@@ -0,0 +1,143 @@
+const MAX_SAFE_INTEGER_ABS_STR = String(Number.MAX_SAFE_INTEGER);
+
+function isAsciiDigit(ch: string | undefined): boolean {
+  return ch !== undefined && ch >= "0" && ch <= "9";
+}
+
+function parseJsonNumberToken(
+  input: string,
+  start: number,
+): { token: string; end: number; isInteger: boolean } | null {
+  let idx = start;
+  if (input[idx] === "-") {
+    idx += 1;
+  }
+  if (idx >= input.length) {
+    return null;
+  }
+
+  if (input[idx] === "0") {
+    idx += 1;
+  } else if (isAsciiDigit(input[idx]) && input[idx] !== "0") {
+    while (isAsciiDigit(input[idx])) {
+      idx += 1;
+    }
+  } else {
+    return null;
+  }
+
+  let isInteger = true;
+  if (input[idx] === ".") {
+    isInteger = false;
+    idx += 1;
+    if (!isAsciiDigit(input[idx])) {
+      return null;
+    }
+    while (isAsciiDigit(input[idx])) {
+      idx += 1;
+    }
+  }
+
+  if (input[idx] === "e" || input[idx] === "E") {
+    isInteger = false;
+    idx += 1;
+    if (input[idx] === "+" || input[idx] === "-") {
+      idx += 1;
+    }
+    if (!isAsciiDigit(input[idx])) {
+      return null;
+    }
+    while (isAsciiDigit(input[idx])) {
+      idx += 1;
+    }
+  }
+
+  return {
+    token: input.slice(start, idx),
+    end: idx,
+    isInteger,
+  };
+}
+
+function isUnsafeIntegerLiteral(token: string): boolean {
+  const digits = token[0] === "-" ? token.slice(1) : token;
+  if (digits.length < MAX_SAFE_INTEGER_ABS_STR.length) {
+    return false;
+  }
+  if (digits.length > MAX_SAFE_INTEGER_ABS_STR.length) {
+    return true;
+  }
+  return digits > MAX_SAFE_INTEGER_ABS_STR;
+}
+
+export function quoteUnsafeIntegerLiterals(input: string): string {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  let idx = 0;
+
+  while (idx < input.length) {
+    const ch = input[idx] ?? "";
+    if (inString) {
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      idx += 1;
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      idx += 1;
+      continue;
+    }
+
+    if (ch === "-" || isAsciiDigit(ch)) {
+      const parsed = parseJsonNumberToken(input, idx);
+      if (parsed) {
+        if (parsed.isInteger && isUnsafeIntegerLiteral(parsed.token)) {
+          out += `"${parsed.token}"`;
+        } else {
+          out += parsed.token;
+        }
+        idx = parsed.end;
+        continue;
+      }
+    }
+
+    out += ch;
+    idx += 1;
+  }
+
+  return out;
+}
+
+export function parseJsonPreservingUnsafeIntegers(input: string): unknown {
+  return JSON.parse(quoteUnsafeIntegerLiterals(input)) as unknown;
+}
+
+export function parseJsonObjectPreservingUnsafeIntegers(
+  value: unknown,
+): Record<string, unknown> | null {
+  if (typeof value === "string") {
+    try {
+      const parsed = parseJsonPreservingUnsafeIntegers(value);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return null;
+}
