pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/ai/test/github-copilot-anthropic.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { getModel } from "../src/models.js";
-import type { Context } from "../src/types.js";
-
-const mockState = vi.hoisted(() => ({
-	constructorOpts: undefined as Record<string, unknown> | undefined,
-	createParams: undefined as Record<string, unknown> | undefined,
-}));
-
-vi.mock("@anthropic-ai/sdk", () => {
-	function createSseResponse(): Response {
-		const body = [
-			`event: message_start\ndata: ${JSON.stringify({
-				type: "message_start",
-				message: {
-					id: "msg_test",
-					usage: { input_tokens: 10, output_tokens: 0 },
-				},
-			})}\n`,
-			`event: message_delta\ndata: ${JSON.stringify({
-				type: "message_delta",
-				delta: { stop_reason: "end_turn" },
-				usage: { output_tokens: 5 },
-			})}\n`,
-		].join("\n");
-
-		return new Response(body, {
-			status: 200,
-			headers: { "content-type": "text/event-stream" },
-		});
-	}
-
-	class FakeAnthropic {
-		constructor(opts: Record<string, unknown>) {
-			mockState.constructorOpts = opts;
-		}
-		messages = {
-			create: (params: Record<string, unknown>) => {
-				mockState.createParams = params;
-				return {
-					asResponse: async () => createSseResponse(),
-				};
-			},
-		};
-	}
-
-	return { default: FakeAnthropic };
-});
-
-describe("Copilot Claude via Anthropic Messages", () => {
-	const context: Context = {
-		systemPrompt: "You are a helpful assistant.",
-		messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
-	};
-
-	it("uses Bearer auth, Copilot headers, and valid Anthropic Messages payload", async () => {
-		const model = getModel("github-copilot", "claude-sonnet-4");
-		expect(model.api).toBe("anthropic-messages");
-
-		const { streamAnthropic } = await import("../src/providers/anthropic.js");
-		const s = streamAnthropic(model, context, { apiKey: "tid_copilot_session_test_token" });
-		for await (const event of s) {
-			if (event.type === "error") break;
-		}
-
-		const opts = mockState.constructorOpts!;
-		expect(opts).toBeDefined();
-
-		// Auth: apiKey null, authToken for Bearer
-		expect(opts.apiKey).toBeNull();
-		expect(opts.authToken).toBe("tid_copilot_session_test_token");
-		const headers = opts.defaultHeaders as Record<string, string>;
-
-		// Copilot static headers from model.headers
-		expect(headers["User-Agent"]).toContain("GitHubCopilotChat");
-		expect(headers["Copilot-Integration-Id"]).toBe("vscode-chat");
-
-		// Dynamic headers
-		expect(headers["X-Initiator"]).toBe("user");
-		expect(headers["Openai-Intent"]).toBe("conversation-edits");
-
-		// No fine-grained-tool-streaming (Copilot doesn't support it)
-		const beta = headers["anthropic-beta"] ?? "";
-		expect(beta).not.toContain("fine-grained-tool-streaming");
-
-		// Payload is valid Anthropic Messages format
-		const params = mockState.createParams!;
-		expect(params.model).toBe("claude-sonnet-4");
-		expect(params.stream).toBe(true);
-		expect(params.max_tokens).toBeGreaterThan(0);
-		expect(Array.isArray(params.messages)).toBe(true);
-	});
-
-	it("includes interleaved-thinking beta when reasoning is enabled", async () => {
-		const model = getModel("github-copilot", "claude-sonnet-4");
-		const { streamAnthropic } = await import("../src/providers/anthropic.js");
-		const s = streamAnthropic(model, context, {
-			apiKey: "tid_copilot_session_test_token",
-			interleavedThinking: true,
-		});
-		for await (const event of s) {
-			if (event.type === "error") break;
-		}
-
-		const headers = mockState.constructorOpts!.defaultHeaders as Record<string, string>;
-		expect(headers["anthropic-beta"]).toContain("interleaved-thinking-2025-05-14");
-	});
-});

package/pi.dev-src/pi-mono/ai/test/github-copilot-oauth.test.ts

@@ -1,196 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { loginGitHubCopilot } from "../src/utils/oauth/github-copilot.js";
-
-function jsonResponse(body: unknown, status: number = 200): Response {
-	return new Response(JSON.stringify(body), {
-		status,
-		headers: {
-			"Content-Type": "application/json",
-		},
-	});
-}
-
-function getUrl(input: unknown): string {
-	if (typeof input === "string") {
-		return input;
-	}
-	if (input instanceof URL) {
-		return input.toString();
-	}
-	if (input instanceof Request) {
-		return input.url;
-	}
-	throw new Error(`Unsupported fetch input: ${String(input)}`);
-}
-
-describe("GitHub Copilot OAuth device flow", () => {
-	afterEach(() => {
-		vi.unstubAllGlobals();
-		vi.useRealTimers();
-	});
-
-	it("waits before the first poll and increases the safety margin after slow_down", async () => {
-		vi.useFakeTimers();
-		const startTime = new Date("2026-03-09T00:00:00Z");
-		vi.setSystemTime(startTime);
-
-		const accessTokenPollTimes: number[] = [];
-		const accessTokenResponses = [
-			jsonResponse({ error: "authorization_pending", error_description: "pending" }),
-			jsonResponse({ error: "slow_down", error_description: "slow down", interval: 10 }),
-			jsonResponse({ access_token: "ghu_refresh_token" }),
-		];
-
-		const fetchMock = vi.fn(async (input: unknown, init?: RequestInit): Promise<Response> => {
-			const url = getUrl(input);
-
-			if (url.endsWith("/login/device/code")) {
-				expect(init?.method).toBe("POST");
-				expect(init?.headers).toMatchObject({
-					Accept: "application/json",
-					"Content-Type": "application/x-www-form-urlencoded",
-				});
-				expect(String(init?.body)).toContain("client_id=");
-				expect(String(init?.body)).toContain("scope=read%3Auser");
-				return jsonResponse({
-					device_code: "device-code",
-					user_code: "ABCD-EFGH",
-					verification_uri: "https://github.com/login/device",
-					interval: 5,
-					expires_in: 900,
-				});
-			}
-
-			if (url.endsWith("/login/oauth/access_token")) {
-				accessTokenPollTimes.push(Date.now());
-				expect(init?.method).toBe("POST");
-				expect(init?.headers).toMatchObject({
-					Accept: "application/json",
-					"Content-Type": "application/x-www-form-urlencoded",
-				});
-				expect(String(init?.body)).toContain("client_id=");
-				expect(String(init?.body)).toContain("device_code=device-code");
-				expect(String(init?.body)).toContain("grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code");
-				const response = accessTokenResponses.shift();
-				if (!response) {
-					throw new Error("Unexpected extra access token poll");
-				}
-				return response;
-			}
-
-			if (url.includes("/copilot_internal/v2/token")) {
-				return jsonResponse({
-					token: "tid=test;exp=9999999999;proxy-ep=proxy.individual.githubcopilot.com;",
-					expires_at: 9999999999,
-				});
-			}
-
-			if (url.includes("/models/") && url.endsWith("/policy")) {
-				return new Response("", { status: 200 });
-			}
-
-			throw new Error(`Unexpected fetch URL: ${url}`);
-		});
-
-		vi.stubGlobal("fetch", fetchMock);
-
-		const loginPromise = loginGitHubCopilot({
-			onAuth: () => {},
-			onPrompt: async () => "",
-			onProgress: () => {},
-		});
-
-		await vi.advanceTimersByTimeAsync(0);
-		expect(accessTokenPollTimes).toHaveLength(0);
-
-		await vi.advanceTimersByTimeAsync(5999);
-		expect(accessTokenPollTimes).toHaveLength(0);
-
-		await vi.advanceTimersByTimeAsync(1);
-		expect(accessTokenPollTimes).toHaveLength(1);
-
-		await vi.advanceTimersByTimeAsync(5999);
-		expect(accessTokenPollTimes).toHaveLength(1);
-
-		await vi.advanceTimersByTimeAsync(1);
-		expect(accessTokenPollTimes).toHaveLength(2);
-
-		await vi.advanceTimersByTimeAsync(13999);
-		expect(accessTokenPollTimes).toHaveLength(2);
-
-		await vi.advanceTimersByTimeAsync(1);
-		await loginPromise;
-
-		expect(accessTokenPollTimes).toEqual([
-			startTime.getTime() + 6000,
-			startTime.getTime() + 12000,
-			startTime.getTime() + 26000,
-		]);
-	});
-
-	it("uses the remaining lifetime for a final poll before timing out after repeated slow_down responses", async () => {
-		vi.useFakeTimers();
-		const startTime = new Date("2026-03-09T00:00:00Z");
-		vi.setSystemTime(startTime);
-
-		const accessTokenPollTimes: number[] = [];
-		const accessTokenResponses = [
-			jsonResponse({ error: "slow_down", error_description: "slow down", interval: 10 }),
-			jsonResponse({ error: "slow_down", error_description: "still too fast", interval: 15 }),
-			jsonResponse({ error: "authorization_pending", error_description: "pending" }),
-		];
-
-		const fetchMock = vi.fn(async (input: unknown): Promise<Response> => {
-			const url = getUrl(input);
-
-			if (url.endsWith("/login/device/code")) {
-				return jsonResponse({
-					device_code: "device-code",
-					user_code: "ABCD-EFGH",
-					verification_uri: "https://github.com/login/device",
-					interval: 5,
-					expires_in: 25,
-				});
-			}
-
-			if (url.endsWith("/login/oauth/access_token")) {
-				accessTokenPollTimes.push(Date.now());
-				const response = accessTokenResponses.shift();
-				if (!response) {
-					throw new Error("Unexpected extra access token poll");
-				}
-				return response;
-			}
-
-			throw new Error(`Unexpected fetch URL: ${url}`);
-		});
-
-		vi.stubGlobal("fetch", fetchMock);
-
-		const loginPromise = loginGitHubCopilot({
-			onAuth: () => {},
-			onPrompt: async () => "",
-		});
-		const rejection = expect(loginPromise).rejects.toThrow(
-			/Device flow timed out after one or more slow_down responses/,
-		);
-
-		await vi.advanceTimersByTimeAsync(6000);
-		expect(accessTokenPollTimes).toEqual([startTime.getTime() + 6000]);
-
-		await vi.advanceTimersByTimeAsync(14000);
-		expect(accessTokenPollTimes).toEqual([startTime.getTime() + 6000, startTime.getTime() + 20000]);
-
-		await vi.advanceTimersByTimeAsync(4999);
-		expect(accessTokenPollTimes).toEqual([startTime.getTime() + 6000, startTime.getTime() + 20000]);
-
-		await vi.advanceTimersByTimeAsync(1);
-		await rejection;
-
-		expect(accessTokenPollTimes).toEqual([
-			startTime.getTime() + 6000,
-			startTime.getTime() + 20000,
-			startTime.getTime() + 25000,
-		]);
-	});
-});

package/pi.dev-src/pi-mono/ai/test/google-gemini-cli-claude-thinking-header.test.ts

@@ -1,103 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { streamGoogleGeminiCli } from "../src/providers/google-gemini-cli.js";
-import type { Context, Model } from "../src/types.js";
-
-const originalFetch = global.fetch;
-const apiKey = JSON.stringify({ token: "token", projectId: "project" });
-
-const createSseResponse = () => {
-	const sse = `${[
-		`data: ${JSON.stringify({
-			response: {
-				candidates: [
-					{
-						content: { role: "model", parts: [{ text: "Hello" }] },
-						finishReason: "STOP",
-					},
-				],
-			},
-		})}`,
-	].join("\n\n")}\n\n`;
-
-	const encoder = new TextEncoder();
-	const stream = new ReadableStream<Uint8Array>({
-		start(controller) {
-			controller.enqueue(encoder.encode(sse));
-			controller.close();
-		},
-	});
-
-	return new Response(stream, {
-		status: 200,
-		headers: { "content-type": "text/event-stream" },
-	});
-};
-
-afterEach(() => {
-	global.fetch = originalFetch;
-	vi.restoreAllMocks();
-});
-
-describe("google-gemini-cli Claude thinking header", () => {
-	const context: Context = {
-		messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
-	};
-
-	it("adds anthropic-beta for Claude thinking models", async () => {
-		const fetchMock = vi.fn(async (_input: string | URL, init?: RequestInit) => {
-			const headers = new Headers(init?.headers);
-			expect(headers.get("anthropic-beta")).toBe("interleaved-thinking-2025-05-14");
-			return createSseResponse();
-		});
-
-		global.fetch = fetchMock as typeof fetch;
-
-		const model: Model<"google-gemini-cli"> = {
-			id: "claude-opus-4-5-thinking",
-			name: "Claude Opus 4.5 Thinking",
-			api: "google-gemini-cli",
-			provider: "google-antigravity",
-			baseUrl: "https://cloudcode-pa.googleapis.com",
-			reasoning: true,
-			input: ["text"],
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-			contextWindow: 128000,
-			maxTokens: 8192,
-		};
-
-		const stream = streamGoogleGeminiCli(model, context, { apiKey });
-		for await (const _event of stream) {
-			// exhaust stream
-		}
-		await stream.result();
-	});
-
-	it("does not add anthropic-beta for Gemini models", async () => {
-		const fetchMock = vi.fn(async (_input: string | URL, init?: RequestInit) => {
-			const headers = new Headers(init?.headers);
-			expect(headers.has("anthropic-beta")).toBe(false);
-			return createSseResponse();
-		});
-
-		global.fetch = fetchMock as typeof fetch;
-
-		const model: Model<"google-gemini-cli"> = {
-			id: "gemini-2.5-flash",
-			name: "Gemini 2.5 Flash",
-			api: "google-gemini-cli",
-			provider: "google-gemini-cli",
-			baseUrl: "https://cloudcode-pa.googleapis.com",
-			reasoning: false,
-			input: ["text"],
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-			contextWindow: 128000,
-			maxTokens: 8192,
-		};
-
-		const stream = streamGoogleGeminiCli(model, context, { apiKey });
-		for await (const _event of stream) {
-			// exhaust stream
-		}
-		await stream.result();
-	});
-});

package/pi.dev-src/pi-mono/ai/test/google-gemini-cli-empty-stream.test.ts

@@ -1,108 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { streamGoogleGeminiCli } from "../src/providers/google-gemini-cli.js";
-import type { Context, Model } from "../src/types.js";
-
-const originalFetch = global.fetch;
-
-afterEach(() => {
-	global.fetch = originalFetch;
-	vi.restoreAllMocks();
-});
-
-describe("google-gemini-cli empty stream retry", () => {
-	it("retries empty SSE responses without duplicate start", async () => {
-		const emptyStream = new ReadableStream<Uint8Array>({
-			start(controller) {
-				controller.close();
-			},
-		});
-
-		const sse = `${[
-			`data: ${JSON.stringify({
-				response: {
-					candidates: [
-						{
-							content: { role: "model", parts: [{ text: "Hello" }] },
-							finishReason: "STOP",
-						},
-					],
-					usageMetadata: {
-						promptTokenCount: 1,
-						candidatesTokenCount: 1,
-						totalTokenCount: 2,
-					},
-				},
-			})}`,
-		].join("\n\n")}\n\n`;
-
-		const encoder = new TextEncoder();
-		const dataStream = new ReadableStream<Uint8Array>({
-			start(controller) {
-				controller.enqueue(encoder.encode(sse));
-				controller.close();
-			},
-		});
-
-		let callCount = 0;
-		const fetchMock = vi.fn(async () => {
-			callCount += 1;
-			if (callCount === 1) {
-				return new Response(emptyStream, {
-					status: 200,
-					headers: { "content-type": "text/event-stream" },
-				});
-			}
-			return new Response(dataStream, {
-				status: 200,
-				headers: { "content-type": "text/event-stream" },
-			});
-		});
-
-		global.fetch = fetchMock as typeof fetch;
-
-		const model: Model<"google-gemini-cli"> = {
-			id: "gemini-2.5-flash",
-			name: "Gemini 2.5 Flash",
-			api: "google-gemini-cli",
-			provider: "google-gemini-cli",
-			baseUrl: "https://cloudcode-pa.googleapis.com",
-			reasoning: false,
-			input: ["text"],
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-			contextWindow: 128000,
-			maxTokens: 8192,
-		};
-
-		const context: Context = {
-			messages: [{ role: "user", content: "Say hello", timestamp: Date.now() }],
-		};
-
-		const stream = streamGoogleGeminiCli(model, context, {
-			apiKey: JSON.stringify({ token: "token", projectId: "project" }),
-		});
-
-		let startCount = 0;
-		let doneCount = 0;
-		let text = "";
-
-		for await (const event of stream) {
-			if (event.type === "start") {
-				startCount += 1;
-			}
-			if (event.type === "done") {
-				doneCount += 1;
-			}
-			if (event.type === "text_delta") {
-				text += event.delta;
-			}
-		}
-
-		const result = await stream.result();
-
-		expect(text).toBe("Hello");
-		expect(result.stopReason).toBe("stop");
-		expect(startCount).toBe(1);
-		expect(doneCount).toBe(1);
-		expect(fetchMock).toHaveBeenCalledTimes(2);
-	});
-});

package/pi.dev-src/pi-mono/ai/test/google-gemini-cli-retry-delay.test.ts

@@ -1,53 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { extractRetryDelay } from "../src/providers/google-gemini-cli.js";
-
-describe("extractRetryDelay header parsing", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	it("prefers Retry-After seconds header", () => {
-		vi.useFakeTimers();
-		vi.setSystemTime(new Date("2025-01-01T00:00:00Z"));
-
-		const response = new Response("", { headers: { "Retry-After": "5" } });
-		const delay = extractRetryDelay("Please retry in 1s", response);
-
-		expect(delay).toBe(6000);
-	});
-
-	it("parses Retry-After HTTP date header", () => {
-		vi.useFakeTimers();
-		const now = new Date("2025-01-01T00:00:00Z");
-		vi.setSystemTime(now);
-
-		const retryAt = new Date(now.getTime() + 12000).toUTCString();
-		const response = new Response("", { headers: { "Retry-After": retryAt } });
-		const delay = extractRetryDelay("", response);
-
-		expect(delay).toBe(13000);
-	});
-
-	it("parses x-ratelimit-reset header", () => {
-		vi.useFakeTimers();
-		const now = new Date("2025-01-01T00:00:00Z");
-		vi.setSystemTime(now);
-
-		const resetAtMs = now.getTime() + 20000;
-		const resetSeconds = Math.floor(resetAtMs / 1000).toString();
-		const response = new Response("", { headers: { "x-ratelimit-reset": resetSeconds } });
-		const delay = extractRetryDelay("", response);
-
-		expect(delay).toBe(21000);
-	});
-
-	it("parses x-ratelimit-reset-after header", () => {
-		vi.useFakeTimers();
-		vi.setSystemTime(new Date("2025-01-01T00:00:00Z"));
-
-		const response = new Response("", { headers: { "x-ratelimit-reset-after": "30" } });
-		const delay = extractRetryDelay("", response);
-
-		expect(delay).toBe(31000);
-	});
-});