Bug: tool-call id/name overwritten by empty strings from OpenAI-compatible providers (every tool call becomes unknown tool "")

[arnold-gopagoda]

Summary

When dsh is pointed at an OpenAI-compatible gateway (reproduced with SiliconFlow, https://api.siliconflow.cn/v1) instead of the official DeepSeek API, every tool call fails with unknown tool "". The arguments JSON assembles correctly, but the call's id and name end up as empty strings, so the tool registry lookup rejects the call. The agent retries in a loop and can never execute any tool.

Root cause

packages/llm/llm-deepseek/src/translate.ts accumulates streaming tool_calls fragments with:

if (call.id !== undefined) block.callId = call.id
if (call.function?.name !== undefined) block.name = call.function.name

Only the first fragment of a tool call carries id and function.name. The official DeepSeek API omits both fields on continuation fragments (undefined), so the guards hold. SiliconFlow (and other OpenAI-compatible implementations) instead send them as empty strings on every continuation fragment:

{"index": 0, "id": "", "function": {"name": "", "arguments": "{\"pattern\""}}

"" !== undefined, so the second fragment overwrites the real id/name with "". The closing block-end then carries the empty values, and (with the authoritative-block path in BlockAssembler) the final tool-call block has name: "".

Session-log evidence (SiliconFlow, deepseek-ai/DeepSeek-V4-Flash):

{"type":"tool-call-delta","index":2,"id":"01a00b657d8e5e2208f74d77907a55cc","name":"glob","argumentsDelta":""}
{"type":"tool-call-delta","index":2,"id":"","name":"","argumentsDelta":"{"}
...
{"type":"block-end","index":2,"block":{"type":"tool-call","id":"","name":"","arguments":"{\"pattern\": \"*\", ...}"}}

Note BlockAssembler.push already guards name accumulation with truthiness (if (chunk.name)), but it cannot recover because the adapter's authoritative block-end wins, and its unconditional partial.toolCallId = chunk.id has the same empty-string overwrite for the id.

Fix

Treat empty strings the same as absent fields — an empty id/name never replaces the opening fragment's value:

-        if (call.id !== undefined) block.callId = call.id
-        if (call.function?.name !== undefined) block.name = call.function.name
+        // OpenAI-compatible providers (e.g. SiliconFlow) send `id: ""` and
+        // `name: ""` on continuation fragments where the official API omits
+        // the fields; an empty value never replaces the opening fragment's.
+        if (call.id) block.callId = call.id
+        if (call.function?.name) block.name = call.function.name

Regression test (passes with the fix, fails without; full translate.spec.ts suite still green, 31/31):

it('keeps the opening fragment id and name when continuations carry empty strings (SiliconFlow shape)', async () => {
  const chunks = await collect(translate(feed(
    firstChunk,
    { choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_00_x', type: 'function', function: { name: 'get_weather', arguments: '' } }] } }] },
    { choices: [{ delta: { tool_calls: [{ index: 0, id: '', function: { name: '', arguments: '{"city"' } }] } }] },
    { choices: [{ delta: { tool_calls: [{ index: 0, id: '', function: { name: '', arguments: ': "Paris"}' } }] } }] },
    { choices: [{ delta: {}, finish_reason: 'tool_calls' }] },
    DONE,
  )))
  const ends = chunks.filter(chunk => chunk.type === 'block-end')
  expect(ends).toEqual([
    {
      type: 'block-end',
      index: 0,
      block: { type: 'tool-call', id: 'call_00_x', name: 'get_weather', arguments: '{"city": "Paris"}' },
    },
  ])
})

Verified end-to-end: with the patch applied, the same Web UI session executes bash/glob tool calls through SiliconFlow normally.

Environment

• deepseek-harness @ master (47f9438), source launch (pnpm dsh web)
• macOS (darwin arm64), Node 24.19.0, pnpm 11.7.0
• Provider: SiliconFlow OpenAI-compatible endpoint, model deepseek-ai/DeepSeek-V4-Flash

CONTRIBUTING.md says external PRs are not accepted at the moment, so reporting here with the patch inline — happy to provide anything else that helps.

[argszero]

Verified line-by-line against master (47f9438) — your analysis is exact on every point I checked. This report is the empty-string sibling of an earlier pair in the same family, and your fix direction is the one that closes the whole family. Adding the cross-thread layer:

1. Family convergence — the != null gap. #1713 / #2090 (SGLang, OpenAI-compatible) reported the same identity-loss with null on continuation fragments. zoahdev's fix branch (fix/llm-deepseek-toolcall-null-name) switched the guards to != null — which correctly stops null, but "" != null evaluates true, so empty strings still overwrite. Your truthy guard (if (call.id)) covers both null and "", so it's the family-complete form. The #2090 branch should be reconciled to this same guard so the fix lands once instead of twice.

2. Second independent repro already exists. lanjie8 reproduced the same wire-level cause on #2343 and posted a cherry-pick-ready commit (lanjie8/deepseek-harness@1e635ed, fix(llm-deepseek): preserve streamed tool-call identity) — same translate.ts lines (+4 −2), regression fixture, 152 tests + lint/typecheck/build/docs all green, plus a real headless request verifying name: "bash" and non-empty callId. Worth linking #2540 ↔ #2343: three independent confirmations of the same root cause.

3. One residual site neither fix covers — the shared assembler. Your diff (and lanjie8's) fixes translate.ts, which protects the block-end-authoritative path because the closing block-end then carries the correct id. But packages/llm/llm/src/assembler.ts:70 — partial.toolCallId = chunk.id, unconditional — is in BlockAssembler, the assembler shared by every provider adapter, not just llm-deepseek (relevant to #2529's proposal to split packages/llm for self-hosted gateways). Any adapter emitting tool-call-delta with an empty id — or a truncated stream that falls back to delta accumulation, where :113's partial.toolCallId ?? CallId(...) doesn't rescue "" either — still poisons the id. Adding if (chunk.id) at :70 mirrors the already-truthy name guard at :71 and makes the assembler itself immune for all adapters. Belt-and-braces, one line, worth folding into the same fix.

4. Your follow-on is confirmed. lanjie8 noted the persisted tool/result with empty source callId is rejected on reload — packages/core/session/src/index.ts:339-347 throws message must have tool source for callId === ''. So the live turn dies at dispatch (UNKNOWN_TOOL) and the empty-callId turn can't survive reload either; the session-side guard is already right, which is why the wire-side fix at translate is the correct root level. (This is also the 6th report in the serializer/wire family tracked across #1449/#1519/#1337/#1593/#2169 — the empty-string delta was the one variant the earlier reports didn't cover, so this closes the loop.)

Your regression test follows the existing feed/collect/firstChunk/DONE conventions and asserts the exact block-end shape — clean. With the assembler line folded in, this family should be fully closed.

[CZJCC]

I independently reproduced this on a DeepSeek-compatible OpenAI-style stream while integrating DSH with a gateway.

The wire shape is:

• opening delta: tool_calls[0].id = "call_00_x"
• later argument-only deltas: tool_calls[0].id = ""

With the current packages/llm/llm-deepseek/src/translate.ts, the guard call.id !== undefined lets the empty continuation overwrite the valid opening id. The emitted tool-call then has an empty identity, so the following tool result cannot be correlated and the turn fails with an unresolved tool lineage.

I prepared and validated a minimal adapter-level patch in my fork:
https://github.com/CZJCC/deepseek-harness/tree/codex/pr-deepseek-stream-tool-call-id

Commit: d0ed1f3855468ca90cc2df9bda09924367175877

The patch only updates the accumulated call id when the wire value is non-empty, and adds a regression fixture for the empty-id continuation shape. Validation completed with 30 focused DeepSeek translation tests, the package TypeScript build, and the repository pre-push build/typecheck hook. No internal endpoints, credentials, or customer data are included.

This is an independent confirmation of the same empty-string variant. The upstream PR path is currently disabled, so I am sharing the ready-to-review branch here for maintainers to fold into the preferred family-wide fix.

[guzhou0102]

Cross-posting from #2855,
where I reported the assembler-side half of this bug family — argszero asked me to
consolidate the complete picture here since this thread has the fullest root-cause writeup.

TL;DR

translate.ts guards alone are not sufficient. Even after Layer 1 is fixed, a provider or
adapter that emits a raw block-end carrying id: "" / name: "" (or a truncation that
skips deltas entirely) still poisons the final block, because BlockAssembler.assemble()
short-circuits on partial.block and never backfills from the accumulated deltas. You need
both layers. Verified against rc.7 (99f6f02fec) by argszero in #2855.

The two assembler defects (rc.7 source)

Defect 1 — unconditional id capture (assembler.ts:70):

partial.toolCallId = chunk.id;                     // later empty-id deltas clobber it
if (chunk.name) partial.toolCallName = chunk.name; // guarded — the asymmetry proves intent

Defect 2 — assemble() short-circuit discards accumulated values (assembler.ts:78-82, 100):

case 'block-end':
    partial.block = chunk.block;   // raw block may carry id:"" / name:""
    ...
assemble(partial, index) {
    if (partial.block)
        return partial.block;      // short-circuit: partial.* accumulators are dropped

The fix (two small patches, both applied)

L2 — guard id exactly like name:

if (chunk.id) partial.toolCallId = chunk.id;
if (chunk.name) partial.toolCallName = chunk.name;

L3 — backfill in assemble() when the raw block-end is missing fields:

assemble(partial, index) {
    if (partial.block) {
        let block = partial.block;
        if ((block.name === undefined || block.name === null || block.name === '') &&
            partial.toolCallName) block = { ...block, name: partial.toolCallName };
        if ((block.id === undefined || block.id === null || block.id === '') &&
            partial.toolCallId) block = { ...block, id: partial.toolCallId };
        if ((block.arguments === undefined || block.arguments === null || block.arguments === '') &&
            partial.toolCallArguments) block = { ...block, arguments: partial.toolCallArguments };
        return block;
    }
    ...
}

The invariant: a fully-populated block-end is returned unchanged; only missing fields get
backfilled. Belt-and-suspenders on top: if both sources end up empty, fall back to a generated
id rather than "" — an unknown-but-stable id fails loudly once instead of poisoning the session.

Regression test (exercises all layers)

40 parallel tool calls × 25 SSE chunks each, arguments split across all chunks, id/name only
on the first chunk, then a raw block-end carrying arguments: "":

for (let c = 0; c < CHUNKS; c++) {
  for (let t = 0; t < N_TOOLS; t++) {
    if (c === 0) asm.push({ type: "block-start", index: t, blockType: "tool-call" });
    asm.push({
      type: "tool-call-delta", index: t,
      id:   c === 0 ? `call_${t}` : undefined,
      name: c === 0 ? `tool_${t}` : undefined,
      argumentsDelta: segs[c] ?? "",
    });
  }
}
for (let t = 0; t < N_TOOLS; t++)
  asm.push({ type: "block-end", index: t, block: { type: "tool-call", arguments: "" } });
// assert every assembled block has call_${t} / tool_${t} / full arguments

Unpatched: every block comes back with id: "", name: "". Patched: 40/40 exact. Worth adding
both null and "" variants per argszero's note — both wire shapes appear across providers.

One operational note

The runtime loads the bundled dsh-llm/lib/index.js, not lib/types/assembler.js — a
source-only fix looks correct in review but never executes. Any patch/test must target the
bundled copy (this bit me on first application).

Happy to share my idempotent patch script + stress test verbatim if the maintainers want them
for a proper upstream fix.