return Array.isArray(content) ? (content as Array<Record<string, any>>) : [];

}

function mockCallAt(

mock: { mock: { calls: ReadonlyArray<ReadonlyArray<unknown>> } },

index: number,

): ReadonlyArray<unknown> | undefined {

const calls = mock.mock.calls;

const normalizedIndex = index < 0 ? calls.length + index : index;

return calls[normalizedIndex];

}

function lastRespondCall(respond: ReturnType<typeof vi.fn>) {

return respond.mock.calls.at(-1) as

return mockCallAt(respond, -1) as

| [boolean, Record<string, any> | undefined, Record<string, any> | undefined]

| undefined;

}

}

function lastBroadcastPayload(context: ChatContext): Record<string, any> | undefined {

const chatCall = (context.broadcast as unknown as ReturnType<typeof vi.fn>).mock.calls.at(-1);

const chatCall = mockCallAt(context.broadcast as unknown as ReturnType<typeof vi.fn>, -1);

expect(chatCall?.[0]).toBe("chat");

return chatCall?.[1] as Record<string, any> | undefined;

}

function lastNodeSendCall(context: ChatContext) {

return (context.nodeSendToSession as unknown as ReturnType<typeof vi.fn>).mock.calls.at(-1) as

return mockCallAt(context.nodeSendToSession as unknown as ReturnType<typeof vi.fn>, -1) as

| [string, string, Record<string, any>]

| undefined;

}

waitForCompletion?: boolean;

waitForDedupe?: boolean;

waitFor?: NonStreamingChatSendWaitFor;

}) {

}): Promise<Record<string, any> | undefined> {

const sendParams: {

sessionKey: string;

message: string;

).toBe(1);

});

const chatCall = (params.context.broadcast as unknown as ReturnType<typeof vi.fn>).mock.calls.at(

0,

);

const chatCall = mockCallAt(params.context.broadcast as unknown as ReturnType<typeof vi.fn>, 0);

expect(chatCall?.[0]).toBe("chat");

return chatCall?.[1];

return chatCall?.[1] as Record<string, any> | undefined;

}

describe("chat directive tag stripping for non-streaming final payloads", () => {

});

expect(respond).toHaveBeenCalled();

const chatCall = (context.broadcast as unknown as ReturnType<typeof vi.fn>).mock.calls.at(-1);

const chatCall = mockCallAt(context.broadcast as unknown as ReturnType<typeof vi.fn>, -1);

expect(chatCall?.[0]).toBe("chat");

expect(extractFirstTextBlock(chatCall?.[1])).toBe("hello");

});

expect(payload).toBeUndefined();

expect(error?.code).toBe(ErrorCodes.UNAVAILABLE);

expect(responseErrorMessage(error)).toMatch(/ENOSPC|non-image attachments/i);

const unavailableLogCall = (

context.logGateway.error as unknown as ReturnType<typeof vi.fn>

).mock.calls.at(0) as [string, Record<string, string>] | undefined;

const unavailableLogCall = mockCallAt(

context.logGateway.error as unknown as ReturnType<typeof vi.fn>,

0,

) as [string, Record<string, string>] | undefined;

expect(unavailableLogCall?.[0]).toBe("chat.send attachment parse/stage failed");

expect(unavailableLogCall?.[1].consoleMessage).toContain(

"chat.send attachment parse/stage failed: MediaOffloadError",