mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-16 05:01:03 +03:00
163 lines
6.4 KiB
TypeScript
163 lines
6.4 KiB
TypeScript
import { describe, expect, test } from "bun:test"
|
|
import { Message, ToolCallPart, ToolResultPart } from "../src/schema/messages.js"
|
|
import { normalizeToolHistory } from "../src/tool-history.js"
|
|
|
|
const toolCall = (id: string, name = id) => ToolCallPart.make({ id, name, input: {} })
|
|
const toolResult = (id: string, value: unknown, name = id, resultType?: "text" | "content" | "error") =>
|
|
Message.tool(ToolResultPart.make({ id, name, result: value, resultType }))
|
|
|
|
describe("tool history normalization", () => {
|
|
test("fills missing local results before the next step", () => {
|
|
const normalized = normalizeToolHistory([
|
|
Message.assistant([toolCall("first"), toolCall("second")]),
|
|
toolResult("first", "done", "wrong", "text"),
|
|
Message.user("Continue."),
|
|
Message.assistant(toolCall("trailing")),
|
|
])
|
|
|
|
expect(normalized.map((message) => message.role)).toEqual([
|
|
"assistant",
|
|
"tool",
|
|
"tool",
|
|
"user",
|
|
"assistant",
|
|
"tool",
|
|
])
|
|
expect(normalized[1]?.content[0]).toMatchObject({ type: "tool-result", id: "first", name: "first" })
|
|
expect(normalized[2]?.content).toEqual([
|
|
{ type: "tool-result", id: "second", name: "second", result: { type: "error", value: "Tool result missing" } },
|
|
])
|
|
expect(normalized[4]?.content).toEqual([toolCall("trailing")])
|
|
expect(normalized[5]?.content).toEqual([
|
|
{
|
|
type: "tool-result",
|
|
id: "trailing",
|
|
name: "trailing",
|
|
result: { type: "error", value: "Tool result missing" },
|
|
},
|
|
])
|
|
})
|
|
|
|
test("fills missing results for trailing calls without replacing available results", () => {
|
|
const calls = Message.assistant([toolCall("answered"), toolCall("unanswered")])
|
|
const answered = toolResult("answered", "done", "answered", "text")
|
|
const hosted = ToolCallPart.make({ id: "hosted", name: "web_search", input: {}, providerExecuted: true })
|
|
|
|
expect(normalizeToolHistory([calls, answered])).toEqual([
|
|
calls,
|
|
answered,
|
|
Message.tool(
|
|
ToolResultPart.make({
|
|
id: "unanswered",
|
|
name: "unanswered",
|
|
result: "Tool result missing",
|
|
resultType: "error",
|
|
}),
|
|
),
|
|
])
|
|
expect(normalizeToolHistory([Message.assistant(hosted)])).toEqual([Message.assistant(hosted)])
|
|
})
|
|
|
|
test("normalizes empty results without changing whitespace or media", () => {
|
|
const media = { type: "file" as const, uri: "data:image/png;base64,AQID", mime: "image/png" }
|
|
const normalized = normalizeToolHistory([
|
|
Message.assistant([
|
|
toolCall("text"),
|
|
toolCall("content"),
|
|
toolCall("error"),
|
|
toolCall("mixed"),
|
|
toolCall("whitespace"),
|
|
]),
|
|
toolResult("text", "", "text", "text"),
|
|
toolResult("content", [], "content", "content"),
|
|
toolResult("error", "", "error", "error"),
|
|
toolResult("mixed", [{ type: "text", text: "" }, media], "mixed", "content"),
|
|
toolResult("whitespace", " ", "whitespace", "text"),
|
|
])
|
|
|
|
expect(normalized.slice(1).map((message) => message.content[0])).toEqual([
|
|
{ type: "tool-result", id: "text", name: "text", result: { type: "text", value: "(no tool output)" } },
|
|
{ type: "tool-result", id: "content", name: "content", result: { type: "text", value: "(no tool output)" } },
|
|
{ type: "tool-result", id: "error", name: "error", result: { type: "error", value: "(no tool output)" } },
|
|
{ type: "tool-result", id: "mixed", name: "mixed", result: { type: "content", value: [media] } },
|
|
{ type: "tool-result", id: "whitespace", name: "whitespace", result: { type: "text", value: " " } },
|
|
])
|
|
})
|
|
|
|
test("leaves unmatched and provider-executed history unchanged", () => {
|
|
const hostedCall = ToolCallPart.make({
|
|
id: "hosted",
|
|
name: "web_search",
|
|
input: {},
|
|
providerExecuted: true,
|
|
})
|
|
const hostedResult = ToolResultPart.make({
|
|
id: "hosted",
|
|
name: "web_search",
|
|
result: "",
|
|
resultType: "text",
|
|
providerExecuted: true,
|
|
})
|
|
const hosted = Message.assistant([hostedCall, hostedResult])
|
|
const orphan = toolResult("orphan", "ignored", "orphan", "text")
|
|
|
|
expect(normalizeToolHistory([orphan, hosted])).toEqual([orphan, hosted])
|
|
})
|
|
|
|
test("uses a matching call as the complete tool identity", () => {
|
|
const normalized = normalizeToolHistory([
|
|
Message.assistant(ToolCallPart.make({ id: "call_1", name: "lookup", input: {} })),
|
|
Message.tool(ToolResultPart.make({ id: "call_1", name: "wrong", namespace: "stale", result: "done" })),
|
|
])
|
|
|
|
expect(normalized[1]?.content[0]).toMatchObject({ name: "lookup", namespace: undefined })
|
|
})
|
|
|
|
test("moves system updates after the results of pending calls", () => {
|
|
const calls = Message.assistant([toolCall("first"), toolCall("second")])
|
|
const first = toolResult("first", "one", "first", "text")
|
|
const second = toolResult("second", "two", "second", "text")
|
|
const update = Message.system("First update.")
|
|
const later = Message.system("Second update.")
|
|
const user = Message.user("Continue.")
|
|
const missing = (id: string) =>
|
|
Message.tool(ToolResultPart.make({ id, name: id, result: "Tool result missing", resultType: "error" }))
|
|
|
|
expect(normalizeToolHistory([calls, first, update, later, second, user])).toEqual([
|
|
calls,
|
|
first,
|
|
second,
|
|
update,
|
|
later,
|
|
user,
|
|
])
|
|
expect(normalizeToolHistory([Message.assistant(toolCall("first")), update, user])).toEqual([
|
|
Message.assistant(toolCall("first")),
|
|
missing("first"),
|
|
update,
|
|
user,
|
|
])
|
|
expect(normalizeToolHistory([Message.assistant(toolCall("first")), update])).toEqual([
|
|
Message.assistant(toolCall("first")),
|
|
missing("first"),
|
|
update,
|
|
])
|
|
})
|
|
|
|
test("moves effort updates after the results of pending calls", () => {
|
|
const call = Message.assistant(toolCall("first"))
|
|
const result = toolResult("first", "one", "first", "text")
|
|
const effort = Message.effort({ effort: "low", previous: "high" })
|
|
|
|
expect(normalizeToolHistory([call, effort, result])).toEqual([call, result, effort])
|
|
})
|
|
|
|
test("keeps system updates in place when no call is pending", () => {
|
|
const history = [Message.assistant(toolCall("first")), toolResult("first", "one", "first", "text")]
|
|
const update = Message.system("Update.")
|
|
const input = [Message.user("Start."), update, ...history, update, Message.user("Continue.")]
|
|
|
|
expect(normalizeToolHistory(input)).toBe(input)
|
|
})
|
|
})
|