pi-usereq 0.6.0 → 0.10.0

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

@@ -0,0 +1,189 @@
+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

@@ -0,0 +1,198 @@
+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

@@ -0,0 +1,214 @@
+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");
+		}
+	});
+});