jianf/HomeAgent
1
0
Fork 0
mirror of https://gitcode.com/JianFeeeee/HomeAgent.git synced 2026-09-27 12:53:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix(lua): 补齐 6 个适配器的流式 tool_calls 支持

Browse Source 
体检判据（TestAllBundledAdaptersStreamToolCallStatus）报出的三类问题，
本提交解决其中两类；第三类（gemini）未动，原因见下。

## ① OpenAI 兼容族：github / groq / mistral（3 个）

它们的 transform_stream_chunk 与修复前的 deepseek **逐字相同** ——
只透 content/done，tool_calls 处理只存在于 transform_response（非流式）。

后果与 deepseek 相同：流式模式下工具调用全部丢失，模型调不动任何工具，
且**没有任何报错**。生产当前未启用这三个源，但按预设配置的用户会踩到。

照 deepseek 的修法补上（含 reasoning_content 透传）。

## ② 嵌套形态 + 键名错：server / kimicode / anthropic / ollama（4 个）

这四个**有** tool_calls 处理，但发的是：

    { index = N, id = ..., ["function"] = { name = ..., arguments = ... } }

而 homed 的 `agentAPI.ToolCall` 是**扁平**结构，json tag 为：

    id / type / name / arguments / raw_arguments / stream_index

两处都是**静默**失效（Go 侧按 json tag 反序列化，取不到就是零值，无报错）：
- **嵌套** `["function"]` ⇒ `name` / `raw_arguments` 取零值
  ⇒ flush 时判「无 name」丢弃，或参数为空
- **键名 `index`** ⇒ `StreamIndex` 取零值
  ⇒ 多个分片并到同一个桶，argsRaw 混拼 ⇒ 每个工具报「参数不是合法 JSON」
  而**一个都没真跑**

已逐项对齐为扁平 + `stream_index`。协议差异都保留：
- anthropic：`content_block_start` / `input_json_delta`，续传片 name 留空
  （内核按 stream_index 累积，补齐 name 后才 flush）
- ollama：tool_calls **整条一次发完**（不分片），故 stream_index 取数组下标

## ③ gemini 未动

它的流式函数处理 `candidates[].content.parts`，**全文件没有任何
tool_calls / functionCall 处理** —— 连非流式路径也没有。补它不是"对齐"
而是新实现，且 gemini 的 functionCall 形态（`functionCall: {name, args}`，
args 是对象而非 JSON 字符串）与 OpenAI 族不同，需要单独判据。

生产三个源（llmsproxy / visionllm / justworker）全部用 `openai.lua`，
不阻塞。留作独立项。

## 判据

- TestOpenAICompatibleFamilyHandlesStreamToolCalls  5 个 OpenAI 族适配器，
  逐个验证 tool_calls 未丢 + stream_index 正确
- TestAnthropicAdapterEmitsFlatToolCallsWithStreamIndex  用 **Anthropic 协议**
  的 fixture（不用 OpenAI 的，否则会因"不适用该 chunk"跳过 —— 看着绿，
  实则没测）
- TestOllamaAdapterEmitsFlatToolCallsWithStreamIndex  用 Ollama 协议形态
- TestDeepSeekAdapterHandlesStreamToolCalls  单列，因它有源预设指向

★ 三个判据按**协议**分文件而非逐适配器：这几个文件的流式函数逐字相同，
共用一个 fixture 会因协议不适用而静默跳过 —— 那等于没测。

## 体检分类

    修前: ✓ [openai]        ⚠ [kimicode server]  ✗ [anthropic deepseek gemini github groq mistral ollama]
    修后: ✓ [openai deepseek github groq mistral]  ⚠ []  ✗ [gemini]
This commit is contained in:
JianFeeeee
2026-09-27 18:34:33 +08:00
parent 0fdb13749a
commit cff8e10ad5
10 changed files with 411 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
internal/lua/adapters/anthropic.lua
View File

@ -108,22 +108,32 @@ function adapter.transform_stream_chunk(raw_chunk)
-- first fragment of a tool call: emit index + id + name, empty args
return json.encode({
content = "", done = false,
-- ★ 必须是**扁平**结构（name / raw_arguments 在顶层）且键名是
-- stream_index —— homed 的 agentAPI.ToolCall 按 json tag 反序列化：
-- · 嵌套 ["function"]={...} ⇒ Go 侧取不到 name/raw_arguments（取零值）
-- · 键名写 index ⇒ StreamIndex 取零值 ⇒ 多个分片并到同一个桶，
-- argsRaw 混拼 ⇒ 每个工具报"参数不是合法 JSON"而一个都没真跑
-- 两种形态都是**静默**失效，所以这里逐项对齐。
tool_calls = { {
index = chunk.index or 0,
id = chunk.content_block.id or "",
type = "function",
["function"] = { name = chunk.content_block.name or "", arguments = "" }
name = chunk.content_block.name or "",
raw_arguments = "",
stream_index = chunk.index or 0
} }
})
end
if chunk.type == "content_block_delta" and chunk.delta then
if chunk.delta.type == "input_json_delta" then
-- incremental JSON fragment; clients accumulate across chunks
-- 同上：扁平 + stream_index。续传片 name 为空是正常的 ——
-- 内核按 stream_index 累积，补齐 name 后才 flush。
local unified = { content = "", done = false, tool_calls = { {
index = chunk.index or 0,
id = "",
type = "function",
["function"] = { name = "", arguments = chunk.delta.partial_json or "" }
name = "",
raw_arguments = chunk.delta.partial_json or "",
stream_index = chunk.index or 0
} } }
return json.encode(unified)
end

42
internal/lua/adapters/github.lua
View File

@ -86,10 +86,48 @@ function adapter.transform_stream_chunk(raw_chunk)
if not chunk.choices or #chunk.choices == 0 then return "" end
local delta = chunk.choices[1].delta or {}
local fr = chunk.choices[1].finish_reason
return json.encode({
local unified = {
content = delta.content or "",
done = (fr ~= nil)
})
}
if delta.reasoning_content then
unified.reasoning_content = delta.reasoning_content
end
-- ★ 必须处理流式 tool_calls —— 此前只透 content/done，导致 deepseek 源
-- 在**流式**模式下工具调用全部丢失，模型调不动任何工具且无任何报错。
--
-- 为什么难发现：非流式路径（transform_response）是好的，所以端到端
-- 手工测试也过；而内核的 tool call 循环默认走流式。
-- 功能判据（core 包的批内测试）直接构造 Go 结构体，绕过适配器。
--
-- 形态与 openai.lua 一致：OpenAI 兼容流式格式
-- {function:{name,arguments}, id, type, index} → homed 扁平结构
-- {id, type, name, raw_arguments, stream_index}。
if delta.tool_calls then
local tcs = {}
for _, tc in ipairs(delta.tool_calls) do
local fn = tc["function"]
local name = (type(fn) == "table" and fn.name) or tc.name or ""
local raw_args = ""
if type(fn) == "table" and type(fn.arguments) == "string" then
raw_args = fn.arguments
elseif type(tc.arguments) == "string" then
raw_args = tc.arguments
end
-- 不能按 name 过滤：流式续传片 name 为空但携带 arguments，
-- 内核 accumulateStream 按 stream_index 分桶并累积
table.insert(tcs, {
id = tc.id or "",
type = tc.type or "function",
name = name,
raw_arguments = raw_args,
-- 透传上游分片 index：并行多工具调用时内核按它区分归属桶
stream_index = tc.index or 0
})
end
unified.tool_calls = tcs
end
return json.encode(unified)
end
return adapter

42
internal/lua/adapters/groq.lua
View File

@ -85,10 +85,48 @@ function adapter.transform_stream_chunk(raw_chunk)
if not chunk.choices or #chunk.choices == 0 then return "" end
local delta = chunk.choices[1].delta or {}
local fr = chunk.choices[1].finish_reason
return json.encode({
local unified = {
content = delta.content or "",
done = (fr ~= nil)
})
}
if delta.reasoning_content then
unified.reasoning_content = delta.reasoning_content
end
-- ★ 必须处理流式 tool_calls —— 此前只透 content/done，导致 deepseek 源
-- 在**流式**模式下工具调用全部丢失，模型调不动任何工具且无任何报错。
--
-- 为什么难发现：非流式路径（transform_response）是好的，所以端到端
-- 手工测试也过；而内核的 tool call 循环默认走流式。
-- 功能判据（core 包的批内测试）直接构造 Go 结构体，绕过适配器。
--
-- 形态与 openai.lua 一致：OpenAI 兼容流式格式
-- {function:{name,arguments}, id, type, index} → homed 扁平结构
-- {id, type, name, raw_arguments, stream_index}。
if delta.tool_calls then
local tcs = {}
for _, tc in ipairs(delta.tool_calls) do
local fn = tc["function"]
local name = (type(fn) == "table" and fn.name) or tc.name or ""
local raw_args = ""
if type(fn) == "table" and type(fn.arguments) == "string" then
raw_args = fn.arguments
elseif type(tc.arguments) == "string" then
raw_args = tc.arguments
end
-- 不能按 name 过滤：流式续传片 name 为空但携带 arguments，
-- 内核 accumulateStream 按 stream_index 分桶并累积
table.insert(tcs, {
id = tc.id or "",
type = tc.type or "function",
name = name,
raw_arguments = raw_args,
-- 透传上游分片 index：并行多工具调用时内核按它区分归属桶
stream_index = tc.index or 0
})
end
unified.tool_calls = tcs
end
return json.encode(unified)
end
return adapter

37
internal/lua/adapters/kimicode.lua
View File

@ -95,7 +95,42 @@ function adapter.transform_stream_chunk(raw_chunk)
unified.reasoning_content = delta.reasoning_content
end
if delta.tool_calls then
unified.tool_calls = delta.tool_calls
local tcs = {}
for _, tc in ipairs(delta.tool_calls) do
-- OpenAI 流式格式: {function:{name,arguments}, id, type, index}
-- homed StreamChunk.ToolCalls 期望扁平格式: {id, type, name, raw_arguments}
local fn = tc["function"]
local name = (type(fn) == "table" and fn.name) or tc.name or ""
local raw_args = ""
if type(fn) == "table" and type(fn.arguments) == "string" then
raw_args = fn.arguments
elseif type(tc.arguments) == "string" then
raw_args = tc.arguments
end
-- 不能按 name 过滤：OpenAI 流式分片中后续块 name 为空但携带 arguments
-- accumulateStream 按 index 累积并在 flushToolCall 时校验 name
table.insert(tcs, {
id = tc.id or "",
type = tc.type or "function",
name = name,
raw_arguments = raw_args,
-- ★ 必须透传上游 index（键名是 stream_index，不是 index）。
--
-- 内核按 stream_index 分桶累积同一轮多个 tool_call 的分片
-- （process.go:347 `idx := tc.StreamIndex`）。缺了这一项，
-- 所有分片的 StreamIndex 都是缺省 0 ⇒ 全部并进同一个桶 ⇒
-- argsRaw 混拼 ⇒ 每个工具都报"参数不是合法 JSON"，
-- 而工具一次都没真跑过。
--
-- 单工具调用时上游 index 恒为 0，缺省也是 0，所以这个问题
-- 在生产上长期不显形 —— 直到模型一轮发多个工具才炸。
--
-- 续传分片（只有 arguments、没有 name）尤其依赖它：
-- 那种分片除了 index 没有任何可归位的依据。
stream_index = tc.index or 0
})
end
unified.tool_calls = tcs
end
return json.encode(unified)
end

42
internal/lua/adapters/mistral.lua
View File

@ -85,10 +85,48 @@ function adapter.transform_stream_chunk(raw_chunk)
if not chunk.choices or #chunk.choices == 0 then return "" end
local delta = chunk.choices[1].delta or {}
local fr = chunk.choices[1].finish_reason
return json.encode({
local unified = {
content = delta.content or "",
done = (fr ~= nil)
})
}
if delta.reasoning_content then
unified.reasoning_content = delta.reasoning_content
end
-- ★ 必须处理流式 tool_calls —— 此前只透 content/done，导致 deepseek 源
-- 在**流式**模式下工具调用全部丢失，模型调不动任何工具且无任何报错。
--
-- 为什么难发现：非流式路径（transform_response）是好的，所以端到端
-- 手工测试也过；而内核的 tool call 循环默认走流式。
-- 功能判据（core 包的批内测试）直接构造 Go 结构体，绕过适配器。
--
-- 形态与 openai.lua 一致：OpenAI 兼容流式格式
-- {function:{name,arguments}, id, type, index} → homed 扁平结构
-- {id, type, name, raw_arguments, stream_index}。
if delta.tool_calls then
local tcs = {}
for _, tc in ipairs(delta.tool_calls) do
local fn = tc["function"]
local name = (type(fn) == "table" and fn.name) or tc.name or ""
local raw_args = ""
if type(fn) == "table" and type(fn.arguments) == "string" then
raw_args = fn.arguments
elseif type(tc.arguments) == "string" then
raw_args = tc.arguments
end
-- 不能按 name 过滤：流式续传片 name 为空但携带 arguments，
-- 内核 accumulateStream 按 stream_index 分桶并累积
table.insert(tcs, {
id = tc.id or "",
type = tc.type or "function",
name = name,
raw_arguments = raw_args,
-- 透传上游分片 index：并行多工具调用时内核按它区分归属桶
stream_index = tc.index or 0
})
end
unified.tool_calls = tcs
end
return json.encode(unified)
end
return adapter

27
internal/lua/adapters/ollama.lua
View File

@ -81,15 +81,28 @@ function adapter.transform_stream_chunk(raw_chunk)
end
if chunk.message.tool_calls then
local tools = {}
for _, tc in ipairs(chunk.message.tool_calls) do
for i, tc in ipairs(chunk.message.tool_calls) do
-- ★ 必须是**扁平**结构（name / raw_arguments 在顶层）且键名是
-- stream_index —— homed 的 agentAPI.ToolCall 按 json tag 反序列化：
-- · 嵌套 ["function"]={...} ⇒ Go 侧取不到 name/raw_arguments（零值）
-- · 键名写 index ⇒ StreamIndex 取零值 ⇒ 多个分片并到同一个桶，
-- argsRaw 混拼 ⇒ 每个工具报"参数不是合法 JSON"而一个都没真跑
-- 两种都是**静默**失效，所以这里逐项对齐。
local fn = tc["function"]
local name = (type(fn) == "table" and fn.name) or tc.name or ""
local args = "{}"
if type(fn) == "table" and fn.arguments ~= nil then
args = fn.arguments
elseif type(tc.arguments) == "string" then
args = tc.arguments
end
-- ollama 的 tool_calls **整条一次发完**（不分片），所以序号即下标
table.insert(tools, {
index = #tools,
id = tc.id or ("call_" .. #tools),
id = tc.id or ("call_" .. i),
type = "function",
["function"] = {
name = tc["function"] and tc["function"].name or "",
arguments = tc["function"] and (tc["function"].arguments or "{}") or "{}"
}
name = name,
raw_arguments = args,
stream_index = (tc.index or (i - 1))
})
end
unified.tool_calls = tools

37
internal/lua/adapters/server.lua
View File

@ -95,7 +95,42 @@ function adapter.transform_stream_chunk(raw_chunk)
unified.reasoning_content = delta.reasoning_content
end
if delta.tool_calls then
unified.tool_calls = delta.tool_calls
local tcs = {}
for _, tc in ipairs(delta.tool_calls) do
-- OpenAI 流式格式: {function:{name,arguments}, id, type, index}
-- homed StreamChunk.ToolCalls 期望扁平格式: {id, type, name, raw_arguments}
local fn = tc["function"]
local name = (type(fn) == "table" and fn.name) or tc.name or ""
local raw_args = ""
if type(fn) == "table" and type(fn.arguments) == "string" then
raw_args = fn.arguments
elseif type(tc.arguments) == "string" then
raw_args = tc.arguments
end
-- 不能按 name 过滤：OpenAI 流式分片中后续块 name 为空但携带 arguments
-- accumulateStream 按 index 累积并在 flushToolCall 时校验 name
table.insert(tcs, {
id = tc.id or "",
type = tc.type or "function",
name = name,
raw_arguments = raw_args,
-- ★ 必须透传上游 index（键名是 stream_index，不是 index）。
--
-- 内核按 stream_index 分桶累积同一轮多个 tool_call 的分片
-- （process.go:347 `idx := tc.StreamIndex`）。缺了这一项，
-- 所有分片的 StreamIndex 都是缺省 0 ⇒ 全部并进同一个桶 ⇒
-- argsRaw 混拼 ⇒ 每个工具都报"参数不是合法 JSON"，
-- 而工具一次都没真跑过。
--
-- 单工具调用时上游 index 恒为 0，缺省也是 0，所以这个问题
-- 在生产上长期不显形 —— 直到模型一轮发多个工具才炸。
--
-- 续传分片（只有 arguments、没有 name）尤其依赖它：
-- 那种分片除了 index 没有任何可归位的依据。
stream_index = tc.index or 0
})
end
unified.tool_calls = tcs
end
return json.encode(unified)
end

66
internal/lua/anthropic_stream_test.go Normal file
View File

@ -0,0 +1,66 @@
package lua
import (
"encoding/json"
"testing"
)
// TestAnthropicAdapterEmitsFlatToolCallsWithStreamIndex 用 **Anthropic 协议**
// 的形态喂分片，验证输出是**扁平**结构且键名是 stream_index。
//
// ★ 与 OpenAI 族的判据分开，原因有二：
//
// 1. 协议不同：Anthropic 用 content_block_start / content_block_delta +
// input_json_delta，不是 OpenAI 的 delta.tool_calls。共用一个 fixture
// 会因"不适用该 chunk"而跳过 —— 看着绿，实则没测。
// 2. 它此前是**两处都错**：发嵌套 `["function"]={...}`，且键名用 `index`
// 而非 `stream_index`。两种都是**静默**失效（Go 侧按 json tag 取值，取不到
// 就是零值，没有报错）：
// · 嵌套 ⇒ name / raw_arguments 取零值 ⇒ flush 时判 "无 name" 丢弃
// · 键名 index ⇒ StreamIndex 取零值 ⇒ 多分片并桶 ⇒ argsRaw 混拼
func TestAnthropicAdapterEmitsFlatToolCallsWithStreamIndex(t *testing.T) {
vm := NewVM(t.TempDir())
loadBundled(t, vm, "anthropic")
// 首片：content_block_start，声明工具名
start := `{"type":"content_block_start","index":2,` +
`"content_block":{"type":"tool_use","id":"toolu_01","name":"Read"}}`
// 续传片：content_block_delta + input_json_delta
delta := `{"type":"content_block_delta","index":2,` +
`"delta":{"type":"input_json_delta","partial_json":"{\"path\":\"a\"}"}}`
for i, f := range []string{start, delta} {
out, err := vm.CallTransformStreamChunk("anthropic", f)
if err != nil {
t.Fatalf("第 %d 片: %v", i, err)
}
var u struct {
ToolCalls []map[string]interface{} `json:"tool_calls"`
}
if json.Unmarshal([]byte(out), &u) != nil {
t.Fatalf("第 %d 片输出非法: %s", i, out)
}
if len(u.ToolCalls) == 0 {
t.Fatalf("第 %d 片没有 tool_calls: %s", i, out)
}
tc := u.ToolCalls[0]
// 必须是扁平：name / raw_arguments 在顶层，不能藏在 ["function"] 里
if _, nested := tc["function"]; nested {
t.Errorf("第 %d 片仍是**嵌套**形态 %v —— Go 侧 agentAPI.ToolCall 没有 "+
"function 字段，name/raw_arguments 会取零值（静默）", i, tc)
}
if _, has := tc["name"]; !has {
t.Errorf("第 %d 片缺顶层 name 键: %v", i, tc)
}
if _, has := tc["raw_arguments"]; !has {
t.Errorf("第 %d 片缺顶层 raw_arguments 键: %v", i, tc)
}
// 键名必须是 stream_index，不是 index
if si, ok := tc["stream_index"]; !ok {
t.Errorf("第 %d 片缺 stream_index 键: %v —— 键名写成 index 的话内核取零值，"+
"多个分片并到同一个桶、参数混拼（静默）", i, tc)
} else if int(si.(float64)) != 2 {
t.Errorf("第 %d 片 stream_index = %v，应为 2", i, si)
}
}
}

55
internal/lua/ollama_stream_test.go Normal file
View File

@ -0,0 +1,55 @@
package lua
import (
"encoding/json"
"testing"
)
// TestOllamaAdapterEmitsFlatToolCallsWithStreamIndex 用 **Ollama 协议**
// 的形态喂分片，验证输出是扁平结构且键名是 stream_index。
//
// ollama 的 tool_calls 是**整条一次发完**（不分片），所以 stream_index 取
// 数组下标。它此前发的是嵌套 ["function"]={...} + index 键名 —— 两种都是
// **静默**失效：Go 侧 agentAPI.ToolCall 没有 function 字段（取零值），
// 键名 index 也不会映射到 StreamIndex（取零值）。
func TestOllamaAdapterEmitsFlatToolCallsWithStreamIndex(t *testing.T) {
vm := NewVM(t.TempDir())
loadBundled(t, vm, "ollama")
chunk := `{"message":{"content":"","tool_calls":[` +
`{"id":"c0","function":{"name":"Read","arguments":"{\"p\":1}"}},` +
`{"id":"c1","function":{"name":"Write","arguments":"{\"p\":2}"}}]},` +
`"done":false}`
out, err := vm.CallTransformStreamChunk("ollama", chunk)
if err != nil {
t.Fatalf("transform_stream_chunk: %v", err)
}
var u struct {
ToolCalls []map[string]interface{} `json:"tool_calls"`
}
if json.Unmarshal([]byte(out), &u) != nil {
t.Fatalf("输出非法: %s", out)
}
if len(u.ToolCalls) != 2 {
t.Fatalf("应有 2 个 tool_call，实际 %d: %s", len(u.ToolCalls), out)
}
for i, tc := range u.ToolCalls {
if _, nested := tc["function"]; nested {
t.Errorf("[%d] 仍是**嵌套**形态 %v —— Go 侧没有 function 字段，"+
"name/raw_arguments 取零值（静默）", i, tc)
}
if _, has := tc["name"]; !has {
t.Errorf("[%d] 缺顶层 name: %v", i, tc)
}
if _, has := tc["raw_arguments"]; !has {
t.Errorf("[%d] 缺顶层 raw_arguments: %v", i, tc)
}
si, ok := tc["stream_index"]
if !ok {
t.Errorf("[%d] 缺 stream_index: %v —— 键名写成 index 的话内核取零值，"+
"多分片并桶、参数混拼（静默）", i, tc)
} else if int(si.(float64)) != i {
t.Errorf("[%d] stream_index = %v，应为 %d", i, si, i)
}
}
}

64
internal/lua/openai_family_stream_test.go Normal file
View File

@ -0,0 +1,64 @@
package lua
import (
"encoding/json"
"testing"
)
// openAICompatibleStreamAdapters 是「OpenAI 兼容流式协议」那一族适配器。
//
// 它们的 transform_stream_chunk 曾只透 content/done，**完全不处理
// tool_calls**（那部分只存在于 transform_response 即非流式路径）。后果：
// 流式模式下工具调用全部丢失，模型调不动任何工具，且没有任何报错。
//
// 为什么难发现：非流式路径是好的 ⇒ 手工端到端测试也过；内核的 tool call
// 循环默认走流式 ⇒ 实际不可用；core 包的批内判据直接构造 Go 结构体，
// 绕过适配器 ⇒ 测不到这一层。
//
// ★ 本判据按**协议族**组织而不是逐个适配器：这几个文件的流式函数逐字相同，
//
// 逐个写判据只是复制粘贴，且漏掉一个就少一个保护。
var openAICompatibleStreamAdapters = []string{"openai", "deepseek", "github", "groq", "mistral"}
func TestOpenAICompatibleFamilyHandlesStreamToolCalls(t *testing.T) {
// 两个 tool_call，各一片：首片带 name、续传片只带 arguments
frags := []string{
`{"id":"c","choices":[{"index":0,"delta":{"tool_calls":[` +
`{"index":0,"id":"t0","type":"function","function":{"name":"cmd_run","arguments":""}}]}}]}`,
`{"id":"c","choices":[{"index":0,"delta":{"tool_calls":[` +
`{"index":1,"function":{"arguments":"{\"command\":\"x\"}"}}]}}]}`,
}
for _, name := range openAICompatibleStreamAdapters {
t.Run(name, func(t *testing.T) {
vm := NewVM(t.TempDir())
loadBundled(t, vm, name)
for i, f := range frags {
out, err := vm.CallTransformStreamChunk(name, f)
if err != nil {
t.Fatalf("第 %d 片: %v", i, err)
}
var u struct {
ToolCalls []struct {
StreamIndex int `json:"stream_index"`
Name string `json:"name"`
RawArguments string `json:"raw_arguments"`
} `json:"tool_calls"`
}
if json.Unmarshal([]byte(out), &u) != nil {
t.Fatalf("第 %d 片输出非法: %s", i, out)
}
if len(u.ToolCalls) == 0 {
t.Errorf("第 %d 片：%s 的流式路径**丢掉了 tool_call**\n"+
" 输出：%s\n"+
" ⇒ 该源在流式模式下无法调用任何工具，且无任何报错。",
i, name, out)
continue
}
if u.ToolCalls[0].StreamIndex != i {
t.Errorf("第 %d 片 stream_index = %d，应为 %d —— 缺它会让内核"+
"把多个分片并到同一个桶，参数混拼成非法 JSON", i, u.ToolCalls[0].StreamIndex, i)
}
}
})
}
}