expect(firstPayload.output?.[0]?.call_id).not.toBe(secondPayload.output?.[0]?.call_id);

});

it("uses unique ids for repeated identical tool calls", async () => {

const server = await startMockServer();

const body = {

stream: false,

model: "gpt-5.5",

input: [makeUserInput("Read QA_KICKOFF_TASK.md, then answer with exactly QA-READ-OK.")],

};

const first = await expectResponsesJson<{ output?: Array<{ call_id?: string }> }>(server, body);

const second = await expectResponsesJson<{ output?: Array<{ call_id?: string }> }>(

server,

body,

);

const firstCallId = first.output?.[0]?.call_id;

const secondCallId = second.output?.[0]?.call_id;

expect(firstCallId).toMatch(/^call_mock_read_/);

expect(secondCallId).toMatch(/^call_mock_read_/);

expect(firstCallId).not.toBe(secondCallId);

});

it("continues repo-contract followthrough when a retry user item follows tool output", async () => {

const server = await startQaMockOpenAiServer({

host: "127.0.0.1",

type ResponsesInputItem = Record<string, unknown>;

let mockFunctionCallSequence = 0;

type StreamEvent =

| { type: "response.output_item.added"; item: Record<string, unknown> }

| {

.update(serialized)

.digest("hex")

.slice(0, 10);

const callId = `call_mock_${name}_${callSuffix}`;

const itemId = `fc_mock_${name}_${callSuffix}`;

const sequence = ++mockFunctionCallSequence;

const uniqueSuffix = `${callSuffix}_${sequence}`;

const callId = `call_mock_${name}_${uniqueSuffix}`;

const itemId = `fc_mock_${name}_${uniqueSuffix}`;

const item = {

type: "function_call",

id: itemId,

callId,

item,

itemId,

responseId: `resp_mock_${name}_${callSuffix}`,

responseId: `resp_mock_${name}_${uniqueSuffix}`,

serialized,

};

}