pi-harness-runtime 1.1.440 → 1.1.441

package/packages/providers/test/providers.test.ts

@@ -1,225 +0,0 @@
-/**
- * Providers Tests
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	MiniMaxAdapter,
-	OpenAIAdapter,
-	ClaudeAdapter,
-	AdapterRegistry,
-} from "../src/adapters.js";
-import type { ProviderConfig } from "../../../packages/types/src/runtime-types.js";
-
-const makeConfig = (id: string): ProviderConfig => ({
-	id,
-	name: id,
-	models: [`${id}/model-a`, `${id}/model-b`],
-	capabilities: ["code", "review"],
-	rateLimits: {},
-});
-
-describe("MiniMaxAdapter", () => {
-	const adapter = new MiniMaxAdapter(makeConfig("minimax"));
-
-	it("has correct id and name", () => {
-		expect(adapter.id).toBe("minimax");
-		expect(adapter.name).toBe("MiniMax");
-	});
-
-	it("supports its configured models", () => {
-		expect(adapter.supportsModel("minimax/model-a")).toBe(true);
-		expect(adapter.supportsModel("minimax/model-b")).toBe(true);
-	});
-
-	it("does not support other models", () => {
-		expect(adapter.supportsModel("openai/gpt-4")).toBe(false);
-	});
-
-	it("returns default model", () => {
-		expect(adapter.getDefaultModel()).toBe("minimax/model-a");
-	});
-
-	it("returns correct max tokens", () => {
-		expect(adapter.getMaxTokens("minimax/MiniMax-Text-01")).toBe(1000000);
-		expect(adapter.getMaxTokens("minimax/MiniMax-M3")).toBe(32768);
-	});
-
-	it("returns capabilities", () => {
-		const caps = adapter.getCapabilities();
-		expect(caps).toContain("code");
-		expect(caps).toContain("review");
-	});
-
-	it("parses MiniMax quota errors", () => {
-		const result = adapter.parseError({
-			message: "Error code: 2056 - Rate limit exceeded",
-		});
-		expect(result.quotaExceeded).toBe(true);
-		expect(result.rateLimited).toBe(true);
-	});
-
-	it("parses rate limit errors", () => {
-		const result = adapter.parseError({
-			message: "Rate limit exceeded, retry after 429",
-		});
-		expect(result.rateLimited).toBe(true);
-	});
-
-	it("parses timeout errors", () => {
-		const result = adapter.parseError({ message: "Request timed out" });
-		expect(result.timeout).toBe(true);
-	});
-
-	it("parses server errors", () => {
-		const result = adapter.parseError({ message: "Internal server error 500" });
-		expect(result.serverError).toBe(true);
-	});
-
-	it("parses client errors", () => {
-		const result = adapter.parseError({ message: "Bad request 400" });
-		expect(result.clientError).toBe(true);
-	});
-
-	it("invokes and returns mock result", async () => {
-		const result = await adapter.invoke({
-			model: "minimax/model-a",
-			messages: [],
-			maxTokens: 100,
-		});
-		expect(result.response.content).toBe("Mock response");
-		expect(result.retryable).toBe(false);
-	});
-});
-
-describe("OpenAIAdapter", () => {
-	const adapter = new OpenAIAdapter(makeConfig("openai"));
-
-	it("has correct id and name", () => {
-		expect(adapter.id).toBe("openai");
-		expect(adapter.name).toBe("OpenAI");
-	});
-
-	it("parses insufficient_quota error", () => {
-		const result = adapter.parseError({
-			code: "insufficient_quota",
-			message: "Quota exceeded",
-		});
-		expect(result.quotaExceeded).toBe(true);
-		expect(result.quotaSignal?.exhausted).toBe(true);
-	});
-
-	it("parses rate_limit_exceeded error", () => {
-		const result = adapter.parseError({
-			code: "rate_limit_exceeded",
-			message: "Rate limit",
-		});
-		expect(result.rateLimited).toBe(true);
-	});
-
-	it("returns correct max tokens", () => {
-		expect(adapter.getMaxTokens("openai/gpt-4o")).toBe(128000);
-	});
-});
-
-describe("ClaudeAdapter", () => {
-	const adapter = new ClaudeAdapter(makeConfig("anthropic"));
-
-	it("has correct id and name", () => {
-		expect(adapter.id).toBe("anthropic");
-		expect(adapter.name).toBe("Anthropic Claude");
-	});
-
-	it("returns Claude default model", () => {
-		expect(adapter.getDefaultModel()).toBe(
-			"anthropic/claude-3-5-sonnet-20240620",
-		);
-	});
-
-	it("returns large token limits for Claude models", () => {
-		expect(adapter.getMaxTokens("anthropic/claude-3-5-sonnet-20240620")).toBe(
-			200000,
-		);
-		expect(adapter.getMaxTokens("anthropic/claude-3-opus-20240229")).toBe(
-			200000,
-		);
-		expect(adapter.getMaxTokens("anthropic/claude-2")).toBe(100000);
-	});
-
-	it("parses rate_limit_error type", () => {
-		const result = adapter.parseError({
-			type: "rate_limit_error",
-			message: "Rate limited",
-		});
-		expect(result.rateLimited).toBe(true);
-	});
-
-	it("parses overloaded_error type", () => {
-		const result = adapter.parseError({
-			type: "overloaded_error",
-			message: "Overloaded",
-		});
-		expect(result.rateLimited).toBe(true);
-		expect(result.serverError).toBe(true);
-	});
-
-	it("parses quota_error type", () => {
-		const result = adapter.parseError({
-			type: "quota_error",
-			message: "Quota exceeded",
-		});
-		expect(result.quotaExceeded).toBe(true);
-		expect(result.quotaSignal?.exhausted).toBe(true);
-	});
-
-	it("parses authentication_error as client error", () => {
-		const result = adapter.parseError({
-			type: "authentication_error",
-			message: "Auth failed",
-		});
-		expect(result.clientError).toBe(true);
-	});
-});
-
-describe("AdapterRegistry", () => {
-	it("starts empty", () => {
-		const registry = new AdapterRegistry();
-		expect(registry.list()).toEqual([]);
-		expect(registry.get("minimax")).toBeUndefined();
-	});
-
-	it("registers and retrieves adapters", () => {
-		const registry = new AdapterRegistry();
-		const adapter = new MiniMaxAdapter(makeConfig("minimax"));
-		registry.register(adapter);
-
-		expect(registry.get("minimax")).toBe(adapter);
-		expect(registry.list()).toHaveLength(1);
-	});
-
-	it("creates default registry with all adapters", () => {
-		const registry = AdapterRegistry.createDefault();
-		const adapters = registry.list();
-
-		expect(adapters.some((a) => a.id === "minimax")).toBe(true);
-		expect(adapters.some((a) => a.id === "openai")).toBe(true);
-		expect(adapters.some((a) => a.id === "anthropic")).toBe(true);
-		expect(registry.get("minimax")).toBeDefined();
-		expect(registry.get("openai")).toBeDefined();
-		expect(registry.get("anthropic")).toBeDefined();
-	});
-
-	it("overwrites adapter with same id", () => {
-		const registry = new AdapterRegistry();
-		const a1 = new MiniMaxAdapter(makeConfig("minimax"));
-		const a2 = new MiniMaxAdapter({
-			...makeConfig("minimax"),
-			name: "New MinMax",
-		});
-		registry.register(a1);
-		registry.register(a2);
-
-		expect(registry.list()).toHaveLength(1);
-		expect(registry.get("minimax")).toBe(a2);
-	});
-});

package/packages/qdrant-skills/test/collection-info.test.ts

@@ -1,165 +0,0 @@
-/**
- * The collection info of Qdrant.
- *
- * Qdrant reports the vector configuration under `config.params.vectors` -
- * not at the top level. Reading `info.vectors` yields undefined for every
- * collection, which turned every schema check into "dimension mismatch:
- * got undefined" and hid the real cause of an incompatible collection.
- *
- * The client is a small double, so the test never reaches the network.
- */
-
-import { describe, expect, it } from "bun:test";
-
-import {
-	getCollectionInfo,
-	isNotFoundError,
-	validateCollectionSchema,
-} from "../src/client.js";
-
-/** A client that answers with the given collection description. */
-function fakeClient(description: unknown): {
-	getCollection: (name: string) => Promise<unknown>;
-} {
-	return {
-		getCollection: async () => description,
-	};
-}
-
-/** The description Qdrant answers with for a 384-dimensional collection. */
-const MINILM_DESCRIPTION = {
-	status: "green",
-	points_count: 79,
-	config: {
-		params: {
-			vectors: { size: 384, distance: "Cosine" },
-		},
-	},
-};
-
-describe("the collection info", () => {
-	it("reads the vector size and the distance", async () => {
-		const info = await getCollectionInfo(
-			fakeClient(MINILM_DESCRIPTION) as never,
-			"pi-harness-skills",
-		);
-		expect(info).not.toBeNull();
-		expect(info?.exists).toBe(true);
-		expect(info?.vectorsSize).toBe(384);
-		expect(info?.vectorsDistance).toBe("Cosine");
-	});
-
-	it("reads the number of points", async () => {
-		const info = await getCollectionInfo(
-			fakeClient(MINILM_DESCRIPTION) as never,
-			"pi-harness-skills",
-		);
-		expect(info?.pointsCount).toBe(79);
-	});
-
-	it("reads a named vector configuration", async () => {
-		const info = await getCollectionInfo(
-			fakeClient({
-				points_count: 3,
-				config: {
-					params: {
-						vectors: { named: { text: { size: 1536, distance: "Dot" } } },
-					},
-				},
-			}) as never,
-			"pi-harness-skills",
-		);
-		expect(info?.vectorsSize).toBe(1536);
-		expect(info?.vectorsDistance).toBe("Dot");
-	});
-
-	it("still reads a flat description", async () => {
-		// An older proxy answers without the config wrapper.
-		const info = await getCollectionInfo(
-			fakeClient({ points_count: 1, vectors: { size: 1536, distance: "Cosine" } }) as never,
-			"pi-harness-skills",
-		);
-		expect(info?.vectorsSize).toBe(1536);
-		expect(info?.vectorsDistance).toBe("Cosine");
-	});
-
-	it("reports a missing collection", async () => {
-		const client = {
-			getCollection: async () => {
-				throw new Error("Not found: Collection not found");
-			},
-		};
-		const info = await getCollectionInfo(client as never, "pi-harness-skills");
-		expect(info).toEqual({ exists: false });
-	});
-
-	it("reports a missing collection the way Qdrant really answers", async () => {
-		// Qdrant answers with the status 404 and the text "Not Found" -
-		// capitalised. A case-sensitive comparison turns a collection that
-		// does not exist yet into "the cluster could not be read".
-		const client = {
-			getCollection: async () => {
-				const error = new Error("Not Found") as Error & {
-					status: number;
-					headers: unknown;
-					url: string;
-				};
-				error.status = 404;
-				throw error;
-			},
-		};
-		const info = await getCollectionInfo(client as never, "pi-harness-skills-openai-v1");
-		expect(info).toEqual({ exists: false });
-	});
-
-	it("tells a missing collection apart from an unreachable cluster", async () => {
-		const missing = new Error("Not Found") as Error & { status: number };
-		missing.status = 404;
-		expect(isNotFoundError(missing)).toBe(true);
-
-		const unreachable = new Error("connection refused");
-		expect(isNotFoundError(unreachable)).toBe(false);
-
-		const forbidden = new Error("Forbidden") as Error & { status: number };
-		forbidden.status = 403;
-		expect(isNotFoundError(forbidden)).toBe(false);
-	});
-
-	it("reports an unreadable collection as unknown", async () => {
-		const client = {
-			getCollection: async () => {
-				throw new Error("connection refused");
-			},
-		};
-		expect(await getCollectionInfo(client as never, "pi-harness-skills")).toBeNull();
-	});
-});
-
-describe("the schema check", () => {
-	it("names the real dimensions of an incompatible collection", async () => {
-		const result = await validateCollectionSchema(
-			fakeClient(MINILM_DESCRIPTION) as never,
-			"pi-harness-skills",
-			1536,
-		);
-		expect(result.valid).toBe(false);
-		// The message names the size the collection really has - not
-		// "undefined".
-		expect(result.error).toContain("384");
-		expect(result.error).not.toContain("undefined");
-		expect(result.actualDimensions).toBe(384);
-	});
-
-	it("accepts a collection with the expected dimensions", async () => {
-		const result = await validateCollectionSchema(
-			fakeClient({
-				points_count: 79,
-				config: { params: { vectors: { size: 1536, distance: "Cosine" } } },
-			}) as never,
-			"pi-harness-skills",
-			1536,
-		);
-		expect(result.valid).toBe(true);
-		expect(result.actualDimensions).toBe(1536);
-	});
-});

package/packages/qdrant-skills/test/embedder-batch.test.ts

@@ -1,184 +0,0 @@
-/**
- * The batch embeddings of the embedder.
- *
- * One request per text exhausts the sockets of the process when a registry
- * holds hundreds of skills. The endpoint of OpenAI accepts an array of
- * inputs, so a batch stays one request per chunk.
- *
- * The HTTP client is injected, so the test never replaces a global and never
- * reaches the network.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { createEmbeddingsBatch } from "../src/embedder.js";
-
-/** One recorded request. */
-interface RecordedRequest {
-	url: string;
-	body: { model: string; input: string[] };
-	authorization: string;
-}
-
-/** A client that answers with the given vectors. */
-function fakeFetch(
-	vectors: number[][],
-	recorded: RecordedRequest[],
-): typeof fetch {
-	return (async (input: string | URL | Request, init?: RequestInit) => {
-		const body = JSON.parse(String(init?.body ?? "{}")) as {
-			model: string;
-			input: string[];
-		};
-		recorded.push({
-			url: String(input),
-			body,
-			authorization: String(
-				(init?.headers as Record<string, string>)?.Authorization ?? "",
-			),
-		});
-		return {
-			ok: true,
-			json: async () => ({
-				// The endpoint may answer out of order.
-				data: body.input.map((_, index) => {
-					const position = body.input.length - 1 - index;
-					return { index: position, embedding: vectors[position] };
-				}),
-				usage: { total_tokens: body.input.length * 3 },
-			}),
-			text: async () => "",
-		} as Response;
-	}) as unknown as typeof fetch;
-}
-
-/** The environment variables the key lookup looks at. */
-const ENV_KEYS = ["OPENAI_API_KEY", "HOME", "USERPROFILE"] as const;
-
-let saved: Record<string, string | undefined> = {};
-let tempHome: string;
-
-beforeEach(() => {
-	saved = {};
-	for (const key of ENV_KEYS) {
-		saved[key] = process.env[key];
-		delete process.env[key];
-	}
-	// A fresh home directory: the test never reads the key of the machine
-	// it runs on.
-	tempHome = mkdtempSync(join(homedir(), ".test-qdrant-batch-"));
-	process.env.HOME = tempHome;
-	process.env.USERPROFILE = tempHome;
-});
-
-afterEach(() => {
-	for (const key of ENV_KEYS) {
-		if (saved[key] === undefined) delete process.env[key];
-		else process.env[key] = saved[key];
-	}
-	rmSync(tempHome, { recursive: true, force: true });
-});
-
-describe("the batch embeddings of the embedder", () => {
-	it("sends one request for many texts", async () => {
-		const recorded: RecordedRequest[] = [];
-		const texts = ["first", "second", "third"];
-
-		const result = await createEmbeddingsBatch(
-			texts,
-			"sk-test-key",
-			{ fetchImpl: fakeFetch([[1], [2], [3]], recorded) },
-		);
-
-		expect(recorded.length).toBe(1);
-		expect(recorded[0].body.input).toEqual(texts);
-		expect(result.embeddings).toEqual([[1], [2], [3]]);
-		expect(result.tokens).toBe(9);
-	});
-
-	it("keeps the order of the texts even when the answer is out of order", async () => {
-		const recorded: RecordedRequest[] = [];
-
-		const result = await createEmbeddingsBatch(
-			["a", "b", "c"],
-			"sk-test-key",
-			{ fetchImpl: fakeFetch([[10], [20], [30]], recorded) },
-		);
-
-		expect(result.embeddings).toEqual([[10], [20], [30]]);
-	});
-
-	it("splits a large input into chunks", async () => {
-		const recorded: RecordedRequest[] = [];
-		const texts = Array.from({ length: 150 }, (_, index) => `text-${index}`);
-
-		const result = await createEmbeddingsBatch(
-			texts,
-			"sk-test-key",
-			{ fetchImpl: fakeFetch(texts.map((_, index) => [index]), recorded) },
-		);
-
-		// The chunk size is 64, so 150 texts need three requests.
-		expect(recorded.length).toBe(3);
-		expect(recorded[0].body.input.length).toBe(64);
-		expect(recorded[1].body.input.length).toBe(64);
-		expect(recorded[2].body.input.length).toBe(22);
-		expect(result.embeddings.length).toBe(150);
-		expect(result.tokens).toBe(150 * 3);
-	});
-
-	it("sends no request for an empty input", async () => {
-		const recorded: RecordedRequest[] = [];
-
-		const result = await createEmbeddingsBatch([], "sk-test-key", {
-			fetchImpl: fakeFetch([], recorded),
-		});
-
-		expect(recorded.length).toBe(0);
-		expect(result.embeddings).toEqual([]);
-		expect(result.tokens).toBe(0);
-	});
-
-	it("sends the OpenAI key of the caller", async () => {
-		const recorded: RecordedRequest[] = [];
-
-		await createEmbeddingsBatch(["text"], "sk-test-key", {
-			fetchImpl: fakeFetch([[1]], recorded),
-		});
-
-		expect(recorded[0].authorization).toBe("Bearer sk-test-key");
-		expect(recorded[0].url).toBe("https://api.openai.com/v1/embeddings");
-	});
-
-	it("trims a very long text", async () => {
-		const recorded: RecordedRequest[] = [];
-
-		await createEmbeddingsBatch(["x".repeat(9000)], "sk-test-key", {
-			fetchImpl: fakeFetch([[1]], recorded),
-		});
-
-		expect(recorded[0].body.input[0].length).toBe(8000);
-	});
-
-	it("reports a failed request", async () => {
-		const failing = (async () =>
-			({
-				ok: false,
-				text: async () => "the endpoint refused the request",
-			}) as Response) as unknown as typeof fetch;
-
-		await expect(
-			createEmbeddingsBatch(["text"], "sk-test-key", { fetchImpl: failing }),
-		).rejects.toThrow(/OpenAI embedding failed/);
-	});
-
-	it("reports a missing key", async () => {
-		// The home directory points at a fresh directory and the environment
-		// carries no key, so the machine of the test cannot provide one.
-		await expect(
-			createEmbeddingsBatch(["text"], "", { fetchImpl: fakeFetch([[1]], []) }),
-		).rejects.toThrow(/No OpenAI API key/);
-	});
-});

package/packages/qdrant-skills/test/embedder.test.ts

@@ -1,97 +0,0 @@
-/**
- * The OpenAI key of the embedder.
- *
- * The embeddings endpoint of OpenAI accepts only an OpenAI key. The key of
- * another provider is a different credential and must never be sent there.
- * The loader must also work in ESM, where `require` does not exist.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { getOpenAIApiKey } from "../src/embedder.js";
-
-/** The environment variables the loader looks at. */
-const ENV_KEYS = [
-	"OPENAI_API_KEY",
-	"TYPESAFE_API_KEY",
-	"OPENROUTER_API_KEY",
-	"HOME",
-	"USERPROFILE",
-] as const;
-
-let saved: Record<string, string | undefined> = {};
-let tempHome: string;
-
-beforeEach(() => {
-	saved = {};
-	for (const key of ENV_KEYS) {
-		saved[key] = process.env[key];
-		delete process.env[key];
-	}
-	// The home directory points at a fresh directory, so the test never
-	// reads the key of the machine it runs on.
-	tempHome = mkdtempSync(join(homedir(), ".test-qdrant-embedder-"));
-	process.env.HOME = tempHome;
-	process.env.USERPROFILE = tempHome;
-});
-
-afterEach(() => {
-	for (const key of ENV_KEYS) {
-		if (saved[key] === undefined) delete process.env[key];
-		else process.env[key] = saved[key];
-	}
-	rmSync(tempHome, { recursive: true, force: true });
-});
-
-/** Write a key file of the installation. */
-function writeKeyFile(name: string, content: string): void {
-	const dir = join(tempHome, ".pi-harness-runtime", "keys");
-	mkdirSync(dir, { recursive: true });
-	writeFileSync(join(dir, name), content, "utf8");
-}
-
-describe("the OpenAI key of the embedder", () => {
-	it("takes the key of the environment", () => {
-		process.env.OPENAI_API_KEY = "sk-openai-from-env";
-		expect(getOpenAIApiKey()).toBe("sk-openai-from-env");
-	});
-
-	it("takes the key file of the installation", () => {
-		writeKeyFile("openai-api-key.txt", "sk-openai-from-file\n");
-		expect(getOpenAIApiKey()).toBe("sk-openai-from-file");
-	});
-
-	it("takes the token of a pi.dev login", () => {
-		const dir = join(tempHome, ".pi", "agent");
-		mkdirSync(dir, { recursive: true });
-		writeFileSync(
-			join(dir, "auth.json"),
-			JSON.stringify({ openai: { access: "openai-oauth-token" } }),
-			"utf8",
-		);
-		expect(getOpenAIApiKey()).toBe("openai-oauth-token");
-	});
-
-	it("never takes the key of another provider", () => {
-		// A TypeSafe key and an OpenRouter key are different credentials:
-		// the embeddings endpoint of OpenAI rejects them.
-		process.env.TYPESAFE_API_KEY = "ts-key-of-another-provider";
-		expect(getOpenAIApiKey()).toBeNull();
-
-		process.env.OPENROUTER_API_KEY = "or-key-of-another-provider";
-		expect(getOpenAIApiKey()).toBeNull();
-	});
-
-	it("prefers the OpenAI key over the key of another provider", () => {
-		process.env.OPENAI_API_KEY = "sk-openai-from-env";
-		process.env.TYPESAFE_API_KEY = "ts-key-of-another-provider";
-		process.env.OPENROUTER_API_KEY = "or-key-of-another-provider";
-		expect(getOpenAIApiKey()).toBe("sk-openai-from-env");
-	});
-
-	it("finds no key when there is none", () => {
-		expect(getOpenAIApiKey()).toBeNull();
-	});
-});