pi-inferhub 0.2.0 → 0.3.0

package/test/auth.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { loginInferhub } from "../src/auth.js";
-
-function interaction(responses: string[], notified: string[] = []) {
-	let i = 0;
-	return {
-		signal: new AbortController().signal,
-		prompt: vi.fn(async () => {
-			const v = responses[i++];
-			if (v === undefined) throw new Error("prompt exhausted");
-			return v;
-		}),
-		notify: (e: { type: string; message?: string }) => notified.push(`${e.type}: ${e.message}`),
-	};
-}
-
-describe("loginInferhub", () => {
-	it("validates the key against /me and returns an api_key credential", async () => {
-		const fetchMock = vi.fn(async (_url: string, init?: RequestInit) =>
-			new Response(JSON.stringify({}), { status: 200, headers: { "content-type": "application/json" } }));
-		const result = await loginInferhub(interaction(["sk-airo-abc"]), { fetchImpl: fetchMock as typeof fetch });
-		expect(result).toEqual({ type: "api_key", key: "sk-airo-abc" });
-		expect((fetchMock.mock.calls[0][1]?.headers as Record<string, string>)["Authorization"]).toBe("Bearer sk-airo-abc");
-	});
-
-	it("re-prompts after a 401 and notifies, up to 3 attempts", async () => {
-		// Ruled fix (controller 2026-10-06): the brief's mock was always-401, contradicting
-		// this test's intent and test 3. Mock returns 401 twice, then 200 on call 3.
-		const fetchMock = vi.fn(async () => new Response(JSON.stringify({ error: { code: "invalid_api_key", message: "bad key" } }), { status: 401 }))
-			.mockImplementationOnce(async () => new Response(JSON.stringify({ error: { code: "invalid_api_key", message: "bad key" } }), { status: 401 }))
-			.mockImplementationOnce(async () => new Response(JSON.stringify({ error: { code: "invalid_api_key", message: "bad key" } }), { status: 401 }))
-			.mockImplementationOnce(async () => new Response(JSON.stringify({}), { status: 200 }));
-		const notified: string[] = [];
-		const result = await loginInferhub(interaction(["sk-bad", "sk-bad", "sk-airo-good"], notified), { fetchImpl: fetchMock as typeof fetch });
-		expect(result.key).toBe("sk-airo-good");
-		expect(notified.some((n) => n.startsWith("info:"))).toBe(true);
-	});
-
-	it("throws after 3 failed attempts", async () => {
-		const fetchMock = vi.fn(async () => new Response("{}", { status: 401 }));
-		await expect(loginInferhub(interaction(["a", "b", "c"]), { fetchImpl: fetchMock as typeof fetch })).rejects.toThrow(/three/);
-	});
-});

package/test/catalog.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { CatalogModel, Combo } from "../src/catalog.js";
-import { combosToModels } from "../src/catalog.js";
-import { INFERENCE_BASE_URL, PROVIDER_NAME } from "../src/inferhub.js";
-
-const base = {
-	input_token_limit: 200_000,
-	max_output_tokens: 32_000,
-	modality: "text,image",
-	reasoning_levels: ["low", "high"],
-	pricing: { official_in: 3.0, official_out: 15.0 },
-};
-
-const catalog: CatalogModel[] = [
-	{ id: "croc/glm-5.3", ...base },
-	{ id: "ag/claude-opus", ...base, modality: "text", input_token_limit: 100_000, max_output_tokens: 16_000, pricing: { official_in: 1.0, official_out: 5.0 } },
-];
-
-const combo = (members: Combo["members"], overrides: Partial<Combo> = {}): Combo => ({
-	id: "c1", name: "My Combo", slug: "my-combo", members, ...overrides,
-});
-
-/** Bare alias row shape observed live 2026-10-15: id without prefix, owned_by "alias",
- *  no limits/pricing/reasoning fields at all. */
-const aliasRow = (name: string): CatalogModel => ({ id: name, owned_by: "alias" });
-
-describe("combosToModels", () => {
-	it("maps id, name, provider, baseUrl, api", () => {
-		const [m] = combosToModels([combo([{ kind: "model", model: "croc/glm-5.3" }])], catalog);
-		expect(m.id).toBe("combo/my-combo");
-		expect(m.name).toBe("My Combo");
-		expect(m.provider).toBe(PROVIDER_NAME);
-		expect(m.baseUrl).toBe(INFERENCE_BASE_URL);
-		expect(m.api).toBe("openai-completions");
-	});
-
-	it("derives min limits, all-members image rule, and cheapest-member cost", () => {
-		const [m] = combosToModels([combo([{ kind: "model", model: "croc/glm-5.3" }, { kind: "model", model: "ag/claude-opus" }])], catalog);
-		expect(m.contextWindow).toBe(100_000);
-		expect(m.maxTokens).toBe(16_000);
-		expect(m.input).toEqual(["text"]); // one text-only member demotes the combo
-		expect(m.reasoning).toBe(true);
-		expect(m.cost).toEqual({ input: 1.0, output: 5.0, cacheRead: 0, cacheWrite: 0 });
-	});
-
-	it("falls back to slug when name is blank; empty name whitespace counts", () => {
-		const [m] = combosToModels([combo([{ kind: "model", model: "croc/glm-5.3" }], { name: "  " })], catalog);
-		expect(m.name).toBe("my-combo");
-	});
-
-	it("skips unresolvable members and alias members; alias-only combo gets safe defaults", () => {
-		const aliasOnly = combosToModels([combo([{ kind: "alias", alias: "glm-5" }])], catalog);
-		expect(aliasOnly[0].input).toEqual(["text"]);
-		expect(aliasOnly[0].reasoning).toBe(true);
-		expect(aliasOnly[0].cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
-		expect(aliasOnly[0].contextWindow).toBe(262_144);
-		expect(aliasOnly[0].maxTokens).toBe(131_072);
-
-		const partial = combosToModels([combo([{ kind: "model", model: "ghost/gone" }, { kind: "model", model: "croc/glm-5.3" }])], catalog);
-		expect(partial[0].contextWindow).toBe(200_000);
-		expect(partial[0].input).toEqual(["text", "image"]);
-	});
-
-	it("preserves combo order and handles empty combo list", () => {
-		const models = combosToModels([
-			combo([{ kind: "model", model: "ag/claude-opus" }], { slug: "b-combo", name: "B" }),
-			combo([{ kind: "model", model: "croc/glm-5.3" }], { slug: "a-combo", name: "A" }),
-		], catalog);
-		expect(models.map((m) => m.id)).toEqual(["combo/b-combo", "combo/a-combo"]);
-		expect(combosToModels([], catalog)).toEqual([]);
-	});
-
-	it("raises bare alias rows and alias-kind members via prefixed sibling join (live combo/fast shape)", () => {
-		// Members named like a user-built combo: bare names whose catalog rows are
-		// information-free alias rows, but prefixed servings of the same model exist.
-		const sibCatalog: CatalogModel[] = [
-			aliasRow("qwen3.8-flash"),
-			aliasRow("deepseek-v4.1-flash"),
-			aliasRow("glm-5.3-flash"),
-			{ id: "ocg/qwen3.8-flash", ...base },
-			{ id: "ali/qwen3.8-flash", ...base },
-			{ id: "ocg/deepseek-v4.1-flash", ...base, pricing: { official_in: 2.0, official_out: 10.0 } },
-			{ id: "zai/glm-5.3-flash", ...base },
-		];
-		const [m] = combosToModels([combo([
-			{ kind: "model", model: "qwen3.8-flash" },
-			{ kind: "alias", alias: "deepseek-v4.1-flash" },
-			{ kind: "model", model: "glm-5.3-flash" },
-		])], sibCatalog);
-		expect(m.contextWindow).toBe(200_000); // min over sibling servings, not the 128k fallback
-		expect(m.maxTokens).toBe(32_000);
-		expect(m.reasoning).toBe(true);
-		expect(m.thinkingLevelMap).toMatchObject({ low: "low", high: "high" });
-		expect(m.input).toEqual(["text", "image"]); // every sibling serving is vision-capable
-		expect(m.cost).toEqual({ input: 2.0, output: 10.0, cacheRead: 0, cacheWrite: 0 });
-	});
-
-	it("does not cross-join a siblingless alias and keeps safe defaults (claude fable shape)", () => {
-		// cc/ row exists but is null everywhere and has NO prefixed siblings carrying data.
-		const [m] = combosToModels([combo([{ kind: "model", model: "claude-fable-5-1" }])], [aliasRow("claude-fable-5-1")]);
-		expect(m.contextWindow).toBe(262_144);
-		expect(m.maxTokens).toBe(131_072);
-		expect(m.reasoning).toBe(true); // alias-only optimism invariant
-		expect(m.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
-	});
-
-	it("prefers a direct row's real data over sibling join", () => {
-		// A prefixed member resolves directly; siblings must not inflate its set.
-		const sibCatalog: CatalogModel[] = [
-			{ id: "croc/glm-5.3", ...base },
-			{ id: "other/glm-5.3", ...base, input_token_limit: 1_000_000, max_output_tokens: 128_000 },
-		];
-		const [m] = combosToModels([combo([{ kind: "model", model: "croc/glm-5.3" }])], sibCatalog);
-		expect(m.contextWindow).toBe(200_000); // only the directly-joined member counts
-		expect(m.maxTokens).toBe(32_000);
-	});
-
-	it("reasoning false when no member advertises levels", () => {
-		const noLevels: CatalogModel = { id: "x/plain", modality: "text" };
-		const [m] = combosToModels([combo([{ kind: "model", model: "x/plain" }])], [noLevels]);
-		expect(m.reasoning).toBe(false);
-	});
-});

package/test/http.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { Type } from "typebox";
-import { Compile } from "typebox/compile";
-import { fetchJson, InferhubHttpError } from "../src/http.js";
-
-const Payload = Type.Object({ object: Type.String() });
-const Validator = Compile(Payload);
-
-function respond(status: number, body: string, headers: Record<string, string> = {}): Response {
-	const h = new Headers({ "content-type": "application/json", ...headers });
-	return new Response(body, { status, headers: h });
-}
-
-describe("fetchJson", () => {
-	it("sends bearer auth and user agent, parses and validates JSON", async () => {
-		const fetchMock = vi.fn(async () => respond(200, JSON.stringify({ object: "list" })));
-		const result = await fetchJson("https://x/y", "sk-test", Validator, undefined, { fetchImpl: fetchMock as typeof fetch });
-		expect(result).toEqual({ object: "list" });
-		const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
-		expect(url).toBe("https://x/y");
-		expect((init.headers as Record<string, string>)["Authorization"]).toBe("Bearer sk-test");
-		expect((init.headers as Record<string, string>)["User-Agent"]).toMatch(/^pi-inferhub\//);
-	});
-
-	it("throws InferhubHttpError with parsed code/message on error JSON", async () => {
-		const fetchMock = vi.fn(async () => respond(403, JSON.stringify({ error: { code: "account_blocked", message: "banned: reason" } })));
-		await expect(fetchJson("https://x/y", "k", Validator, undefined, { fetchImpl: fetchMock as typeof fetch }))
-			.rejects.toMatchObject({ status: 403, code: "account_blocked", message: "banned: reason" });
-	});
-
-	it("aborts via signal and surfaces non-JSON error bodies as raw text", async () => {
-		const controller = new AbortController();
-		const fetchMock = vi.fn(async (_url: string, init?: RequestInit) => {
-			controller.abort();
-			throw new DOMException("aborted", "AbortError");
-		});
-		await expect(fetchJson("https://x/y", "k", Validator, controller.signal, { fetchImpl: fetchMock as typeof fetch }))
-			.rejects.toMatchObject({ name: "AbortError" });
-		const fetchMock2 = vi.fn(async () => respond(500, "<html>oops</html>"));
-		await expect(fetchJson("https://x/y", "k", Validator, undefined, { fetchImpl: fetchMock2 as typeof fetch }))
-			.rejects.toMatchObject({ status: 500, code: "http_500" });
-	});
-});

package/test/index.test.ts

@@ -1,159 +0,0 @@
-import type { ModelsPublication, Provider, RefreshModelsContext } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { inferhubApiKeyAuth, loginInferhub } from "../src/auth.js";
-import { registerInferhubProvider, type InferhubRegistrationPi } from "../src/index.js";
-import { INFERENCE_BASE_URL } from "../src/inferhub.js";
-
-function registrationHarness() {
-	const providers = new Map<string, Provider>();
-	const commands = new Map<string, { description?: string; handler: (args: string, ctx: ExtensionCommandContext) => Promise<void> }>();
-	const pi: InferhubRegistrationPi = {
-		registerProvider: (provider) => void providers.set(provider.id, provider),
-		registerCommand: (name, options) => void commands.set(name, options),
-	};
-	return { pi, providers, commands };
-}
-
-function refreshContext(overrides: Partial<RefreshModelsContext> = {}) {
-	const publications: ModelsPublication[] = [];
-	const context: RefreshModelsContext = {
-		credential: { type: "api_key", key: "sk-test" },
-		publish: async (publication) => {
-			publications.push(publication);
-			publication.update?.();
-			return true;
-		},
-		allowNetwork: true,
-		signal: new AbortController().signal,
-		...overrides,
-	};
-	return { context, publications };
-}
-
-/** Stub GET /combos + GET /v1/models, recording Authorization headers per call. */
-function stubCatalogFetch() {
-	const authHeaders: string[] = [];
-	const fetchMock = vi.fn(async (url: string, init?: RequestInit) => {
-		const headers = (init?.headers ?? {}) as Record<string, string>;
-		authHeaders.push(headers["Authorization"] ?? "");
-		const body = String(url).includes("/combos")
-			? [{ id: "c1", name: "Test Combo", slug: "test-combo", members: [{ kind: "model", model: "croc/glm-5.3" }] }]
-			: {
-					data: [
-						{
-							id: "croc/glm-5.3",
-							modality: "text,image",
-							input_token_limit: 200_000,
-							max_output_tokens: 8_192,
-							reasoning_levels: ["low"],
-							pricing: { official_in: 3, official_out: 15 },
-						},
-					],
-				};
-		return new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json" } });
-	});
-	vi.stubGlobal("fetch", fetchMock);
-	return { fetchMock, authHeaders };
-}
-
-afterEach(() => {
-	vi.unstubAllGlobals();
-});
-
-describe("registerInferhubProvider", () => {
-	it("registers the inferhub provider with empty baseline, login+env auth, and dynamic model fetch", () => {
-		const { pi, providers } = registrationHarness();
-		registerInferhubProvider(pi);
-		expect(providers.has("inferhub")).toBe(true);
-		const provider = providers.get("inferhub")!;
-		expect(provider.name).toBe("InferHub");
-		expect(provider.baseUrl).toBe(INFERENCE_BASE_URL);
-		expect(provider.getModels()).toEqual([]); // baseline; combos arrive via refreshModels
-		expect(provider.refreshModels).toBeTypeOf("function");
-		expect(typeof provider.streamSimple).toBe("function");
-		// envApiKeyAuth resolution + our prompt-validate login overriding the plain default
-		expect(provider.auth.apiKey?.login).toBe(loginInferhub);
-		expect(provider.auth.apiKey?.resolve).toBe(inferhubApiKeyAuth.resolve);
-	});
-
-	it("the default export registers through the same surface", async () => {
-		const { pi, providers, commands } = registrationHarness();
-		const mod = await import("../src/index.js");
-		mod.default(pi as unknown as ExtensionAPI);
-		expect(providers.has("inferhub")).toBe(true);
-		expect(commands.has("inferhub-login")).toBe(true);
-	});
-
-	it("refreshModels maps the combo catalog using the credential key", async () => {
-		const { pi, providers } = registrationHarness();
-		registerInferhubProvider(pi);
-		const { authHeaders } = stubCatalogFetch();
-		const { context, publications } = refreshContext();
-		await providers.get("inferhub")!.refreshModels!(context);
-		expect(providers.get("inferhub")!.getModels().map((m) => m.id)).toEqual(["combo/test-combo"]);
-		const persisted = publications.at(-1)?.persist?.models ?? [];
-		expect(persisted.map((m) => m.id)).toEqual(["combo/test-combo"]);
-		expect(persisted[0]).toMatchObject({
-			name: "Test Combo",
-			api: "openai-completions",
-			provider: "inferhub",
-			baseUrl: INFERENCE_BASE_URL,
-			input: ["text", "image"],
-			contextWindow: 200_000,
-		});
-		expect(authHeaders).toEqual(["Bearer sk-test", "Bearer sk-test"]); // /combos + /v1/models
-	});
-
-	it("refreshModels keeps the empty baseline without a credential (no network)", async () => {
-		const { pi, providers } = registrationHarness();
-		registerInferhubProvider(pi);
-		const { fetchMock } = stubCatalogFetch();
-		const { context } = refreshContext({ credential: undefined });
-		await providers.get("inferhub")!.refreshModels!(context);
-		expect(fetchMock).not.toHaveBeenCalled();
-		expect(providers.get("inferhub")!.getModels()).toEqual([]);
-	});
-
-	it("auth resolves the env key when no stored credential exists", async () => {
-		const { pi, providers } = registrationHarness();
-		registerInferhubProvider(pi);
-		const result = await providers.get("inferhub")!.auth.apiKey!.resolve({
-			ctx: {
-				env: async (name) => (name === "INFERHUB_API_KEY" ? "sk-env" : undefined),
-				fileExists: async () => false,
-			},
-			credential: undefined,
-			signal: new AbortController().signal,
-		});
-		expect(result).toMatchObject({ auth: { apiKey: "sk-env" }, source: "INFERHUB_API_KEY" });
-	});
-
-	it("registers the inferhub-login command pointing at /login inferhub", async () => {
-		const { pi, commands } = registrationHarness();
-		registerInferhubProvider(pi);
-		expect(commands.has("inferhub-login")).toBe(true);
-		const command = commands.get("inferhub-login")!;
-		expect(command.description).toBeTruthy();
-
-		const notified: string[] = [];
-		const queried: string[] = [];
-		const ctxFor = (configured: boolean) =>
-			({
-				modelRegistry: {
-					getProviderAuthStatus: (provider: string) => {
-						queried.push(provider);
-						return { configured };
-					},
-				},
-				ui: { notify: (message: string) => void notified.push(message) },
-			}) as unknown as ExtensionCommandContext;
-
-		await command.handler("", ctxFor(false));
-		expect(queried).toEqual(["inferhub"]);
-		expect(notified[0]).toContain("/login inferhub");
-
-		await command.handler("", ctxFor(true));
-		expect(notified[1]).not.toContain("not configured");
-	});
-});

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-	"compilerOptions": {
-		"module": "NodeNext",
-		"moduleResolution": "NodeNext",
-		"target": "ES2022",
-		"lib": ["ES2022"],
-		"strict": true,
-		"noEmit": true,
-		"skipLibCheck": true,
-		"types": ["node"],
-		"forceConsistentCasingInFileNames": true
-	},
-	"include": ["src", "test"]
-}