type PayloadHook = (payload: unknown, payloadModel: unknown) => Promise<unknown>;

function streamAnthropicCall(streamAnthropicMock: ReturnType<typeof vi.fn>): unknown[] {

const call = streamAnthropicMock.mock.calls.at(0);

if (!call) {

throw new Error("Expected streamAnthropic call");

}

return call;

}

function streamTransportOptions(

streamAnthropicMock: ReturnType<typeof vi.fn>,

): Record<string, unknown> {

const options = streamAnthropicCall(streamAnthropicMock).at(2);

if (!options || typeof options !== "object") {

throw new Error("Expected streamAnthropic transport options");

}

return options as Record<string, unknown>;

}

function captureCacheBoundaryPayloadHook(

onPayload: PayloadHook,

deps: AnthropicVertexStreamDeps,

} as never,

);

const transportOptions = streamAnthropicMock.mock.calls[0]?.[2] as {

onPayload?: PayloadHook;

};

const transportOptions = streamTransportOptions(streamAnthropicMock);

return { model, onPayload: transportOptions.onPayload };

return { model, onPayload: transportOptions.onPayload as PayloadHook | undefined };

}

function buildExpectedCacheBoundaryPayload(messageText: string) {

void streamFn(model, { messages: [] }, {});

const transportOptions = streamAnthropicMock.mock.calls[0]?.[2] as

| { maxTokens?: number }

| undefined;

expect(transportOptions?.maxTokens).toBe(128000);

expect(streamTransportOptions(streamAnthropicMock).maxTokens).toBe(128000);

});

it("clamps explicit maxTokens to the selected model limit", () => {

void streamFn(model, { messages: [] }, { maxTokens: 999999 });

const transportOptions = streamAnthropicMock.mock.calls[0]?.[2] as

| { maxTokens?: number }

| undefined;

expect(transportOptions?.maxTokens).toBe(128000);

expect(streamTransportOptions(streamAnthropicMock).maxTokens).toBe(128000);

});

it("maps xhigh reasoning to max effort for adaptive Opus models", () => {

void streamFn(model, { messages: [] }, { reasoning: "xhigh" });

const transportOptions = streamAnthropicMock.mock.calls[0]?.[2] as

| { effort?: string; thinkingEnabled?: boolean }

| undefined;

expect(transportOptions?.thinkingEnabled).toBe(true);

expect(transportOptions?.effort).toBe("max");

const transportOptions = streamTransportOptions(streamAnthropicMock);

expect(transportOptions.thinkingEnabled).toBe(true);

expect(transportOptions.effort).toBe("max");

});

it("maps xhigh reasoning to xhigh effort for Opus 4.7", () => {

void streamFn(model, { messages: [] }, { reasoning: "xhigh" });

const transportOptions = streamAnthropicMock.mock.calls[0]?.[2] as

| { effort?: string; thinkingEnabled?: boolean }

| undefined;

expect(transportOptions?.thinkingEnabled).toBe(true);

expect(transportOptions?.effort).toBe("xhigh");

const transportOptions = streamTransportOptions(streamAnthropicMock);

expect(transportOptions.thinkingEnabled).toBe(true);

expect(transportOptions.effort).toBe("xhigh");

});

it("applies Anthropic cache-boundary shaping before forwarding payload hooks", async () => {

void streamFn(model, { messages: [] }, { maxTokens: Number.NaN });

expect(streamAnthropicMock).toHaveBeenCalledTimes(1);

const [calledModel, payload, transportOptions] = streamAnthropicMock.mock.calls[0] ?? [];

const [calledModel, payload, transportOptions] = streamAnthropicCall(streamAnthropicMock);

expect(calledModel).toBe(model);

expect(payload).toEqual({ messages: [] });

expect(transportOptions).toBeTypeOf("object");