pi-free 1.0.0

package/tests/mistral.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Mistral Provider Tests
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+let capturedConfig: any = null;
+let capturedHook: Function | null = null;
+
+vi.mock("../config.ts", () => ({
+	MISTRAL_API_KEY: "test-mistral-key",
+	MISTRAL_SHOW_PAID: false,
+	PROVIDER_MISTRAL: "mistral",
+	applyHidden: (models: any[]) => models,
+}));
+
+vi.mock("../constants.ts", () => ({
+	BASE_URL_MISTRAL: "https://api.mistral.ai/v1",
+}));
+
+vi.mock("../provider-helper.ts", () => ({
+	createReRegister: vi.fn(() => vi.fn()),
+	setupProvider: vi.fn(),
+}));
+
+vi.mock("../provider-factory.ts", () => ({
+	createProvider: vi.fn(async (pi: any, def: any) => {
+		capturedConfig = def;
+		// Capture the beforeProviderRequest hook if provided
+		if (def.beforeProviderRequest) {
+			capturedHook = def.beforeProviderRequest;
+			// Also register it via pi.on
+			(pi.on as Function)("before_provider_request", (event: any) => {
+				const payload = event.payload as Record<string, unknown>;
+				return def.beforeProviderRequest(payload);
+			});
+		}
+	}),
+}));
+
+vi.mock("../lib/logger.ts", () => ({
+	createLogger: () => ({
+		warn: vi.fn(),
+		info: vi.fn(),
+		debug: vi.fn(),
+		error: vi.fn(),
+	}),
+}));
+
+import mistralProvider from "../providers/mistral.ts";
+
+describe("Mistral Provider", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		capturedConfig = null;
+		capturedHook = null;
+	});
+
+	describe("initialization", () => {
+		it("should configure factory correctly", async () => {
+			const mockPi = {
+				registerProvider: vi.fn(),
+				on: vi.fn(),
+			} as unknown as ExtensionAPI;
+
+			await mistralProvider(mockPi);
+
+			expect(capturedConfig).toMatchObject({
+				providerId: "mistral",
+				baseUrl: "https://api.mistral.ai/v1",
+				apiKeyEnvVar: "MISTRAL_API_KEY",
+				apiKeyConfigKey: "mistral_api_key",
+			});
+		});
+
+		it("should include beforeProviderRequest hook", async () => {
+			const mockPi = {
+				registerProvider: vi.fn(),
+				on: vi.fn(),
+			} as unknown as ExtensionAPI;
+
+			await mistralProvider(mockPi);
+
+			expect(capturedConfig.beforeProviderRequest).toBeDefined();
+			expect(typeof capturedConfig.beforeProviderRequest).toBe("function");
+		});
+	});
+
+	describe("payload filtering", () => {
+		it("should filter to only allowed fields for Mistral requests", async () => {
+			const mockPi = {
+				registerProvider: vi.fn(),
+				on: vi.fn(),
+			} as unknown as ExtensionAPI;
+
+			await mistralProvider(mockPi);
+
+			const mistralPayload = {
+				model: "mistral-large-latest",
+				messages: [{ role: "user", content: "Hello" }],
+				temperature: 0.7,
+				max_tokens: 100,
+				unsupported_field: "should be removed",
+				another_bad_field: 123,
+			};
+
+			const result = capturedHook?.(mistralPayload);
+
+			expect(result).toEqual({
+				model: "mistral-large-latest",
+				messages: [{ role: "user", content: "Hello" }],
+				temperature: 0.7,
+				max_tokens: 100,
+			});
+			expect(result.unsupported_field).toBeUndefined();
+		});
+
+		it("should not filter requests from other providers", async () => {
+			const mockPi = {
+				registerProvider: vi.fn(),
+				on: vi.fn(),
+			} as unknown as ExtensionAPI;
+
+			await mistralProvider(mockPi);
+
+			const otherPayload = {
+				model: "gpt-4",
+				messages: [{ role: "user", content: "Hello" }],
+				temperature: 0.7,
+			};
+
+			const result = capturedHook?.(otherPayload);
+
+			// Should return undefined to let payload through unchanged
+			expect(result).toBeUndefined();
+		});
+	});
+});

package/tests/nvidia.test.ts

@@ -0,0 +1,55 @@
+/**
+ * NVIDIA Provider Tests
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+let capturedConfig: any = null;
+
+vi.mock("../provider-factory.ts", () => ({
+	createProvider: vi.fn(async (_pi: any, def: any) => {
+		capturedConfig = def;
+		// Don't call fetchModels - just capture config
+		return;
+	}),
+}));
+
+// Minimal mocks for imports
+vi.mock("../config.ts", () => ({
+	NVIDIA_API_KEY: "test-key",
+	NVIDIA_SHOW_PAID: true,
+	PROVIDER_NVIDIA: "nvidia",
+	applyHidden: (m: any[]) => m,
+}));
+
+vi.mock("../constants.ts", () => ({
+	BASE_URL_NVIDIA: "https://integrate.api.nvidia.com/v1",
+	DEFAULT_FETCH_TIMEOUT_MS: 10000,
+	NVIDIA_MIN_SIZE_B: 70,
+	URL_MODELS_DEV: "https://models.dev/api.json",
+}));
+
+import nvidiaProvider from "../providers/nvidia.ts";
+
+describe("NVIDIA Provider", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		capturedConfig = null;
+	});
+
+	it("should configure factory correctly", async () => {
+		const mockPi = {} as ExtensionAPI;
+		await nvidiaProvider(mockPi);
+
+		expect(capturedConfig).toMatchObject({
+			providerId: "nvidia",
+			baseUrl: "https://integrate.api.nvidia.com/v1",
+			apiKeyEnvVar: "NVIDIA_API_KEY",
+			apiKeyConfigKey: "nvidia_api_key",
+		});
+		// Should NOT have showPaidFlag (NVIDIA filters internally)
+		expect(capturedConfig.showPaidFlag).toBeUndefined();
+		expect(typeof capturedConfig.fetchModels).toBe("function");
+	});
+});

package/tests/ollama.test.ts

@@ -0,0 +1,261 @@
+/**
+ * Ollama Provider Tests
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock dependencies
+vi.mock("../config.ts", () => ({
+	OLLAMA_API_KEY: "test-ollama-key",
+	OLLAMA_SHOW_PAID: true,
+	PROVIDER_OLLAMA: "ollama",
+	applyHidden: (models: unknown[]) => models,
+}));
+
+vi.mock("../constants.ts", () => ({
+	BASE_URL_OLLAMA: "https://ollama.com/v1",
+	DEFAULT_FETCH_TIMEOUT_MS: 10000,
+}));
+
+vi.mock("../provider-helper.ts", () => ({
+	createReRegister: vi.fn(() => vi.fn()),
+	setupProvider: vi.fn(),
+}));
+
+vi.mock("../lib/logger.ts", () => ({
+	createLogger: () => ({
+		warn: vi.fn(),
+		info: vi.fn(),
+		debug: vi.fn(),
+		error: vi.fn(),
+	}),
+}));
+
+vi.mock("../util.ts", () => ({
+	fetchWithRetry: vi.fn(),
+	logWarning: vi.fn(),
+}));
+
+import { fetchWithRetry } from "../lib/util.ts";
+import { setupProvider } from "../provider-helper.ts";
+
+describe("Ollama Provider", () => {
+	let mockPi: ExtensionAPI;
+	let mockRegisterProvider: ReturnType<typeof vi.fn>;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockRegisterProvider = vi.fn();
+
+		mockPi = {
+			registerProvider: mockRegisterProvider,
+			registerCommand: vi.fn(),
+		} as unknown as ExtensionAPI;
+	});
+
+	describe("initialization", () => {
+		it("should register provider with cloud models", async () => {
+			const mockModels = {
+				data: [
+					{
+						id: "gpt-oss:120b",
+						object: "model",
+						created: 1754352000,
+						owned_by: "ollama",
+					},
+				],
+			};
+			vi.mocked(fetchWithRetry).mockResolvedValue({
+				ok: true,
+				json: async () => mockModels,
+			} as Response);
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			expect(mockRegisterProvider).toHaveBeenCalledWith(
+				"ollama",
+				expect.objectContaining({
+					baseUrl: "https://ollama.com/v1",
+					apiKey: "OLLAMA_API_KEY",
+					api: "openai-completions",
+					models: expect.any(Array),
+				}),
+			);
+		});
+
+		it("should set API key in environment", async () => {
+			delete process.env.OLLAMA_API_KEY;
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			expect(process.env.OLLAMA_API_KEY).toBe("test-ollama-key");
+		});
+
+		it("should skip registration without API key", async () => {
+			const apiKeySpy = vi
+				.spyOn(await import("../config.ts"), "OLLAMA_API_KEY", "get")
+				.mockReturnValue(undefined as any);
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			expect(mockRegisterProvider).not.toHaveBeenCalled();
+			apiKeySpy.mockRestore();
+		});
+
+		it("should skip registration when SHOW_PAID is false", async () => {
+			const showPaidSpy = vi
+				.spyOn(await import("../config.ts"), "OLLAMA_SHOW_PAID", "get")
+				.mockReturnValue(false);
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			expect(mockRegisterProvider).not.toHaveBeenCalled();
+			showPaidSpy.mockRestore();
+		});
+	});
+
+	describe("model fetching", () => {
+		it("should filter out small models (< 30B)", async () => {
+			const mockModels = {
+				data: [
+					{
+						id: "gpt-oss:120b",
+						object: "model",
+						created: 1754352000,
+						owned_by: "ollama",
+					},
+					{
+						id: "llama3.2:1b", // Should be filtered out (too small)
+						object: "model",
+						created: 1754352000,
+						owned_by: "ollama",
+					},
+					{
+						id: "qwen3-coder:8b", // Should be kept (8b >= 3b threshold in code)
+						object: "model",
+						created: 1754352000,
+						owned_by: "ollama",
+					},
+				],
+			};
+			vi.mocked(fetchWithRetry).mockResolvedValue({
+				ok: true,
+				json: async () => mockModels,
+			} as Response);
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			const registerCall = mockRegisterProvider.mock.calls[0];
+			const models = registerCall?.[1]?.models;
+
+			// Should filter out small models (< 30B), keep only 120b
+			expect(models).toHaveLength(1);
+			expect(models[0].id).toBe("gpt-oss:120b");
+		});
+
+		it("should clean up model names", async () => {
+			const mockModels = {
+				data: [
+					{
+						id: "gpt-oss:120b",
+						object: "model",
+						created: 1754352000,
+						owned_by: "ollama",
+					},
+				],
+			};
+			vi.mocked(fetchWithRetry).mockResolvedValue({
+				ok: true,
+				json: async () => mockModels,
+			} as Response);
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			const registerCall = mockRegisterProvider.mock.calls[0];
+			const models = registerCall?.[1]?.models;
+
+			expect(models[0].name).toBe("Gpt Oss 120b"); // Cleaned up name
+		});
+
+		it("should detect reasoning models", async () => {
+			const mockModels = {
+				data: [
+					{
+						id: "deepseek-r1:70b",
+						object: "model",
+						created: 1754352000,
+						owned_by: "ollama",
+					},
+				],
+			};
+			vi.mocked(fetchWithRetry).mockResolvedValue({
+				ok: true,
+				json: async () => mockModels,
+			} as Response);
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			const registerCall = mockRegisterProvider.mock.calls[0];
+			const models = registerCall?.[1]?.models;
+
+			expect(models[0].reasoning).toBe(true);
+		});
+	});
+
+	describe("setupProvider integration", () => {
+		it("should call setupProvider with stored models", async () => {
+			const mockModels = {
+				data: [
+					{
+						id: "gpt-oss:120b",
+						object: "model",
+						created: 1754352000,
+						owned_by: "ollama",
+					},
+				],
+			};
+			vi.mocked(fetchWithRetry).mockResolvedValue({
+				ok: true,
+				json: async () => mockModels,
+			} as Response);
+
+			const { default: ollamaProvider } = await import(
+				"../providers/ollama.ts"
+			);
+			await ollamaProvider(mockPi);
+
+			expect(setupProvider).toHaveBeenCalledWith(
+				mockPi,
+				expect.objectContaining({
+					providerId: "ollama",
+				}),
+				expect.objectContaining({
+					free: expect.any(Array),
+					all: expect.any(Array),
+				}),
+			);
+		});
+	});
+});

package/tests/openrouter.test.ts

@@ -0,0 +1,192 @@
+/**
+ * OpenRouter Provider Tests
+ */
+
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@mariozechner/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock dependencies
+vi.mock("../config.ts", () => ({
+	OPENROUTER_API_KEY: "test-api-key",
+	OPENROUTER_SHOW_PAID: false,
+	PROVIDER_OPENROUTER: "openrouter",
+	applyHidden: (models: ProviderModelConfig[]) => models,
+}));
+
+vi.mock("../constants.ts", () => ({
+	BASE_URL_OPENROUTER: "https://openrouter.ai/api/v1",
+	DEFAULT_FETCH_TIMEOUT_MS: 10000,
+}));
+
+vi.mock("../metrics.ts", () => ({
+	fetchOpenRouterMetrics: vi.fn(),
+}));
+
+vi.mock("../provider-helper.ts", () => ({
+	createReRegister: vi.fn(() => vi.fn()),
+	createCtxReRegister: vi.fn(() => vi.fn()),
+	setupProvider: vi.fn(),
+}));
+
+vi.mock("../util.ts", () => ({
+	logWarning: vi.fn(),
+}));
+
+vi.mock("../providers/model-fetcher.ts", () => ({
+	fetchOpenRouterModelsWithFree: vi.fn(),
+}));
+
+import { setupProvider } from "../provider-helper.ts";
+import { fetchOpenRouterModelsWithFree } from "../providers/model-fetcher.ts";
+import openrouterProvider from "../providers/openrouter.ts";
+
+describe("OpenRouter Provider", () => {
+	let mockPi: ExtensionAPI;
+	let mockRegisterProvider: ReturnType<typeof vi.fn>;
+	let mockOn: ReturnType<typeof vi.fn>;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockRegisterProvider = vi.fn();
+		mockOn = vi.fn();
+
+		mockPi = {
+			registerProvider: mockRegisterProvider,
+			on: mockOn,
+		} as unknown as ExtensionAPI;
+	});
+
+	describe("initialization", () => {
+		it("should register event handlers", async () => {
+			vi.mocked(fetchOpenRouterModelsWithFree).mockResolvedValue({
+				free: [],
+				all: [],
+			});
+
+			await openrouterProvider(mockPi);
+
+			expect(mockOn).toHaveBeenCalledWith(
+				"session_start",
+				expect.any(Function),
+			);
+		});
+	});
+
+	describe("session_start handling", () => {
+		it("should handle existing auth with free models", async () => {
+			const mockFreeModels: ProviderModelConfig[] = [
+				{
+					id: "gpt-3.5",
+					name: "GPT-3.5",
+					reasoning: false,
+					input: ["text"],
+					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+					contextWindow: 16000,
+					maxTokens: 4096,
+				},
+			];
+
+			const mockAllModels: ProviderModelConfig[] = [
+				...mockFreeModels,
+				{
+					id: "gpt-4",
+					name: "GPT-4",
+					reasoning: true,
+					input: ["text"],
+					cost: { input: 30, output: 60, cacheRead: 0, cacheWrite: 0 },
+					contextWindow: 128000,
+					maxTokens: 4096,
+				},
+			];
+
+			vi.mocked(fetchOpenRouterModelsWithFree).mockResolvedValue({
+				free: mockFreeModels,
+				all: mockAllModels,
+			});
+
+			await openrouterProvider(mockPi);
+
+			// Get session_start handler
+			const sessionStartHandler = mockOn.mock.calls.find(
+				(call) => call[0] === "session_start",
+			)?.[1];
+
+			expect(sessionStartHandler).toBeDefined();
+
+			// Mock context with existing auth
+			const mockCtx = {
+				modelRegistry: {
+					getAll: vi
+						.fn()
+						.mockReturnValue(
+							mockAllModels.map((m) => ({ ...m, provider: "openrouter" })),
+						),
+					getAvailable: vi.fn().mockReturnValue([{ provider: "openrouter" }]),
+					registerProvider: vi.fn(),
+				},
+			};
+
+			await sessionStartHandler({}, mockCtx);
+
+			expect(mockCtx.modelRegistry.registerProvider).toHaveBeenCalled();
+		});
+
+		it("should set API key in env when no existing auth", async () => {
+			vi.mocked(fetchOpenRouterModelsWithFree).mockResolvedValue({
+				free: [
+					{
+						id: "test-model",
+						name: "Test",
+						reasoning: false,
+						input: ["text"],
+						cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+						contextWindow: 128000,
+						maxTokens: 4096,
+					},
+				],
+				all: [],
+			});
+
+			await openrouterProvider(mockPi);
+
+			const sessionStartHandler = mockOn.mock.calls.find(
+				(call) => call[0] === "session_start",
+			)?.[1];
+
+			const mockCtx = {
+				modelRegistry: {
+					getAll: vi.fn().mockReturnValue([]),
+					getAvailable: vi.fn().mockReturnValue([]),
+					registerProvider: vi.fn(),
+				},
+			};
+
+			await sessionStartHandler({}, mockCtx);
+
+			expect(process.env.OPENROUTER_API_KEY).toBe("test-api-key");
+		});
+	});
+
+	describe("setupProvider integration", () => {
+		it("should call setupProvider with correct config", async () => {
+			vi.mocked(fetchOpenRouterModelsWithFree).mockResolvedValue({
+				free: [],
+				all: [],
+			});
+
+			await openrouterProvider(mockPi);
+
+			expect(setupProvider).toHaveBeenCalledWith(
+				mockPi,
+				expect.objectContaining({
+					providerId: "openrouter",
+					reRegister: expect.any(Function),
+				}),
+				expect.objectContaining({ free: [], all: [] }),
+			);
+		});
+	});
+});