工具参数解析时大整数精度丢失（业务 ID 被舍入）——修复补丁

[yellowzhou]

问题

模型输出的工具调用参数里，超出 Number.MAX_SAFE_INTEGER 的大整数（如各类业务 ID）在 JSON.parse 后精度丢失。

使用 Qwen3.6-35B-A3B-FP8 可稳定复现该问题。

复现：给模型的输入包含

用户 ID: 900719925474099123
订单 ID: 1234567890123456789
类别 ID: b3f1c9d24e7a4f0e9c1a2b3c4d5e6f70

模型输出：

{
  "user_id": 900719925474099123,
  "order_id": 1234567890123456789,
  "category_id": "b3f1c9d24e7a4f0e9c1a2b3c4d5e6f70"
}

parseArguments 里 JSON.parse 之后变成 900719925474099100、1234567890123456800，最终下发到请求头/参数即为错误值。

原因

packages/core/agent-loop/src/tool-calls.ts 的 parseArguments 直接 JSON.parse(raw)，19 位整数被双精度浮点表示后四舍五入；另外模型把声明为 string 的 ID 字段写成数字时，也没有按 schema 还原类型。

修复

1. packages/core/agent-loop/src/tool-calls.ts

parseArguments 改为接收工具声明的 parameters schema，先给超限整数字面量加引号再解析，随后按 schema 强转类型：

/**
 * Parse model arguments against the tool's declared parameter schema,
 * preserving invalid JSON as text and mapping empty input to `{}`. Integer
 * literals beyond the safe-integer range survive verbatim, and numeric values
 * are coerced to the string form their field declares.
 */
function parseArguments(raw: string, parameters: Record<string, unknown> | undefined): unknown {
  if (!raw) return {}
  try {
    return coerceToSchema(JSON.parse(quoteUnsafeIntegers(raw)), parameters)
  } catch {
    return raw
  }
}

/** Matches one JSON string literal or number token, in order of appearance. */
const JSON_STRING_OR_NUMBER = /"(?:[^"\\]|\\.)*"|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/g

/** The largest magnitude every double represents as an exact integer, as digits. */
const MAX_SAFE_INTEGER_DIGITS = String(Number.MAX_SAFE_INTEGER)

/**
 * Quote integer literals beyond the safe-integer range before `JSON.parse`
 * rounds them, so their digits survive verbatim (e.g. a 19-digit tenant id).
 */
function quoteUnsafeIntegers(raw: string): string {
  let out = ''
  let last = 0
  let match: RegExpExecArray | null
  while ((match = JSON_STRING_OR_NUMBER.exec(raw)) !== null) {
    const token = match[0]
    out += raw.slice(last, match.index)
    if (!token.startsWith('"') && isUnsafeIntegerLiteral(token)) out += `"${token}"`
    else out += token
    last = match.index + token.length
  }
  return out + raw.slice(last)
}

/** Whether an integer literal's magnitude exceeds the safe-integer range. */
function isUnsafeIntegerLiteral(token: string): boolean {
  const digits = token.startsWith('-') ? token.slice(1) : token
  return digits.length > MAX_SAFE_INTEGER_DIGITS.length
    || (digits.length === MAX_SAFE_INTEGER_DIGITS.length && digits > MAX_SAFE_INTEGER_DIGITS)
}

/**
 * Coerce parsed values toward the tool's declared parameter types: a
 * `string`-typed field receives the string form of a numeric value, so an id
 * the model emitted as a number keeps its declared type.
 */
function coerceToSchema(value: unknown, schema: Record<string, unknown> | undefined): unknown {
  if (schema === undefined) return value
  if (schema.type === 'string' && typeof value === 'number') return String(value)
  if (Array.isArray(value)) {
    const items = schema.items
    return items === undefined ? value : value.map(item => coerceToSchema(item, items as Record<string, unknown>))
  }
  if (typeof value === 'object' && value !== null) {
    const record = value as Record<string, unknown>
    const properties = schema.properties
    if (properties !== undefined) {
      for (const key of Object.keys(record)) {
        const child = (properties as Record<string, unknown>)[key]
        if (child !== undefined) record[key] = coerceToSchema(record[key], child as Record<string, unknown>)
      }
    }
    return record
  }
  return value
}

调用点同步传入 schema：

-      arguments: parseArguments(block.arguments),
+      arguments: parseArguments(block.arguments, ctx.tools.get(block.name)?.parameters),

2. packages/client/ui-trajectory/src/client/TrajectoryTable.tsx

轨迹表格展示 Payload 时同样走了 JSON.parse，大整数 ID 会显示成舍入后的值。这里复用同一套 token 扫描逻辑，只对展示解析生效：

/** Matches one JSON string literal or number token, in order of appearance. */
const JSON_STRING_OR_NUMBER = /"(?:[^"\\]|\\.)*"|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/g

/** The largest magnitude every double represents as an exact integer, as digits. */
const MAX_SAFE_INTEGER_DIGITS = String(Number.MAX_SAFE_INTEGER)

/** Whether an integer literal's magnitude exceeds the safe-integer range. */
function isUnsafeIntegerLiteral(token: string): boolean {
  const digits = token.startsWith('-') ? token.slice(1) : token
  return digits.length > MAX_SAFE_INTEGER_DIGITS.length
    || (digits.length === MAX_SAFE_INTEGER_DIGITS.length && digits > MAX_SAFE_INTEGER_DIGITS)
}

/**
 * Quote integer literals beyond the safe-integer range before `JSON.parse`
 * rounds them, so ids survive the display parse verbatim.
 */
function quoteUnsafeIntegers(raw: string): string {
  let out = ''
  let last = 0
  let match: RegExpExecArray | null
  while ((match = JSON_STRING_OR_NUMBER.exec(raw)) !== null) {
    const token = match[0]
    out += raw.slice(last, match.index)
    if (!token.startsWith('"') && isUnsafeIntegerLiteral(token)) out += `"${token}"`
    else out += token
    last = match.index + token.length
  }
  return out + raw.slice(last)
}

 function parseJsonContainer(value: string): object | undefined {
   try {
-    const parsed: unknown = JSON.parse(value)
+    const parsed: unknown = JSON.parse(quoteUnsafeIntegers(value))
     return typeof parsed === 'object' && parsed !== null ? parsed : undefined
   } catch {
     return undefined

3. packages/core/agent-loop/tests/tool-calls.spec.ts

新增 schema-aware argument parsing 测试组，共 9 个用例：

describe('tool-call scheduler: schema-aware argument parsing', () => {
  /** A tool that records the parsed arguments it receives. */
  function parsingTool() {
    const received: unknown[] = []
    const tool = defineContentToolFixture({
      name: 'parse',
      description: 'parsing probe',
      parameters: {
        tenantId: { type: 'string' },
        count: { type: 'number' },
        bigId: { type: 'integer' },
        tags: { type: 'array', items: { type: 'string' } },
        loose: { type: 'array' },
        meta: { type: 'object', properties: { note: { type: 'string' } }, additionalProperties: false },
        open: { type: 'object', additionalProperties: false },
      },
      async execute(args) {
        received.push(args)
        return [{ type: 'text', text: 'ok' }]
      },
    })
    return { tool, received }
  }

  it('preserves overflowing integers verbatim and coerces numbers to declared string fields', async () => {
    const { probe } = await run('{"tenantId":9876543210987654321,"count":3,"bigId":42,"tags":[123,456],"loose":[7],"meta":{"note":789},"open":{},"extra":5}')
    expect(probe.received).toEqual([{
      tenantId: '9876543210987654321',
      count: 3,
      bigId: 42,
      tags: ['123', '456'],
      loose: [7],
      meta: { note: '789' },
      open: {},
      extra: 5,
    }])
  })

  it('coerces safe numbers for string fields and keeps the largest safe integer numeric', async () => {
    const { probe } = await run('{"tenantId":123,"count":9007199254740991}')
    expect(probe.received).toEqual([{ tenantId: '123', count: 9007199254740991 }])
  })

  it('quotes the smallest unsafe 16-digit integer for a string field', async () => {
    const { probe } = await run('{"tenantId":9007199254740992,"count":9007199254740991}')
    expect(probe.received).toEqual([{ tenantId: '9007199254740992', count: 9007199254740991 }])
  })

  it('preserves a negative overflowing integer for a string field', async () => {
    const { probe } = await run('{"tenantId":-9876543210987654321}')
    expect(probe.received).toEqual([{ tenantId: '-9876543210987654321' }])
  })

  it('quotes an overflowing integer even for an integer field, failing validation instead of rounding', async () => {
    const { agent, probe } = await run('{"bigId":12345678901234567890}')
    expect(probe.received).toEqual([])
    const result = events(agent).find(e => e.type === 'tool/result')
    expect(result!.data.error).toMatchObject({ code: 'INVALID_ARGS' })
  })

  it('preserves invalid JSON as text, failing validation instead of dispatching', async () => {
    const { agent, probe } = await run('{not json')
    expect(probe.received).toEqual([])
    const result = events(agent).find(e => e.type === 'tool/result')
    expect(result!.data.error).toMatchObject({ code: 'INVALID_ARGS' })
  })

  it('leaves null values untouched during schema coercion', async () => {
    const { agent, probe } = await run('{"meta":null}')
    expect(probe.received).toEqual([])
    const result = events(agent).find(e => e.type === 'tool/result')
    expect(result!.data.error).toMatchObject({ code: 'INVALID_ARGS' })
  })

  it('maps empty arguments to an empty object and leaves token-free JSON untouched', async () => {
    const empty = await run('')
    expect(empty.probe.received).toEqual([{}])
    const bare = await run('{}')
    expect(bare.probe.received).toEqual([{}])
  })

  it('passes arguments through unchanged for an unregistered tool', async () => {
    const { agent } = await run('{"tenantId":123}', 'ghost')
    const result = events(agent).find(e => e.type === 'tool/result')
    expect(result!.data.error).toMatchObject({ code: 'UNKNOWN_TOOL' })
  })
})

运行：

pnpm --filter @deepseek-ai/dsh-agent-loop test -- tool-calls

变更文件

文件	说明
packages/core/agent-loop/src/tool-calls.ts	parseArguments 保留大整数精度 + 按 schema 强转类型（+71）
packages/core/agent-loop/tests/tool-calls.spec.ts	新增 schema-aware 解析测试组，9 个用例（+110）
packages/client/ui-trajectory/src/client/TrajectoryTable.tsx	轨迹 Payload 展示解析同步加保护（+33）

[TanTsiChen]

The independent snapshot-boundary finding and exact-integer transport proposal are now tracked in a separate discussion. That report includes the standalone reproduction and validation scope, and links back here for the related argument-parsing issue. This comment has been shortened to keep the detailed report in one place.