pi-usereq 0.48.0 → 0.50.0

package/pi.dev-src/pi-mono/ai/test/openai-responses-copilot-provider.test.ts

@@ -1,128 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { getModel } from "../src/models.js";
-import { streamOpenAIResponses } from "../src/providers/openai-responses.js";
-import type { Model } from "../src/types.js";
-
-type CapturedHeaders = Headers | string[][] | Record<string, string | readonly string[]> | undefined;
-
-function getHeader(headers: CapturedHeaders, name: string): string | null {
-	if (!headers) return null;
-	if (headers instanceof Headers) return headers.get(name);
-
-	const lowerName = name.toLowerCase();
-	if (Array.isArray(headers)) {
-		const match = headers.find(([key]) => key?.toLowerCase() === lowerName);
-		return match?.[1] ?? null;
-	}
-
-	for (const [key, value] of Object.entries(headers)) {
-		if (key.toLowerCase() === lowerName) return typeof value === "string" ? value : value.join(", ");
-	}
-	return null;
-}
-
-async function captureOpenAIResponseHeaders(
-	options: Parameters<typeof streamOpenAIResponses>[2],
-	model: Model<"openai-responses"> = getModel("openai", "gpt-5.4"),
-): Promise<{ sessionId: string | null; clientRequestId: string | null }> {
-	const captured = { sessionId: null as string | null, clientRequestId: null as string | null };
-	vi.spyOn(globalThis, "fetch").mockImplementation(async (_input, init) => {
-		captured.sessionId = getHeader(init?.headers, "session_id");
-		captured.clientRequestId = getHeader(init?.headers, "x-client-request-id");
-		return new Response("data: [DONE]\n\n", {
-			status: 200,
-			headers: { "content-type": "text/event-stream" },
-		});
-	});
-
-	const stream = streamOpenAIResponses(
-		model,
-		{
-			systemPrompt: "sys",
-			messages: [{ role: "user", content: "hi", timestamp: Date.now() }],
-		},
-		{ apiKey: "test-key", ...options },
-	);
-
-	for await (const event of stream) {
-		if (event.type === "done" || event.type === "error") break;
-	}
-
-	return captured;
-}
-
-describe("openai-responses provider defaults", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("omits reasoning when no reasoning is requested", async () => {
-		const model = getModel("github-copilot", "gpt-5-mini");
-		let capturedPayload: unknown;
-
-		vi.spyOn(globalThis, "fetch").mockResolvedValue(
-			new Response("data: [DONE]\n\n", {
-				status: 200,
-				headers: { "content-type": "text/event-stream" },
-			}),
-		);
-
-		const stream = streamOpenAIResponses(
-			model,
-			{
-				systemPrompt: "sys",
-				messages: [{ role: "user", content: "hi", timestamp: Date.now() }],
-			},
-			{
-				apiKey: "test-key",
-				onPayload: (payload) => {
-					capturedPayload = payload;
-				},
-			},
-		);
-
-		for await (const event of stream) {
-			if (event.type === "done" || event.type === "error") break;
-		}
-
-		expect(capturedPayload).not.toBeNull();
-		expect(capturedPayload).not.toMatchObject({
-			reasoning: expect.anything(),
-		});
-	});
-
-	it("sets cache-affinity headers for official OpenAI Responses requests with a sessionId", async () => {
-		const captured = await captureOpenAIResponseHeaders({ sessionId: "session-123" });
-
-		expect(captured).toEqual({ sessionId: "session-123", clientRequestId: "session-123" });
-	});
-
-	it("sets cache-affinity headers for proxy OpenAI Responses requests with a sessionId", async () => {
-		const proxyModel: Model<"openai-responses"> = {
-			...getModel("openai", "gpt-5.4"),
-			provider: "opencode",
-			baseUrl: "https://proxy.example.com/v1",
-		};
-		const captured = await captureOpenAIResponseHeaders({ sessionId: "session-123" }, proxyModel);
-
-		expect(captured).toEqual({ sessionId: "session-123", clientRequestId: "session-123" });
-	});
-
-	it("lets explicit headers override the default OpenAI cache-affinity headers", async () => {
-		const captured = await captureOpenAIResponseHeaders({
-			sessionId: "session-123",
-			headers: {
-				session_id: "override-session",
-				"x-client-request-id": "override-request",
-			},
-		});
-
-		expect(captured).toEqual({ sessionId: "override-session", clientRequestId: "override-request" });
-	});
-
-	it("omits OpenAI cache-affinity headers when cacheRetention is none", async () => {
-		const captured = await captureOpenAIResponseHeaders({ cacheRetention: "none", sessionId: "session-123" });
-
-		expect(captured).toEqual({ sessionId: null, clientRequestId: null });
-	});
-});

package/pi.dev-src/pi-mono/ai/test/openai-responses-foreign-toolcall-id.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getModel } from "../src/models.js";
-import { convertResponsesMessages } from "../src/providers/openai-responses-shared.js";
-import type { AssistantMessage, Context, ToolResultMessage, Usage } from "../src/types.js";
-import { shortHash } from "../src/utils/hash.js";
-
-const COPILOT_RAW_TOOL_CALL_ID =
-	"call_4VnzVawQXPB9MgYib7CiQFEY|I9b95oN1wD/cHXKTw3PpRkL6KkCtzTJhUxMouMWYwHeTo2j3htzfSk7YPx2vifiIM4g3A8XXyOj8q4Bt6SLUG7gqY1E3ELkrkVQNHglRfUmWj84lqxJY+Puieb3VKyX0FB+83TUzn91cDMF/4gzt990IzqVrc+nIb9RRscRD070Du16q1glydVjWR0SBJsE6TbY/esOjFpqplogQqrajm1eI++f3eLi73R6q7hVusY0QbeFySVxABCjhN0lXB04caBe1rzHjYzul6MAXj7uq+0r17VLq+yrtyYhN12wkmFqHeqTyEei6EFPbMy24Nc+IbJlkP0OCg02W+gOnyBFcbi2ctvJFSOhSjt1CqBdqCnnhwUqXjbWiT0wh3DmLScRgTHmGkaI+oAcQQjfic65nxj+TnEkReA==";
-
-const usage: Usage = {
-	input: 0,
-	output: 0,
-	cacheRead: 0,
-	cacheWrite: 0,
-	totalTokens: 0,
-	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-};
-
-describe("OpenAI Responses foreign tool call ID normalization", () => {
-	it("hashes foreign Copilot tool item IDs into a bounded Codex-safe fc_<hash> shape", () => {
-		const model = getModel("openai-codex", "gpt-5.3-codex");
-		const assistant: AssistantMessage = {
-			role: "assistant",
-			content: [
-				{
-					type: "toolCall",
-					id: COPILOT_RAW_TOOL_CALL_ID,
-					name: "edit",
-					arguments: { path: "src/styles/app.css" },
-				},
-			],
-			api: "openai-responses",
-			provider: "github-copilot",
-			model: "gpt-5.3-codex",
-			usage,
-			stopReason: "toolUse",
-			timestamp: Date.now() - 2000,
-		};
-		const toolResult: ToolResultMessage = {
-			role: "toolResult",
-			toolCallId: COPILOT_RAW_TOOL_CALL_ID,
-			toolName: "edit",
-			content: [{ type: "text", text: "ok" }],
-			isError: false,
-			timestamp: Date.now() - 1000,
-		};
-		const context: Context = {
-			systemPrompt: "You are concise.",
-			messages: [{ role: "user", content: "Use the tool.", timestamp: Date.now() - 3000 }, assistant, toolResult],
-		};
-
-		const input = convertResponsesMessages(model, context, new Set(["openai", "openai-codex", "opencode"]));
-		const functionCall = input.find((item) => item.type === "function_call");
-
-		expect(functionCall).toBeDefined();
-		expect(functionCall?.type).toBe("function_call");
-		if (!functionCall || functionCall.type !== "function_call") {
-			throw new Error("Expected function_call item");
-		}
-
-		const expectedItemId = `fc_${shortHash(COPILOT_RAW_TOOL_CALL_ID.split("|")[1]!)}`;
-		expect(functionCall.id).toBe(expectedItemId);
-		expect(functionCall.id?.length ?? 0).toBeLessThanOrEqual(64);
-		expect(functionCall.id).toMatch(/^fc_[A-Za-z0-9]+$/);
-	});
-});

package/pi.dev-src/pi-mono/ai/test/openai-responses-partial-json-cleanup.test.ts

@@ -1,101 +0,0 @@
-import type { ResponseStreamEvent } from "openai/resources/responses/responses.js";
-import { describe, expect, it, vi } from "vitest";
-import { processResponsesStream } from "../src/providers/openai-responses-shared.js";
-import type { AssistantMessage, AssistantMessageEvent, Model } from "../src/types.js";
-import { AssistantMessageEventStream } from "../src/utils/event-stream.js";
-
-function createOutput(model: Model<"openai-responses">): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [],
-		api: model.api,
-		provider: model.provider,
-		model: model.id,
-		usage: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 0,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-		},
-		stopReason: "stop",
-		timestamp: Date.now(),
-	};
-}
-
-async function* createFunctionCallEvents(argumentsJson: string): AsyncIterable<ResponseStreamEvent> {
-	yield {
-		type: "response.output_item.added",
-		item: {
-			type: "function_call",
-			id: "fc_test",
-			call_id: "call_test",
-			name: "edit",
-			arguments: "",
-		},
-	} as ResponseStreamEvent;
-	yield {
-		type: "response.function_call_arguments.delta",
-		delta: '{"path":"README.md"',
-	} as ResponseStreamEvent;
-	yield {
-		type: "response.function_call_arguments.delta",
-		delta: ',"content":"updated"}',
-	} as ResponseStreamEvent;
-	yield {
-		type: "response.function_call_arguments.done",
-		arguments: argumentsJson,
-	} as ResponseStreamEvent;
-	yield {
-		type: "response.output_item.done",
-		item: {
-			type: "function_call",
-			id: "fc_test",
-			call_id: "call_test",
-			name: "edit",
-			arguments: argumentsJson,
-		},
-	} as ResponseStreamEvent;
-}
-
-describe("openai responses partialJson cleanup", () => {
-	it("removes partialJson from persisted tool-call blocks at output_item.done", async () => {
-		const model: Model<"openai-responses"> = {
-			id: "gpt-5-mini",
-			name: "GPT-5 Mini",
-			api: "openai-responses",
-			provider: "openai",
-			baseUrl: "https://api.openai.com/v1",
-			reasoning: true,
-			input: ["text"],
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-			contextWindow: 400000,
-			maxTokens: 128000,
-		};
-		const output = createOutput(model);
-		const stream = new AssistantMessageEventStream();
-		const pushSpy = vi.spyOn(stream, "push");
-		const argumentsJson = '{"path":"README.md","content":"updated"}';
-
-		await processResponsesStream(createFunctionCallEvents(argumentsJson), output, stream, model);
-
-		expect(output.content).toHaveLength(1);
-		const persistedToolCall = output.content[0];
-		expect(persistedToolCall?.type).toBe("toolCall");
-		if (!persistedToolCall || persistedToolCall.type !== "toolCall") {
-			throw new Error("Expected toolCall block");
-		}
-		expect(persistedToolCall.arguments).toEqual({ path: "README.md", content: "updated" });
-		expect("partialJson" in persistedToolCall).toBe(false);
-
-		const emittedEvents = pushSpy.mock.calls.map(([event]) => event as AssistantMessageEvent);
-		const toolCallEnd = emittedEvents.find((event) => event.type === "toolcall_end");
-		expect(toolCallEnd).toBeDefined();
-		if (!toolCallEnd || toolCallEnd.type !== "toolcall_end") {
-			throw new Error("Expected toolcall_end event");
-		}
-		expect(toolCallEnd.toolCall).toBe(persistedToolCall);
-		expect("partialJson" in toolCallEnd.toolCall).toBe(false);
-	});
-});

package/pi.dev-src/pi-mono/ai/test/openai-responses-reasoning-replay-e2e.test.ts

@@ -1,292 +0,0 @@
-import { Type } from "typebox";
-import { describe, expect, it } from "vitest";
-import { getModel } from "../src/models.js";
-import { complete, getEnvApiKey } from "../src/stream.js";
-import type { AssistantMessage, Context, Message, Tool, ToolCall } from "../src/types.js";
-
-const testToolSchema = Type.Object({
-	value: Type.Number({ description: "A number to double" }),
-});
-
-const testTool: Tool<typeof testToolSchema> = {
-	name: "double_number",
-	description: "Doubles a number and returns the result",
-	parameters: testToolSchema,
-};
-
-describe.skipIf(!process.env.OPENAI_API_KEY || !process.env.ANTHROPIC_API_KEY)(
-	"OpenAI Responses reasoning replay e2e",
-	() => {
-		it("skips reasoning-only history after an aborted turn", { retry: 2 }, async () => {
-			const model = getModel("openai", "gpt-5-mini");
-
-			const apiKey = getEnvApiKey("openai");
-			if (!apiKey) {
-				throw new Error("Missing OPENAI_API_KEY");
-			}
-
-			const userMessage: Message = {
-				role: "user",
-				content: "Use the double_number tool to double 21.",
-				timestamp: Date.now(),
-			};
-
-			const assistantResponse = await complete(
-				model,
-				{
-					systemPrompt: "You are a helpful assistant. Use the tool.",
-					messages: [userMessage],
-					tools: [testTool],
-				},
-				{
-					apiKey,
-					reasoningEffort: "high",
-				},
-			);
-
-			const thinkingBlock = assistantResponse.content.find(
-				(block) => block.type === "thinking" && block.thinkingSignature,
-			);
-			if (!thinkingBlock || thinkingBlock.type !== "thinking") {
-				throw new Error("Missing thinking signature from OpenAI Responses");
-			}
-
-			const corruptedAssistant: AssistantMessage = {
-				...assistantResponse,
-				content: [thinkingBlock],
-				stopReason: "aborted",
-			};
-
-			const followUp: Message = {
-				role: "user",
-				content: "Say hello to confirm you can continue.",
-				timestamp: Date.now(),
-			};
-
-			const context: Context = {
-				systemPrompt: "You are a helpful assistant.",
-				messages: [userMessage, corruptedAssistant, followUp],
-				tools: [testTool],
-			};
-
-			const response = await complete(model, context, {
-				apiKey,
-				reasoningEffort: "high",
-			});
-
-			// The key assertion: no 400 error from orphaned reasoning item
-			expect(response.stopReason, `Error: ${response.errorMessage}`).not.toBe("error");
-			expect(response.errorMessage).toBeFalsy();
-			// Model should respond (text or tool call)
-			expect(response.content.length).toBeGreaterThan(0);
-		});
-
-		it("handles same-provider different-model handoff with tool calls", { retry: 2 }, async () => {
-			// This tests the scenario where:
-			// 1. Model A (gpt-5-mini) generates reasoning + function_call
-			// 2. User switches to Model B (gpt-5.2-codex) - same provider, different model
-			// 3. transform-messages: isSameModel=false, thinking converted to text
-			// 4. But tool call ID still has OpenAI pairing history (fc_xxx paired with rs_xxx)
-			// 5. Without fix: OpenAI returns 400 "function_call without required reasoning item"
-			// 6. With fix: tool calls/results converted to text, conversation continues
-
-			const modelA = getModel("openai", "gpt-5-mini");
-			const modelB = getModel("openai", "gpt-5.2-codex");
-
-			const apiKey = getEnvApiKey("openai");
-			if (!apiKey) {
-				throw new Error("Missing OPENAI_API_KEY");
-			}
-
-			const userMessage: Message = {
-				role: "user",
-				content: "Use the double_number tool to double 21.",
-				timestamp: Date.now(),
-			};
-
-			// Get a real response from Model A with reasoning + tool call
-			const assistantResponse = await complete(
-				modelA,
-				{
-					systemPrompt: "You are a helpful assistant. Always use the tool when asked.",
-					messages: [userMessage],
-					tools: [testTool],
-				},
-				{
-					apiKey,
-					reasoningEffort: "high",
-				},
-			);
-
-			const toolCallBlock = assistantResponse.content.find((block) => block.type === "toolCall") as
-				| ToolCall
-				| undefined;
-
-			if (!toolCallBlock) {
-				throw new Error("Missing tool call from OpenAI Responses - model did not use the tool");
-			}
-
-			// Provide a tool result
-			const toolResult: Message = {
-				role: "toolResult",
-				toolCallId: toolCallBlock.id,
-				toolName: toolCallBlock.name,
-				content: [{ type: "text", text: "42" }],
-				isError: false,
-				timestamp: Date.now(),
-			};
-
-			const followUp: Message = {
-				role: "user",
-				content: "What was the result? Answer with just the number.",
-				timestamp: Date.now(),
-			};
-
-			// Now continue with Model B (different model, same provider)
-			const context: Context = {
-				systemPrompt: "You are a helpful assistant. Answer concisely.",
-				messages: [userMessage, assistantResponse, toolResult, followUp],
-				tools: [testTool],
-			};
-
-			let capturedPayload: any = null;
-			const response = await complete(modelB, context, {
-				apiKey,
-				reasoningEffort: "high",
-				onPayload: (payload) => {
-					capturedPayload = payload;
-				},
-			});
-
-			// The key assertion: no 400 error from orphaned function_call
-			expect(response.stopReason, `Error: ${response.errorMessage}`).not.toBe("error");
-			expect(response.errorMessage).toBeFalsy();
-			expect(response.content.length).toBeGreaterThan(0);
-
-			// Log what was sent for debugging
-			const input = capturedPayload?.input as any[];
-			const functionCalls = input?.filter((item: any) => item.type === "function_call") || [];
-			const reasoningItems = input?.filter((item: any) => item.type === "reasoning") || [];
-
-			console.log("Payload sent to API:");
-			console.log("- function_calls:", functionCalls.length);
-			console.log("- reasoning items:", reasoningItems.length);
-			console.log("- full input:", JSON.stringify(input, null, 2));
-
-			// Verify the model understood the context
-			const responseText = response.content
-				.filter((b) => b.type === "text")
-				.map((b) => (b as any).text)
-				.join("");
-			expect(responseText).toContain("42");
-		});
-
-		it("handles cross-provider handoff from Anthropic to OpenAI Codex", { retry: 2 }, async () => {
-			// This tests cross-provider handoff:
-			// 1. Anthropic model generates thinking + function_call (toolu_xxx ID)
-			// 2. User switches to OpenAI Codex
-			// 3. transform-messages: isSameModel=false, thinking converted to text
-			// 4. Tool call ID is Anthropic format (toolu_xxx), no OpenAI pairing history
-			// 5. Should work because foreign IDs have no pairing expectation
-
-			const anthropicModel = getModel("anthropic", "claude-sonnet-4-5");
-			const codexModel = getModel("openai", "gpt-5.2-codex");
-
-			const anthropicApiKey = getEnvApiKey("anthropic");
-			const openaiApiKey = getEnvApiKey("openai");
-			if (!anthropicApiKey || !openaiApiKey) {
-				throw new Error("Missing API keys");
-			}
-
-			const userMessage: Message = {
-				role: "user",
-				content: "Use the double_number tool to double 21.",
-				timestamp: Date.now(),
-			};
-
-			// Get a real response from Anthropic with thinking + tool call
-			const assistantResponse = await complete(
-				anthropicModel,
-				{
-					systemPrompt: "You are a helpful assistant. Always use the tool when asked.",
-					messages: [userMessage],
-					tools: [testTool],
-				},
-				{
-					apiKey: anthropicApiKey,
-					thinkingEnabled: true,
-					thinkingBudgetTokens: 5000,
-				},
-			);
-
-			const toolCallBlock = assistantResponse.content.find((block) => block.type === "toolCall") as
-				| ToolCall
-				| undefined;
-
-			if (!toolCallBlock) {
-				throw new Error("Missing tool call from Anthropic - model did not use the tool");
-			}
-
-			console.log("Anthropic tool call ID:", toolCallBlock.id);
-
-			// Provide a tool result
-			const toolResult: Message = {
-				role: "toolResult",
-				toolCallId: toolCallBlock.id,
-				toolName: toolCallBlock.name,
-				content: [{ type: "text", text: "42" }],
-				isError: false,
-				timestamp: Date.now(),
-			};
-
-			const followUp: Message = {
-				role: "user",
-				content: "What was the result? Answer with just the number.",
-				timestamp: Date.now(),
-			};
-
-			// Now continue with Codex (different provider)
-			const context: Context = {
-				systemPrompt: "You are a helpful assistant. Answer concisely.",
-				messages: [userMessage, assistantResponse, toolResult, followUp],
-				tools: [testTool],
-			};
-
-			let capturedPayload: any = null;
-			const response = await complete(codexModel, context, {
-				apiKey: openaiApiKey,
-				reasoningEffort: "high",
-				onPayload: (payload) => {
-					capturedPayload = payload;
-				},
-			});
-
-			// Log what was sent
-			const input = capturedPayload?.input as any[];
-			const functionCalls = input?.filter((item: any) => item.type === "function_call") || [];
-			const reasoningItems = input?.filter((item: any) => item.type === "reasoning") || [];
-
-			console.log("Payload sent to Codex:");
-			console.log("- function_calls:", functionCalls.length);
-			console.log("- reasoning items:", reasoningItems.length);
-			if (functionCalls.length > 0) {
-				console.log(
-					"- function_call IDs:",
-					functionCalls.map((fc: any) => fc.id),
-				);
-			}
-
-			// The key assertion: no 400 error
-			expect(response.stopReason, `Error: ${response.errorMessage}`).not.toBe("error");
-			expect(response.errorMessage).toBeFalsy();
-			expect(response.content.length).toBeGreaterThan(0);
-
-			// Verify the model understood the context
-			const responseText = response.content
-				.filter((b) => b.type === "text")
-				.map((b) => (b as any).text)
-				.join("");
-			expect(responseText).toContain("42");
-		});
-	},
-);