pi-usereq 0.49.0 → 0.50.0

package/pi.dev-src/pi-mono/ai/test/openai-completions-cache-control-format.test.ts

@@ -1,189 +0,0 @@
-import { Type } from "typebox";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { getModel } from "../src/models.js";
-import { streamOpenAICompletions } from "../src/providers/openai-completions.js";
-import type { Model } from "../src/types.js";
-
-interface CacheControl {
-	type: "ephemeral";
-	ttl?: string;
-}
-
-interface TextPart {
-	type: "text";
-	text: string;
-	cache_control?: CacheControl;
-}
-
-interface ToolWithCacheControl {
-	type: string;
-	cache_control?: CacheControl;
-}
-
-interface CapturedParams {
-	messages: Array<{
-		role: string;
-		content: string | TextPart[] | null;
-	}>;
-	tools?: ToolWithCacheControl[];
-}
-
-const mockState = vi.hoisted(() => ({
-	lastParams: undefined as CapturedParams | undefined,
-}));
-
-vi.mock("openai", () => {
-	class FakeOpenAI {
-		chat = {
-			completions: {
-				create: (params: CapturedParams) => {
-					mockState.lastParams = params;
-					const stream = {
-						async *[Symbol.asyncIterator]() {
-							yield {
-								id: "chatcmpl-test",
-								choices: [{ delta: {}, finish_reason: "stop" }],
-								usage: {
-									prompt_tokens: 1,
-									completion_tokens: 1,
-									prompt_tokens_details: { cached_tokens: 0 },
-									completion_tokens_details: { reasoning_tokens: 0 },
-								},
-							};
-						},
-					};
-					const promise = Promise.resolve(stream) as Promise<typeof stream> & {
-						withResponse: () => Promise<{
-							data: typeof stream;
-							response: { status: number; headers: Headers };
-						}>;
-					};
-					promise.withResponse = async () => ({
-						data: stream,
-						response: { status: 200, headers: new Headers() },
-					});
-					return promise;
-				},
-			},
-		};
-	}
-
-	return { default: FakeOpenAI };
-});
-
-async function capturePayload(
-	model: Model<"openai-completions">,
-	options?: { cacheRetention?: "none" | "short" | "long" },
-): Promise<CapturedParams> {
-	const timestamp = Date.now();
-
-	await streamOpenAICompletions(
-		model,
-		{
-			systemPrompt: "System prompt",
-			messages: [{ role: "user", content: "Hello", timestamp }],
-			tools: [
-				{
-					name: "read",
-					description: "Read a file",
-					parameters: Type.Object({
-						path: Type.String(),
-					}),
-				},
-			],
-		},
-		{ apiKey: "test-key", ...options },
-	).result();
-
-	if (!mockState.lastParams) {
-		throw new Error("Expected payload to be captured");
-	}
-
-	return mockState.lastParams;
-}
-
-function getInstructionMessage(params: CapturedParams) {
-	return params.messages.find((message) => message.role === "system" || message.role === "developer");
-}
-
-function expectAnthropicCacheMarkers(params: CapturedParams): void {
-	const instructionMessage = getInstructionMessage(params);
-	expect(instructionMessage).toBeDefined();
-	expect(Array.isArray(instructionMessage?.content)).toBe(true);
-	expect((instructionMessage?.content as TextPart[])[0]?.cache_control).toEqual({ type: "ephemeral" });
-
-	expect(params.tools).toHaveLength(1);
-	expect(params.tools?.[0]?.cache_control).toEqual({ type: "ephemeral" });
-
-	const lastMessage = params.messages[params.messages.length - 1];
-	expect(lastMessage.role).toBe("user");
-	expect(Array.isArray(lastMessage.content)).toBe(true);
-	expect((lastMessage.content as TextPart[])[0]?.cache_control).toEqual({ type: "ephemeral" });
-}
-
-describe("openai-completions cacheControlFormat", () => {
-	beforeEach(() => {
-		mockState.lastParams = undefined;
-	});
-
-	it("applies Anthropic-style cache markers when model compat enables them", async () => {
-		const model: Model<"openai-completions"> = {
-			id: "custom-qwen",
-			name: "Custom Qwen",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://example.com/v1",
-			reasoning: true,
-			input: ["text"],
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 128000,
-			maxTokens: 32000,
-			compat: {
-				cacheControlFormat: "anthropic",
-			},
-		};
-
-		const params = await capturePayload(model);
-		expectAnthropicCacheMarkers(params);
-	});
-
-	it("preserves Anthropic-style cache markers for OpenRouter Anthropic models", async () => {
-		const model = getModel("openrouter", "anthropic/claude-sonnet-4");
-		const params = await capturePayload(model);
-		expectAnthropicCacheMarkers(params);
-	});
-
-	it("omits Anthropic-style cache markers when cacheRetention is none", async () => {
-		const model: Model<"openai-completions"> = {
-			id: "custom-qwen",
-			name: "Custom Qwen",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://example.com/v1",
-			reasoning: true,
-			input: ["text"],
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 128000,
-			maxTokens: 32000,
-			compat: {
-				cacheControlFormat: "anthropic",
-			},
-		};
-		const params = await capturePayload(model, { cacheRetention: "none" });
-		const instructionMessage = getInstructionMessage(params);
-
-		expect(Array.isArray(instructionMessage?.content)).toBe(false);
-		expect(params.tools?.[0]?.cache_control).toBeUndefined();
-		expect(typeof params.messages[params.messages.length - 1]?.content).toBe("string");
-	});
-});

package/pi.dev-src/pi-mono/ai/test/openai-completions-prompt-cache.test.ts

@@ -1,198 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { getModel } from "../src/models.js";
-import { streamOpenAICompletions } from "../src/providers/openai-completions.js";
-import type { Model } from "../src/types.js";
-
-interface FakeOpenAIClientOptions {
-	apiKey: string;
-	baseURL: string;
-	dangerouslyAllowBrowser: boolean;
-	defaultHeaders?: Record<string, string>;
-}
-
-interface CapturedCompletionsPayload {
-	prompt_cache_key?: string;
-	prompt_cache_retention?: "24h" | "in-memory" | null;
-}
-
-const mockState = vi.hoisted(() => ({
-	lastParams: undefined as CapturedCompletionsPayload | undefined,
-	lastClientOptions: undefined as FakeOpenAIClientOptions | undefined,
-}));
-
-vi.mock("openai", () => {
-	class FakeOpenAI {
-		chat = {
-			completions: {
-				create: (params: CapturedCompletionsPayload) => {
-					mockState.lastParams = params;
-					const stream = {
-						async *[Symbol.asyncIterator]() {
-							yield {
-								choices: [{ delta: {}, finish_reason: "stop" }],
-								usage: {
-									prompt_tokens: 1,
-									completion_tokens: 1,
-									prompt_tokens_details: { cached_tokens: 0 },
-									completion_tokens_details: { reasoning_tokens: 0 },
-								},
-							};
-						},
-					};
-					const promise = Promise.resolve(stream) as Promise<typeof stream> & {
-						withResponse: () => Promise<{
-							data: typeof stream;
-							response: { status: number; headers: Headers };
-						}>;
-					};
-					promise.withResponse = async () => ({
-						data: stream,
-						response: { status: 200, headers: new Headers() },
-					});
-					return promise;
-				},
-			},
-		};
-
-		constructor(options: FakeOpenAIClientOptions) {
-			mockState.lastClientOptions = options;
-		}
-	}
-
-	return { default: FakeOpenAI };
-});
-
-describe("openai-completions prompt caching", () => {
-	const originalEnv = process.env.PI_CACHE_RETENTION;
-
-	beforeEach(() => {
-		mockState.lastParams = undefined;
-		mockState.lastClientOptions = undefined;
-		delete process.env.PI_CACHE_RETENTION;
-	});
-
-	afterEach(() => {
-		if (originalEnv === undefined) {
-			delete process.env.PI_CACHE_RETENTION;
-		} else {
-			process.env.PI_CACHE_RETENTION = originalEnv;
-		}
-	});
-
-	function createModel(overrides: Partial<Model<"openai-completions">> = {}): Model<"openai-completions"> {
-		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini");
-		return {
-			...(baseModel as Omit<Model<"openai-completions">, "api">),
-			api: "openai-completions",
-			...overrides,
-		};
-	}
-
-	async function captureRequest(
-		options?: {
-			cacheRetention?: "none" | "short" | "long";
-			sessionId?: string;
-			headers?: Record<string, string>;
-		},
-		model: Model<"openai-completions"> = createModel(),
-	) {
-		await streamOpenAICompletions(
-			model,
-			{
-				systemPrompt: "sys",
-				messages: [{ role: "user", content: "hi", timestamp: Date.now() }],
-			},
-			{ apiKey: "test-key", ...options },
-		).result();
-
-		return {
-			payload: mockState.lastParams,
-			headers: mockState.lastClientOptions?.defaultHeaders ?? {},
-		};
-	}
-
-	it("sets prompt_cache_key for direct OpenAI requests when caching is enabled", async () => {
-		const { payload } = await captureRequest({ sessionId: "session-123" });
-
-		expect(payload?.prompt_cache_key).toBe("session-123");
-		expect(payload?.prompt_cache_retention).toBeUndefined();
-	});
-
-	it("sets prompt_cache_retention to 24h for direct OpenAI requests when cacheRetention is long", async () => {
-		const { payload } = await captureRequest({ cacheRetention: "long", sessionId: "session-456" });
-
-		expect(payload?.prompt_cache_key).toBe("session-456");
-		expect(payload?.prompt_cache_retention).toBe("24h");
-	});
-
-	it("omits prompt cache fields when cacheRetention is none", async () => {
-		const { payload } = await captureRequest({ cacheRetention: "none", sessionId: "session-789" });
-
-		expect(payload?.prompt_cache_key).toBeUndefined();
-		expect(payload?.prompt_cache_retention).toBeUndefined();
-	});
-
-	it("omits prompt cache fields for non-OpenAI base URLs", async () => {
-		const model = createModel({
-			baseUrl: "https://proxy.example.com/v1",
-		});
-		const { payload } = await captureRequest({ cacheRetention: "long", sessionId: "session-proxy" }, model);
-
-		expect(payload?.prompt_cache_key).toBeUndefined();
-		expect(payload?.prompt_cache_retention).toBeUndefined();
-	});
-
-	it("uses PI_CACHE_RETENTION for direct OpenAI requests", async () => {
-		process.env.PI_CACHE_RETENTION = "long";
-		const { payload } = await captureRequest({ sessionId: "session-env" });
-
-		expect(payload?.prompt_cache_key).toBe("session-env");
-		expect(payload?.prompt_cache_retention).toBe("24h");
-	});
-
-	it("sends known session-affinity headers when compat.sendSessionAffinityHeaders is enabled", async () => {
-		const model = createModel({
-			baseUrl: "https://proxy.example.com/v1",
-			compat: { sendSessionAffinityHeaders: true },
-		});
-		const { headers } = await captureRequest({ sessionId: "session-affinity" }, model);
-
-		expect(headers.session_id).toBe("session-affinity");
-		expect(headers["x-client-request-id"]).toBe("session-affinity");
-		expect(headers["x-session-affinity"]).toBe("session-affinity");
-	});
-
-	it("omits session-affinity headers when cacheRetention is none", async () => {
-		const model = createModel({
-			baseUrl: "https://proxy.example.com/v1",
-			compat: { sendSessionAffinityHeaders: true },
-		});
-		const { headers } = await captureRequest({ cacheRetention: "none", sessionId: "session-affinity" }, model);
-
-		expect(headers.session_id).toBeUndefined();
-		expect(headers["x-client-request-id"]).toBeUndefined();
-		expect(headers["x-session-affinity"]).toBeUndefined();
-	});
-
-	it("lets explicit headers override generated session-affinity headers", async () => {
-		const model = createModel({
-			baseUrl: "https://proxy.example.com/v1",
-			compat: { sendSessionAffinityHeaders: true },
-		});
-		const { headers } = await captureRequest(
-			{
-				sessionId: "session-affinity",
-				headers: {
-					session_id: "override-session",
-					"x-client-request-id": "override-request",
-					"x-session-affinity": "override-affinity",
-				},
-			},
-			model,
-		);
-
-		expect(headers.session_id).toBe("override-session");
-		expect(headers["x-client-request-id"]).toBe("override-request");
-		expect(headers["x-session-affinity"]).toBe("override-affinity");
-	});
-});

package/pi.dev-src/pi-mono/ai/test/openai-completions-thinking-as-text.test.ts

@@ -1,214 +0,0 @@
-import { once } from "node:events";
-import http from "node:http";
-import type { AddressInfo } from "node:net";
-import { afterEach, describe, expect, it } from "vitest";
-import { convertMessages, streamOpenAICompletions } from "../src/providers/openai-completions.js";
-import type {
-	AssistantMessage,
-	AssistantMessageEvent,
-	Context,
-	Model,
-	OpenAICompletionsCompat,
-	Usage,
-} from "../src/types.js";
-
-const emptyUsage: Usage = {
-	input: 0,
-	output: 0,
-	cacheRead: 0,
-	cacheWrite: 0,
-	totalTokens: 0,
-	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-};
-
-const compat = {
-	supportsStore: true,
-	supportsDeveloperRole: true,
-	supportsReasoningEffort: true,
-	reasoningEffortMap: {},
-	supportsUsageInStreaming: true,
-	maxTokensField: "max_completion_tokens",
-	requiresToolResultName: false,
-	requiresAssistantAfterToolResult: false,
-	requiresThinkingAsText: true,
-	thinkingFormat: "openai",
-	openRouterRouting: {},
-	vercelGatewayRouting: {},
-	zaiToolStream: false,
-	supportsStrictMode: true,
-	cacheControlFormat: undefined,
-	sendSessionAffinityHeaders: false,
-} satisfies Required<Omit<OpenAICompletionsCompat, "cacheControlFormat">> & {
-	cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
-};
-
-function buildModel(baseUrl = "http://127.0.0.1:1"): Model<"openai-completions"> {
-	return {
-		id: "repro-model",
-		name: "Repro Model",
-		api: "openai-completions",
-		provider: "repro-provider",
-		baseUrl,
-		reasoning: true,
-		input: ["text"],
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: 128000,
-		maxTokens: 4096,
-		compat,
-	};
-}
-
-function buildAssistant(content: AssistantMessage["content"]): AssistantMessage {
-	return {
-		role: "assistant",
-		content,
-		api: "openai-completions",
-		provider: "repro-provider",
-		model: "repro-model",
-		usage: emptyUsage,
-		stopReason: "stop",
-		timestamp: 2,
-	};
-}
-
-function buildContext(assistant: AssistantMessage): Context {
-	return {
-		messages: [
-			{ role: "user", content: "hello", timestamp: 1 },
-			assistant,
-			{ role: "user", content: "continue", timestamp: 3 },
-		],
-	};
-}
-
-async function collectEvents(stream: AsyncIterable<AssistantMessageEvent>): Promise<AssistantMessageEvent[]> {
-	const events: AssistantMessageEvent[] = [];
-	for await (const event of stream) {
-		events.push(event);
-	}
-	return events;
-}
-
-interface ChatCompletionsRequestBody {
-	model: string;
-	messages: Array<{ role: string; content?: unknown }>;
-	stream: boolean;
-	stream_options?: { include_usage?: boolean };
-}
-
-describe("openai-completions thinking-as-text replay", () => {
-	afterEach(() => {
-		delete process.env.OPENAI_API_KEY;
-	});
-
-	it("serializes same-model thinking-plus-text replay as assistant text parts", () => {
-		const messages = convertMessages(
-			buildModel(),
-			buildContext(
-				buildAssistant([
-					{ type: "thinking", thinking: "internal reasoning" },
-					{ type: "text", text: "visible answer" },
-				]),
-			),
-			compat,
-		);
-
-		expect(messages[1]).toEqual({
-			role: "assistant",
-			content: [
-				{ type: "text", text: "internal reasoning" },
-				{ type: "text", text: "visible answer" },
-			],
-		});
-	});
-
-	it("serializes same-model thinking-only replay as assistant text parts", () => {
-		const messages = convertMessages(
-			buildModel(),
-			buildContext(buildAssistant([{ type: "thinking", thinking: "internal reasoning" }])),
-			compat,
-		);
-
-		expect(messages[1]).toEqual({
-			role: "assistant",
-			content: [{ type: "text", text: "internal reasoning" }],
-		});
-	});
-
-	it("reaches the endpoint when replay contains both thinking and text", async () => {
-		const requestBodies: ChatCompletionsRequestBody[] = [];
-		const server = http.createServer(async (req, res) => {
-			if (req.method !== "POST" || req.url !== "/chat/completions") {
-				res.writeHead(404).end();
-				return;
-			}
-
-			let body = "";
-			for await (const chunk of req) {
-				body += chunk.toString();
-			}
-			requestBodies.push(JSON.parse(body) as ChatCompletionsRequestBody);
-
-			res.writeHead(200, {
-				"content-type": "text/event-stream",
-				"cache-control": "no-cache",
-				connection: "keep-alive",
-			});
-			res.write(
-				`data: ${JSON.stringify({
-					id: "chatcmpl-repro",
-					object: "chat.completion.chunk",
-					created: 0,
-					model: "repro-model",
-					choices: [{ index: 0, delta: { role: "assistant", content: "ok" }, finish_reason: null }],
-				})}\n\n`,
-			);
-			res.write(
-				`data: ${JSON.stringify({
-					id: "chatcmpl-repro",
-					object: "chat.completion.chunk",
-					created: 0,
-					model: "repro-model",
-					choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-					usage: { prompt_tokens: 1, completion_tokens: 1 },
-				})}\n\n`,
-			);
-			res.write("data: [DONE]\n\n");
-			res.end();
-		});
-
-		server.listen(0, "127.0.0.1");
-		await once(server, "listening");
-
-		try {
-			const { port } = server.address() as AddressInfo;
-			const events = await collectEvents(
-				streamOpenAICompletions(
-					buildModel(`http://127.0.0.1:${port}`),
-					buildContext(
-						buildAssistant([
-							{ type: "thinking", thinking: "internal reasoning" },
-							{ type: "text", text: "visible answer" },
-						]),
-					),
-					{ apiKey: "test-key" },
-				),
-			);
-
-			expect(requestBodies).toHaveLength(1);
-			expect(requestBodies[0]?.messages[1]).toEqual({
-				role: "assistant",
-				content: [
-					{ type: "text", text: "internal reasoning" },
-					{ type: "text", text: "visible answer" },
-				],
-			});
-
-			const terminalEvent = events.at(-1);
-			expect(terminalEvent?.type).toBe("done");
-		} finally {
-			server.close();
-			await once(server, "close");
-		}
-	});
-});