Files
accounted/lib/agent/chat/__tests__/run-turn-dangling-tools.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

170 lines
5.9 KiB
TypeScript

import { describe, it, expect } from 'vitest'
import { repairDanglingToolUse } from '../run-turn'
/**
* A turn persists the assistant message carrying tool_use blocks BEFORE the
* tools run, and their tool_result blocks only after the whole batch finishes.
* If the process dies in between (client disconnect terminating the function,
* a deploy, a tool outliving the request), the stored history ends on an
* unanswered tool_use. The Messages API rejects that shape, so every later turn
* 400s, and agent_messages is append-only (BFL audit trail) so nothing can
* repair the row: the conversation is bricked permanently.
*
* repairDanglingToolUse patches the shape on READ only, leaving the stored
* trail untouched.
*/
const textBlock = (text: string) => [{ type: 'text', text }]
describe('repairDanglingToolUse', () => {
it('leaves a well-formed conversation untouched', () => {
const messages = [
{ role: 'user' as const, content: textBlock('Boka om Circle K') },
{
role: 'assistant' as const,
content: [
{ type: 'tool_use', id: 'tu_1', name: 'gnubok_query_journal', input: {} },
],
},
{
role: 'user' as const,
content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'A-207' }],
},
{ role: 'assistant' as const, content: textBlock('Klart att godkänna.') },
]
expect(repairDanglingToolUse(messages)).toEqual(messages)
})
it('synthesizes an error tool_result for an unanswered tool_use', () => {
const messages = [
{ role: 'user' as const, content: textBlock('Gör klart juli') },
{
role: 'assistant' as const,
content: [{ type: 'tool_use', id: 'tu_dead', name: 'gnubok_list_transactions', input: {} }],
},
]
const repaired = repairDanglingToolUse(messages)
expect(repaired).toHaveLength(3)
expect(repaired[2]).toEqual({
role: 'user',
content: [
{
type: 'tool_result',
tool_use_id: 'tu_dead',
content: expect.stringContaining('Avbröts'),
is_error: true,
},
],
})
})
it('repairs only the unanswered call in a mixed batch', () => {
const messages = [
{
role: 'assistant' as const,
content: [
{ type: 'tool_use', id: 'tu_ok', name: 'a', input: {} },
{ type: 'tool_use', id: 'tu_dead', name: 'b', input: {} },
],
},
{
role: 'user' as const,
content: [{ type: 'tool_result', tool_use_id: 'tu_ok', content: 'fine' }],
},
]
const repaired = repairDanglingToolUse(messages)
const synthesized = repaired.filter(
(m) =>
Array.isArray(m.content) &&
m.content.some((b: { is_error?: boolean }) => b.is_error === true),
)
expect(synthesized).toHaveLength(1)
expect(synthesized[0]!.content).toHaveLength(1)
expect(synthesized[0]!.content[0].tool_use_id).toBe('tu_dead')
})
it('inserts the stub immediately after the assistant turn that opened it', () => {
const messages = [
{
role: 'assistant' as const,
content: [{ type: 'tool_use', id: 'tu_dead', name: 'a', input: {} }],
},
{ role: 'user' as const, content: textBlock('är du kvar?') },
]
const repaired = repairDanglingToolUse(messages)
// The stub must sit between the tool_use and the next user turn, otherwise
// the API still sees an unanswered tool_use followed by a user message.
expect(repaired.map((m) => m.role)).toEqual(['assistant', 'user', 'user'])
expect(repaired[1]!.content[0].tool_use_id).toBe('tu_dead')
expect(repaired[2]!.content[0].text).toBe('är du kvar?')
})
it('repairs a result that arrived after an intervening turn', () => {
// Two turns racing on one conversation can persist a user message between
// the tool_use and its results. The id IS answered somewhere, but not in
// the message immediately following the tool_use, which the API still
// rejects: the stub has to go in the gap and the late copy has to go.
const messages = [
{
role: 'assistant' as const,
content: [{ type: 'tool_use', id: 'tu_late', name: 'a', input: {} }],
},
{ role: 'user' as const, content: textBlock('hallå?') },
{
role: 'user' as const,
content: [{ type: 'tool_result', tool_use_id: 'tu_late', content: 'sent too late' }],
},
]
const repaired = repairDanglingToolUse(messages)
// Stub sits directly after the tool_use...
expect(repaired[1]!.content[0]).toMatchObject({
type: 'tool_result',
tool_use_id: 'tu_late',
is_error: true,
})
// ...the intervening user text survives...
expect(repaired[2]!.content[0].text).toBe('hallå?')
// ...and the orphaned late result is gone, along with its emptied message.
const lateResults = repaired
.flatMap((m) => (Array.isArray(m.content) ? m.content : []))
.filter((b: { content?: string }) => b?.content === 'sent too late')
expect(lateResults).toHaveLength(0)
})
it('drops a tool_result whose tool_use never preceded it', () => {
const messages = [
{ role: 'user' as const, content: textBlock('hej') },
{
role: 'user' as const,
content: [{ type: 'tool_result', tool_use_id: 'tu_ghost', content: 'orphan' }],
},
]
const repaired = repairDanglingToolUse(messages)
// An unmatched tool_result is rejected by the API just as an unanswered
// tool_use is, so the emptied message is dropped entirely.
expect(repaired).toHaveLength(1)
expect(repaired[0]!.content[0].text).toBe('hej')
})
it('tolerates string and non-array content without throwing', () => {
const messages = [
{ role: 'user' as const, content: 'plain string content' as unknown as [] },
{ role: 'assistant' as const, content: null as unknown as [] },
]
expect(() => repairDanglingToolUse(messages)).not.toThrow()
expect(repairDanglingToolUse(messages)).toHaveLength(2)
})
})