]);

});

it("keeps duplicate tool-call ids distinct while retaining the first signature", async () => {

guardedFetchMock.mockResolvedValueOnce(

buildSseResponse([

{

candidates: [

{

content: {

parts: [

{

functionCall: {

id: "call_1",

name: "first",

args: { value: 1 },

},

thoughtSignature: "first_signature",

},

{

functionCall: {

id: "call_1",

name: "second",

args: { value: 2 },

},

},

],

},

finishReason: "STOP",

},

],

},

]),

);

const streamFn = createGoogleGenerativeAiTransportStreamFn();

const stream = await Promise.resolve(

streamFn(buildGeminiModel(), {

messages: [{ role: "user", content: "hello", timestamp: 0 }],

} as never),

);

const result = await stream.result();

const toolCalls = result.content.filter((block) => block.type === "toolCall");

expect(toolCalls).toHaveLength(2);

expect(toolCalls[0]).toMatchObject({

id: "call_1",

name: "first",

arguments: { value: 1 },

thoughtSignature: "first_signature",

});

expect(toolCalls[1]).toMatchObject({

name: "second",

arguments: { value: 2 },

thoughtSignature: "first_signature",

});

expect(toolCalls[1]?.id).not.toBe("call_1");

});

it("keeps explicit thinking signatures after tool-call SSE parts", async () => {

guardedFetchMock.mockResolvedValueOnce(

buildSseResponse([

});

stream.push({ type: "start", partial: output as never });

let currentBlockIndex = -1;

const toolCallBlocksById = new Map<

string,

Extract<GoogleTransportContentBlock, { type: "toolCall" }>

>();

const chunks =

sse.firstChunk === undefined

? sse.chunks

currentBlockIndex = -1;

}

const providedId = part.functionCall.id;

const isDuplicate = output.content.some(

(block) => block.type === "toolCall" && block.id === providedId,

);

const existingToolCall =

typeof providedId === "string"

? output.content.find(

(

block,

): block is Extract<GoogleTransportContentBlock, { type: "toolCall" }> =>

block.type === "toolCall" && block.id === providedId,

)

: undefined;

typeof providedId === "string" ? toolCallBlocksById.get(providedId) : undefined;

const isDuplicate = existingToolCall !== undefined;

const toolCallId =

providedId && !isDuplicate

? providedId

),

};

output.content.push(toolCall);

if (!toolCallBlocksById.has(toolCall.id)) {

toolCallBlocksById.set(toolCall.id, toolCall);

}

const blockIndex = output.content.length - 1;

stream.push({

type: "toolcall_start",

});

expect(output.usage.cost.total).toBeGreaterThan(0);

});

it("generates a new id when Google repeats a streamed tool-call id", async () => {

const output = createOutput();

const stream = new AssistantMessageEventStream();

const events: string[] = [];

const collect = (async () => {

for await (const event of stream) {

events.push(event.type);

}

})();

await consumeGoogleGenerateContentStream({

chunks: chunks([

{

candidates: [

{

content: {

parts: [{ functionCall: { id: "call_1", name: "lookup", args: {} } }],

},

},

],

} as GenerateContentResponse,

{

candidates: [

{

content: {

parts: [{ functionCall: { id: "call_1", name: "lookup", args: {} } }],

},

finishReason: FinishReason.STOP,

},

],

} as GenerateContentResponse,

]),

model,

output,

stream,

nextToolCallId: (name) => `generated-${name}`,

});

await collect;

expect(events.at(-1)).toBe("done");

expect(output.content).toEqual([

{

type: "toolCall",

id: "call_1",

name: "lookup",

arguments: {},

},

{

type: "toolCall",

id: "generated-lookup",

name: "lookup",

arguments: {},

},

]);

});

});

describe("buildGoogleGenerateContentParams", () => {

params.stream.push({ type: "start", partial: params.output });

let currentBlock: TextContent | ThinkingContent | null = null;

const blocks = params.output.content;

const toolCallIds = new Set<string>();

for (const block of blocks) {

if (block.type === "toolCall") {

toolCallIds.add(block.id);

}

}

const blockIndex = () => blocks.length - 1;

const endCurrentBlock = () => {

if (part.functionCall) {

endCurrentBlock();

const providedId = part.functionCall.id;

const needsNewId =

!providedId ||

params.output.content.some(

(block) => block.type === "toolCall" && block.id === providedId,

);

const needsNewId = !providedId || toolCallIds.has(providedId);

const toolCall: ToolCall = {

type: "toolCall",

id: needsNewId ? params.nextToolCallId(part.functionCall.name) : providedId,

};

params.output.content.push(toolCall);

toolCallIds.add(toolCall.id);

params.stream.push({

type: "toolcall_start",

contentIndex: blockIndex(),

expect(eventTypes.filter((type) => type === "thinking_end")).toHaveLength(1);

});

it("attaches encrypted reasoning details to the matching streamed tool call", async () => {

mockChunksRef.chunks = [

makeToolCallChunk("call_1", "first", '{"value":1}'),

{

id: "chatcmpl-test",

choices: [

{

index: 0,

delta: {

tool_calls: [

{

index: 1,

id: "call_2",

function: { name: "second", arguments: '{"value":2}' },

type: "function",

},

],

reasoning_details: [

{

type: "reasoning.encrypted",

id: "call_1",

data: "encrypted",

},

],

} as OpenAICompatibleDelta & {

reasoning_details: Array<Record<string, string>>;

},

},

],

},

makeFinishChunk("tool_calls"),

];

const stream = streamOpenAICompletions(model, context, {

apiKey: "sk-test",

});

const result = await stream.result();

const toolCalls = result.content.filter((block) => block.type === "toolCall");

expect(toolCalls).toHaveLength(2);

expect(toolCalls[0]).toMatchObject({

id: "call_1",

thoughtSignature: JSON.stringify({

type: "reasoning.encrypted",

id: "call_1",

data: "encrypted",

}),

});

expect(toolCalls[1]).not.toHaveProperty("thoughtSignature");

});

it("keeps one native reasoning block when content and reasoning co-occur", async () => {

mockChunksRef.chunks = [

{

let hasFinishReason = false;

const toolCallBlocksByIndex = new Map<number, StreamingToolCallBlock>();

const toolCallBlocksById = new Map<string, StreamingToolCallBlock>();

const toolCallBlocksByFirstId = new Map<string, StreamingToolCallBlock>();

const blocks = output.content as StreamingBlock[];

// A block can be finished mid-stream (native reasoning sealed at the

// text-lane transition) and again by the end-of-stream loop; guard so its

blocks.push(block);

};

const getContentIndex = (block: StreamingBlock) => contentIndices.get(block) ?? -1;

const rememberFirstToolCallById = (id: string, block: StreamingToolCallBlock) => {

if (!toolCallBlocksByFirstId.has(id)) {

toolCallBlocksByFirstId.set(id, block);

}

};

const finishBlock = (block: StreamingBlock) => {

const contentIndex = getContentIndex(block);

if (contentIndex === -1 || finishedBlocks.has(block)) {

}

if (toolCall.id) {

toolCallBlocksById.set(toolCall.id, block);

rememberFirstToolCallById(toolCall.id, block);

}

appendBlock(block);

stream.push({

if (!block.id && toolCall.id) {

block.id = toolCall.id;

toolCallBlocksById.set(toolCall.id, block);

rememberFirstToolCallById(toolCall.id, block);

}

if (!block.name && toolCall.function?.name) {

block.name = toolCall.function.name;

if (reasoningDetails && Array.isArray(reasoningDetails)) {

for (const detail of reasoningDetails) {

if (detail.type === "reasoning.encrypted" && detail.id && detail.data) {

const matchingToolCall = output.content.find(

(b) => b.type === "toolCall" && b.id === detail.id,

) as ToolCall | undefined;

const matchingToolCall = toolCallBlocksByFirstId.get(detail.id);

if (matchingToolCall) {

matchingToolCall.thoughtSignature = JSON.stringify(detail);

}