Å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.
170 lines
5.9 KiB
TypeScript
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)
|
|
})
|
|
})
|