pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/ai/test/openai-completions-tool-choice.test.ts

@@ -1,560 +0,0 @@
-import { Type } from "typebox";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { getModel } from "../src/models.js";
-import { streamSimple } from "../src/stream.js";
-import type { Tool } from "../src/types.js";
-
-const mockState = vi.hoisted(() => ({
-	lastParams: undefined as unknown,
-	chunks: undefined as
-		| Array<null | {
-				id?: string;
-				choices?: Array<{ delta: Record<string, unknown>; finish_reason: string | null; usage?: unknown }>;
-				usage?: {
-					prompt_tokens: number;
-					completion_tokens: number;
-					prompt_tokens_details: { cached_tokens: number; cache_write_tokens?: number };
-					completion_tokens_details: { reasoning_tokens: number };
-				};
-		  }>
-		| undefined,
-}));
-
-vi.mock("openai", () => {
-	class FakeOpenAI {
-		chat = {
-			completions: {
-				create: (params: unknown) => {
-					mockState.lastParams = params;
-					const stream = {
-						async *[Symbol.asyncIterator]() {
-							const chunks = mockState.chunks ?? [
-								{
-									choices: [{ delta: {}, finish_reason: "stop" }],
-									usage: {
-										prompt_tokens: 1,
-										completion_tokens: 1,
-										prompt_tokens_details: { cached_tokens: 0 },
-										completion_tokens_details: { reasoning_tokens: 0 },
-									},
-								},
-							];
-							for (const chunk of chunks) {
-								yield chunk;
-							}
-						},
-					};
-					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 };
-});
-
-describe("openai-completions tool_choice", () => {
-	beforeEach(() => {
-		mockState.lastParams = undefined;
-		mockState.chunks = undefined;
-	});
-
-	it("forwards toolChoice from simple options to payload", async () => {
-		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
-		const model = { ...baseModel, api: "openai-completions" } as const;
-		const tools: Tool[] = [
-			{
-				name: "ping",
-				description: "Ping tool",
-				parameters: Type.Object({
-					ok: Type.Boolean(),
-				}),
-			},
-		];
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Call ping with ok=true",
-						timestamp: Date.now(),
-					},
-				],
-				tools,
-			},
-			{
-				apiKey: "test",
-				toolChoice: "required",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			} as unknown as Parameters<typeof streamSimple>[2],
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { tool_choice?: string; tools?: unknown[] };
-		expect(params.tool_choice).toBe("required");
-		expect(Array.isArray(params.tools)).toBe(true);
-		expect(params.tools?.length ?? 0).toBeGreaterThan(0);
-	});
-
-	it("omits strict when compat disables strict mode", async () => {
-		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
-		const model = {
-			...baseModel,
-			api: "openai-completions",
-			compat: { supportsStrictMode: false },
-		} as const;
-		const tools: Tool[] = [
-			{
-				name: "ping",
-				description: "Ping tool",
-				parameters: Type.Object({
-					ok: Type.Boolean(),
-				}),
-			},
-		];
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Call ping with ok=true",
-						timestamp: Date.now(),
-					},
-				],
-				tools,
-			},
-			{
-				apiKey: "test",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			} as unknown as Parameters<typeof streamSimple>[2],
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { tools?: Array<{ function?: Record<string, unknown> }> };
-		const tool = params.tools?.[0]?.function;
-		expect(tool).toBeTruthy();
-		expect(tool?.strict).toBeUndefined();
-		expect("strict" in (tool ?? {})).toBe(false);
-	});
-
-	it("maps groq qwen3 reasoning levels to default reasoning_effort", async () => {
-		const model = getModel("groq", "qwen/qwen3-32b")!;
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Hi",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{
-				apiKey: "test",
-				reasoning: "medium",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			},
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { reasoning_effort?: string };
-		expect(params.reasoning_effort).toBe("default");
-	});
-
-	it("keeps normal reasoning_effort for groq models without compat mapping", async () => {
-		const model = getModel("groq", "openai/gpt-oss-20b")!;
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Hi",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{
-				apiKey: "test",
-				reasoning: "medium",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			},
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { reasoning_effort?: string };
-		expect(params.reasoning_effort).toBe("medium");
-	});
-
-	it("enables tool_stream for supported z.ai models with tools", async () => {
-		const model = getModel("zai", "glm-5")!;
-		const tools: Tool[] = [
-			{
-				name: "ping",
-				description: "Ping tool",
-				parameters: Type.Object({
-					ok: Type.Boolean(),
-				}),
-			},
-		];
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Call ping with ok=true",
-						timestamp: Date.now(),
-					},
-				],
-				tools,
-			},
-			{
-				apiKey: "test",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			},
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
-		expect(params.tool_stream).toBe(true);
-	});
-
-	it("stores z.ai tool_stream support in model compat metadata", () => {
-		expect(getModel("zai", "glm-5")?.compat?.zaiToolStream).toBe(true);
-		expect(getModel("zai", "glm-4.7")?.compat?.zaiToolStream).toBe(true);
-		expect(getModel("zai", "glm-4.7-flash")?.compat?.zaiToolStream).toBe(true);
-		expect(getModel("zai", "glm-4.6v")?.compat?.zaiToolStream).toBe(true);
-		expect(getModel("zai", "glm-4.5-air")?.compat?.zaiToolStream).toBeUndefined();
-	});
-
-	it("omits tool_stream for unsupported z.ai models", async () => {
-		const model = getModel("zai", "glm-4.5-air")!;
-		const tools: Tool[] = [
-			{
-				name: "ping",
-				description: "Ping tool",
-				parameters: Type.Object({
-					ok: Type.Boolean(),
-				}),
-			},
-		];
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Call ping with ok=true",
-						timestamp: Date.now(),
-					},
-				],
-				tools,
-			},
-			{
-				apiKey: "test",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			},
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
-		expect(params.tool_stream).toBeUndefined();
-	});
-
-	it("respects explicit z.ai tool_stream compat override", async () => {
-		const baseModel = getModel("zai", "glm-4.5-air")!;
-		const model = {
-			...baseModel,
-			compat: {
-				...baseModel.compat,
-				zaiToolStream: true,
-			},
-		} as const;
-		const tools: Tool[] = [
-			{
-				name: "ping",
-				description: "Ping tool",
-				parameters: Type.Object({
-					ok: Type.Boolean(),
-				}),
-			},
-		];
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Call ping with ok=true",
-						timestamp: Date.now(),
-					},
-				],
-				tools,
-			},
-			{
-				apiKey: "test",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			},
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
-		expect(params.tool_stream).toBe(true);
-	});
-
-	it("omits tool_stream when no tools are provided", async () => {
-		const model = getModel("zai", "glm-5")!;
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Hi",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{
-				apiKey: "test",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			},
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
-		expect(params.tool_stream).toBeUndefined();
-	});
-
-	it("maps non-standard provider finish_reason values to stopReason error", async () => {
-		mockState.chunks = [
-			{
-				choices: [{ delta: { content: "partial" }, finish_reason: null }],
-			},
-			{
-				choices: [{ delta: {}, finish_reason: "network_error" }],
-				usage: {
-					prompt_tokens: 1,
-					completion_tokens: 1,
-					prompt_tokens_details: { cached_tokens: 0 },
-					completion_tokens_details: { reasoning_tokens: 0 },
-				},
-			},
-		];
-
-		const model = getModel("zai", "glm-5")!;
-		const response = await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Hi",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{ apiKey: "test" },
-		).result();
-
-		expect(response.stopReason).toBe("error");
-		expect(response.errorMessage).toBe("Provider finish_reason: network_error");
-	});
-
-	it("ignores null stream chunks from openai-compatible providers", async () => {
-		mockState.chunks = [
-			null,
-			{
-				id: "chatcmpl-test",
-				choices: [{ delta: { content: "OK" }, finish_reason: null }],
-			},
-			{
-				id: "chatcmpl-test",
-				choices: [{ delta: {}, finish_reason: "stop" }],
-				usage: {
-					prompt_tokens: 3,
-					completion_tokens: 1,
-					prompt_tokens_details: { cached_tokens: 0 },
-					completion_tokens_details: { reasoning_tokens: 0 },
-				},
-			},
-		];
-
-		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
-		const model = { ...baseModel, api: "openai-completions" } as const;
-		const response = await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Reply with exactly OK",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{ apiKey: "test" },
-		).result();
-
-		expect(response.stopReason).toBe("stop");
-		expect(response.errorMessage).toBeUndefined();
-		expect(response.responseId).toBe("chatcmpl-test");
-		expect(response.usage.totalTokens).toBe(4);
-		expect(response.content).toEqual([{ type: "text", text: "OK" }]);
-	});
-
-	it("preserves prompt_tokens_details.cache_write_tokens from chunk usage", async () => {
-		mockState.chunks = [
-			{
-				id: "chatcmpl-cache-write",
-				choices: [{ delta: { content: "OK" }, finish_reason: null }],
-			},
-			{
-				id: "chatcmpl-cache-write",
-				choices: [{ delta: {}, finish_reason: "stop" }],
-				usage: {
-					prompt_tokens: 100,
-					completion_tokens: 5,
-					prompt_tokens_details: { cached_tokens: 50, cache_write_tokens: 30 },
-					completion_tokens_details: { reasoning_tokens: 0 },
-				},
-			},
-		];
-
-		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
-		const model = { ...baseModel, api: "openai-completions" } as const;
-		const response = await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Reply with exactly OK",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{ apiKey: "test" },
-		).result();
-
-		expect(response.usage.input).toBe(50);
-		expect(response.usage.cacheRead).toBe(20);
-		expect(response.usage.cacheWrite).toBe(30);
-		expect(response.usage.totalTokens).toBe(105);
-	});
-
-	it("preserves prompt_tokens_details.cache_write_tokens from choice usage fallback", async () => {
-		mockState.chunks = [
-			{
-				id: "chatcmpl-cache-write-choice",
-				choices: [{ delta: { content: "OK" }, finish_reason: null }],
-			},
-			{
-				id: "chatcmpl-cache-write-choice",
-				choices: [
-					{
-						delta: {},
-						finish_reason: "stop",
-						usage: {
-							prompt_tokens: 100,
-							completion_tokens: 5,
-							prompt_tokens_details: { cached_tokens: 50, cache_write_tokens: 30 },
-							completion_tokens_details: { reasoning_tokens: 0 },
-						},
-					},
-				],
-			},
-		];
-
-		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
-		const model = { ...baseModel, api: "openai-completions" } as const;
-		const response = await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Reply with exactly OK",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{ apiKey: "test" },
-		).result();
-
-		expect(response.usage.input).toBe(50);
-		expect(response.usage.cacheRead).toBe(20);
-		expect(response.usage.cacheWrite).toBe(30);
-		expect(response.usage.totalTokens).toBe(105);
-	});
-
-	it("uses OpenRouter reasoning object instead of reasoning_effort", async () => {
-		const model = getModel("openrouter", "deepseek/deepseek-r1")!;
-		let payload: unknown;
-
-		await streamSimple(
-			model,
-			{
-				messages: [
-					{
-						role: "user",
-						content: "Hi",
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{
-				apiKey: "test",
-				reasoning: "high",
-				onPayload: (params: unknown) => {
-					payload = params;
-				},
-			},
-		).result();
-
-		const params = (payload ?? mockState.lastParams) as {
-			reasoning?: { effort?: string };
-			reasoning_effort?: string;
-		};
-		expect(params.reasoning).toEqual({ effort: "high" });
-		expect(params.reasoning_effort).toBeUndefined();
-	});
-});

package/pi.dev-src/pi-mono/ai/test/openai-completions-tool-result-images.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getModel } from "../src/models.js";
-import { convertMessages } from "../src/providers/openai-completions.js";
-import type {
-	AssistantMessage,
-	Context,
-	Model,
-	OpenAICompletionsCompat,
-	ToolResultMessage,
-	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: Required<OpenAICompletionsCompat> = {
-	supportsStore: true,
-	supportsDeveloperRole: true,
-	supportsReasoningEffort: true,
-	reasoningEffortMap: {},
-	supportsUsageInStreaming: true,
-	maxTokensField: "max_completion_tokens",
-	requiresToolResultName: false,
-	requiresAssistantAfterToolResult: false,
-	requiresThinkingAsText: false,
-	thinkingFormat: "openai",
-	openRouterRouting: {},
-	vercelGatewayRouting: {},
-	zaiToolStream: false,
-	supportsStrictMode: true,
-	cacheControlFormat: "anthropic",
-	sendSessionAffinityHeaders: false,
-};
-
-function buildToolResult(toolCallId: string, timestamp: number): ToolResultMessage {
-	return {
-		role: "toolResult",
-		toolCallId,
-		toolName: "read",
-		content: [
-			{ type: "text", text: "Read image file [image/png]" },
-			{ type: "image", data: "ZmFrZQ==", mimeType: "image/png" },
-		],
-		isError: false,
-		timestamp,
-	};
-}
-
-describe("openai-completions convertMessages", () => {
-	it("batches tool-result images after consecutive tool results", () => {
-		const baseModel = getModel("openai", "gpt-4o-mini");
-		const model: Model<"openai-completions"> = {
-			...baseModel,
-			api: "openai-completions",
-			input: ["text", "image"],
-		};
-
-		const now = Date.now();
-		const assistantMessage: AssistantMessage = {
-			role: "assistant",
-			content: [
-				{ type: "toolCall", id: "tool-1", name: "read", arguments: { path: "img-1.png" } },
-				{ type: "toolCall", id: "tool-2", name: "read", arguments: { path: "img-2.png" } },
-			],
-			api: model.api,
-			provider: model.provider,
-			model: model.id,
-			usage: emptyUsage,
-			stopReason: "toolUse",
-			timestamp: now,
-		};
-
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Read the images", timestamp: now - 2 },
-				assistantMessage,
-				buildToolResult("tool-1", now + 1),
-				buildToolResult("tool-2", now + 2),
-			],
-		};
-
-		const messages = convertMessages(model, context, compat);
-		const roles = messages.map((message) => message.role);
-		expect(roles).toEqual(["user", "assistant", "tool", "tool", "user"]);
-
-		const imageMessage = messages[messages.length - 1];
-		expect(imageMessage.role).toBe("user");
-		expect(Array.isArray(imageMessage.content)).toBe(true);
-
-		const imageParts = (imageMessage.content as Array<{ type?: string }>).filter(
-			(part) => part?.type === "image_url",
-		);
-		expect(imageParts.length).toBe(2);
-	});
-});

package/pi.dev-src/pi-mono/ai/test/openai-responses-cache-affinity-e2e.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getModel } from "../src/models.js";
-import { complete } from "../src/stream.js";
-import type { Context } from "../src/types.js";
-
-describe.skipIf(!process.env.OPENAI_API_KEY)("openai responses cache affinity e2e", () => {
-	it("handles direct OpenAI Responses requests with aligned cache-affinity identifiers", { retry: 2 }, async () => {
-		const model = getModel("openai", "gpt-5.4");
-		const sessionId = "0195d6e4-4cf9-7f44-a2d8-f8f7f49ee9d3";
-		const context: Context = {
-			systemPrompt: "You are a helpful assistant. Reply exactly as requested.",
-			messages: [
-				{
-					role: "user",
-					content: "Reply with exactly: openai cache affinity e2e success",
-					timestamp: Date.now(),
-				},
-			],
-		};
-
-		const response = await complete(model, context, {
-			apiKey: process.env.OPENAI_API_KEY!,
-			sessionId,
-		});
-
-		expect(response.stopReason, response.errorMessage).not.toBe("error");
-		expect(response.errorMessage).toBeUndefined();
-		expect(response.content.map((block) => (block.type === "text" ? block.text : "")).join("")).toContain(
-			"openai cache affinity e2e success",
-		);
-	});
-});