@xynogen/pix-9router 0.1.0

package/src/index.ts

@@ -0,0 +1,26 @@
+/**
+ * pix-9router — Pi extension bundle
+ *
+ * Registers:
+ *   - 9router provider  (model list from self-hosted router API)
+ *   - fetch tool        (web page fetch via exa through router)
+ *   - search tool       (web/news search via exa through router)
+ *   - transcribe tool   (speech-to-text via audio transcription API)
+ *
+ * Environment:
+ *   ROUTER_API_BASE  — override base URL  (default: https://9r.xynogen.xyz/v1)
+ *   ROUTER_API_KEY   — bearer token       (required for provider + tools)
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import registerProvider from "./provider.js";
+import registerFetch from "./fetch.js";
+import registerSearch from "./search.js";
+import registerTranscribe from "./transcribe.js";
+
+export default async function (pi: ExtensionAPI): Promise<void> {
+	await registerProvider(pi);
+	registerFetch(pi);
+	registerSearch(pi);
+	registerTranscribe(pi);
+}

package/src/provider.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect } from "bun:test";
+import type { ModelsDevModel, RouterModel } from "./data.ts";
+
+// ── Re-export internal helpers for testing via module augmentation ────────────
+// provider.ts exports only the default fn; we test the pure mapping logic
+// inline here to avoid coupling tests to private internals.
+
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+
+const IMAGE_CAPABLE_PATTERNS = [
+	/claude/i,
+	/gpt-5/i,
+	/gpt-4/i,
+	/kimi-k2/i,
+	/hy3/i,
+];
+
+function getInputTypes(
+	model: RouterModel,
+	devModel?: ModelsDevModel,
+): ("text" | "image")[] {
+	if (devModel?.modalities?.input) {
+		const inputs = devModel.modalities.input.filter(
+			(i): i is "text" | "image" => i === "text" || i === "image",
+		);
+		if (inputs.length > 0) return inputs;
+	}
+	const id = model.id ?? "";
+	if (IMAGE_CAPABLE_PATTERNS.some((p) => p.test(id))) return ["text", "image"];
+	return ["text"];
+}
+
+function getModelName(model: RouterModel, devModel?: ModelsDevModel): string {
+	return model.name || devModel?.name || model.id || "unknown";
+}
+
+function getContextWindow(
+	model: RouterModel,
+	devModel?: ModelsDevModel,
+): number {
+	return (
+		model.context_window ||
+		model.contextWindow ||
+		devModel?.limit?.context ||
+		DEFAULT_CONTEXT_WINDOW
+	);
+}
+
+function getMaxTokens(model: RouterModel, devModel?: ModelsDevModel): number {
+	return (
+		model.max_tokens ||
+		model.maxTokens ||
+		devModel?.limit?.output ||
+		DEFAULT_MAX_TOKENS
+	);
+}
+
+function getReasoning(model: RouterModel, devModel?: ModelsDevModel): boolean {
+	if (typeof devModel?.reasoning === "boolean") return devModel.reasoning;
+	return /reasoner|thinking|xhigh|high|max|pro|codex|opus|sonnet/i.test(
+		model.id ?? "",
+	);
+}
+
+// ── getInputTypes ────────────────────────────────────────────────────────────
+
+describe("getInputTypes", () => {
+	it("uses devModel modalities when present", () => {
+		const model: RouterModel = { id: "some-model" };
+		const dev: ModelsDevModel = {
+			id: "some-model",
+			modalities: { input: ["text", "image"] },
+		};
+		expect(getInputTypes(model, dev)).toEqual(["text", "image"]);
+	});
+
+	it("filters out non text/image modalities from devModel", () => {
+		const model: RouterModel = { id: "some-model" };
+		const dev: ModelsDevModel = {
+			id: "some-model",
+			modalities: { input: ["text", "audio"] },
+		};
+		expect(getInputTypes(model, dev)).toEqual(["text"]);
+	});
+
+	it("falls back to pattern match for claude", () => {
+		expect(getInputTypes({ id: "claude-sonnet-4-5" })).toEqual([
+			"text",
+			"image",
+		]);
+	});
+
+	it("falls back to pattern match for gpt-4o", () => {
+		expect(getInputTypes({ id: "gpt-4o" })).toEqual(["text", "image"]);
+	});
+
+	it("falls back to pattern match for kimi-k2", () => {
+		expect(getInputTypes({ id: "kimi-k2-instruct" })).toEqual([
+			"text",
+			"image",
+		]);
+	});
+
+	it("returns text-only for unknown model with no devModel", () => {
+		expect(getInputTypes({ id: "some-random-llm" })).toEqual(["text"]);
+	});
+
+	it("uses devModel over pattern when both match", () => {
+		const model: RouterModel = { id: "claude-opus-4" };
+		const dev: ModelsDevModel = {
+			id: "claude-opus-4",
+			modalities: { input: ["text"] }, // explicitly text-only despite claude pattern
+		};
+		expect(getInputTypes(model, dev)).toEqual(["text"]);
+	});
+});
+
+// ── getModelName ─────────────────────────────────────────────────────────────
+
+describe("getModelName", () => {
+	it("prefers router model.name", () => {
+		expect(
+			getModelName(
+				{ id: "x", name: "Router Name" },
+				{ id: "x", name: "Dev Name" },
+			),
+		).toBe("Router Name");
+	});
+
+	it("falls back to devModel.name", () => {
+		expect(getModelName({ id: "x" }, { id: "x", name: "Dev Name" })).toBe(
+			"Dev Name",
+		);
+	});
+
+	it("falls back to model.id", () => {
+		expect(getModelName({ id: "some-id" })).toBe("some-id");
+	});
+
+	it("returns 'unknown' when all empty", () => {
+		expect(getModelName({})).toBe("unknown");
+	});
+});
+
+// ── getContextWindow ──────────────────────────────────────────────────────────
+
+describe("getContextWindow", () => {
+	it("prefers model.context_window", () => {
+		expect(
+			getContextWindow(
+				{ id: "x", context_window: 32_000 },
+				{ id: "x", limit: { context: 100_000 } },
+			),
+		).toBe(32_000);
+	});
+
+	it("falls back to model.contextWindow", () => {
+		expect(getContextWindow({ id: "x", contextWindow: 64_000 })).toBe(64_000);
+	});
+
+	it("falls back to devModel.limit.context", () => {
+		expect(
+			getContextWindow({ id: "x" }, { id: "x", limit: { context: 200_000 } }),
+		).toBe(200_000);
+	});
+
+	it("falls back to DEFAULT_CONTEXT_WINDOW", () => {
+		expect(getContextWindow({ id: "x" })).toBe(DEFAULT_CONTEXT_WINDOW);
+	});
+});
+
+// ── getMaxTokens ──────────────────────────────────────────────────────────────
+
+describe("getMaxTokens", () => {
+	it("prefers model.max_tokens", () => {
+		expect(
+			getMaxTokens(
+				{ id: "x", max_tokens: 4_096 },
+				{ id: "x", limit: { output: 32_000 } },
+			),
+		).toBe(4_096);
+	});
+
+	it("falls back to model.maxTokens", () => {
+		expect(getMaxTokens({ id: "x", maxTokens: 8_192 })).toBe(8_192);
+	});
+
+	it("falls back to devModel.limit.output", () => {
+		expect(
+			getMaxTokens({ id: "x" }, { id: "x", limit: { output: 16_000 } }),
+		).toBe(16_000);
+	});
+
+	it("falls back to DEFAULT_MAX_TOKENS", () => {
+		expect(getMaxTokens({ id: "x" })).toBe(DEFAULT_MAX_TOKENS);
+	});
+});
+
+// ── getReasoning ──────────────────────────────────────────────────────────────
+
+describe("getReasoning", () => {
+	it("uses devModel.reasoning when boolean true", () => {
+		expect(getReasoning({ id: "x" }, { id: "x", reasoning: true })).toBe(true);
+	});
+
+	it("uses devModel.reasoning when boolean false", () => {
+		// even if pattern would match, devModel wins
+		expect(
+			getReasoning(
+				{ id: "claude-opus-4" },
+				{ id: "claude-opus-4", reasoning: false },
+			),
+		).toBe(false);
+	});
+
+	it("falls back to pattern — opus", () => {
+		expect(getReasoning({ id: "claude-opus-4" })).toBe(true);
+	});
+
+	it("falls back to pattern — sonnet", () => {
+		expect(getReasoning({ id: "claude-sonnet-4-5" })).toBe(true);
+	});
+
+	it("falls back to pattern — thinking", () => {
+		expect(getReasoning({ id: "deepseek-thinking" })).toBe(true);
+	});
+
+	it("falls back to pattern — reasoner", () => {
+		expect(getReasoning({ id: "o1-reasoner" })).toBe(true);
+	});
+
+	it("returns false for plain model with no devModel", () => {
+		expect(getReasoning({ id: "llama-3-8b-instruct" })).toBe(false);
+	});
+});

package/src/provider.ts

@@ -0,0 +1,133 @@
+/**
+ * provider.ts — 9Router model provider
+ *
+ * Registers the "9router" provider in Pi, pulling live model list from the
+ * router API. Falls back to an empty model list if ROUTER_API_KEY is unset.
+ *
+ * Environment:
+ *   ROUTER_API_BASE  — override API base URL (default: https://9r.xynogen.xyz/v1)
+ *   ROUTER_API_KEY   — bearer token (required for live model list)
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	fetchModelsDevIndex,
+	lookupInIndex,
+	routerBaseUrl,
+	routerModels,
+} from "./data.js";
+import type { ModelsDevModel, RouterModel } from "./data.js";
+
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+
+const ZERO_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+};
+
+// Fallback pattern-based detection if models.dev lookup fails
+const IMAGE_CAPABLE_PATTERNS = [
+	/claude/i,
+	/gpt-5/i,
+	/gpt-4/i,
+	/kimi-k2/i,
+	/hy3/i,
+];
+
+function getInputTypes(
+	model: RouterModel,
+	devModel?: ModelsDevModel,
+): ("text" | "image")[] {
+	if (devModel?.modalities?.input) {
+		const inputs = devModel.modalities.input.filter(
+			(i): i is "text" | "image" => i === "text" || i === "image",
+		);
+		if (inputs.length > 0) return inputs;
+	}
+	const id = model.id ?? "";
+	if (IMAGE_CAPABLE_PATTERNS.some((p) => p.test(id))) return ["text", "image"];
+	return ["text"];
+}
+
+function getModelName(model: RouterModel, devModel?: ModelsDevModel): string {
+	return model.name || devModel?.name || model.id || "unknown";
+}
+
+function getContextWindow(
+	model: RouterModel,
+	devModel?: ModelsDevModel,
+): number {
+	return (
+		model.context_window ||
+		model.contextWindow ||
+		devModel?.limit?.context ||
+		DEFAULT_CONTEXT_WINDOW
+	);
+}
+
+function getMaxTokens(model: RouterModel, devModel?: ModelsDevModel): number {
+	return (
+		model.max_tokens ||
+		model.maxTokens ||
+		devModel?.limit?.output ||
+		DEFAULT_MAX_TOKENS
+	);
+}
+
+function getReasoning(model: RouterModel, devModel?: ModelsDevModel): boolean {
+	if (typeof devModel?.reasoning === "boolean") return devModel.reasoning;
+	return /reasoner|thinking|xhigh|high|max|pro|codex|opus|sonnet/i.test(
+		model.id ?? "",
+	);
+}
+
+export default async function registerProvider(
+	pi: ExtensionAPI,
+): Promise<void> {
+	const apiKey = process.env.ROUTER_API_KEY;
+
+	if (!apiKey) {
+		// Register shell provider so the name is known; no models available yet.
+		pi.registerProvider("9router", {
+			name: "9Router",
+			baseUrl: routerBaseUrl(),
+			apiKey: "$ROUTER_API_KEY",
+			api: "openai-completions",
+			models: [],
+		});
+		return;
+	}
+
+	const [models, devIndex] = await Promise.all([
+		routerModels.get(),
+		fetchModelsDevIndex().catch(() => new Map<string, ModelsDevModel>()),
+	]);
+
+	pi.registerProvider("9router", {
+		name: "9Router",
+		baseUrl: routerBaseUrl(),
+		apiKey: "$ROUTER_API_KEY",
+		api: "openai-completions",
+		headers: { "User-Agent": "pi-coding-agent" },
+		compat: {
+			supportsDeveloperRole: false,
+			supportsUsageInStreaming: false,
+			maxTokensField: "max_tokens",
+		},
+		models: models.map((model) => {
+			const devModel = lookupInIndex(model.id!, devIndex);
+			return {
+				id: model.id!,
+				name: getModelName(model, devModel),
+				reasoning: getReasoning(model, devModel),
+				input: getInputTypes(model, devModel),
+				cost: ZERO_COST,
+				contextWindow: getContextWindow(model, devModel),
+				maxTokens: getMaxTokens(model, devModel),
+			};
+		}),
+	});
+}

package/src/search.ts

@@ -0,0 +1,208 @@
+/**
+ * search.ts — search tool via 9Router API, with curl fallback.
+ *
+ * Environment:
+ *   ROUTER_API_BASE  — router API base URL (default: https://9r.xynogen.xyz/v1)
+ *   ROUTER_API_KEY   — bearer token for the router
+ */
+
+import { execFile } from "node:child_process";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { StringEnum } from "@earendil-works/pi-ai";
+import { routerBaseUrl } from "./data.js";
+
+const REQUEST_TIMEOUT_MS = 30_000;
+
+function auth(): string | undefined {
+	return process.env.ROUTER_API_KEY;
+}
+
+async function apiPost(
+	path: string,
+	body: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<string> {
+	const url = `${routerBaseUrl()}${path}`;
+	const key = auth();
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+	const s = signal
+		? AbortSignal.any([signal, controller.signal])
+		: controller.signal;
+
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...(key ? { Authorization: `Bearer ${key}` } : {}),
+			},
+			body: JSON.stringify(body),
+			signal: s,
+		});
+		if (!res.ok) {
+			const errText = await res.text().catch(() => "");
+			throw new Error(`API ${res.status}: ${errText.slice(0, 500)}`);
+		}
+		return await res.text();
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+function curl(args: string[], stdin?: string): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const child = execFile(
+			"curl",
+			["-sS", "--connect-timeout", "10", "--max-time", "25", ...args],
+			{ maxBuffer: 10 * 1024 * 1024, timeout: 30_000 },
+			(err, stdout, stderr) => {
+				if (err) {
+					const msg = (err as NodeJS.ErrnoException).killed
+						? "curl timed out"
+						: `curl exit ${(err as NodeJS.ErrnoException).code ?? "??"}: ${stderr.slice(0, 300)}`;
+					reject(new Error(msg));
+					return;
+				}
+				resolve(stdout);
+			},
+		);
+		if (stdin && child.stdin) {
+			child.stdin.write(stdin);
+			child.stdin.end();
+		}
+	});
+}
+
+export default function registerSearch(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "search",
+		label: "Search",
+		description:
+			"Web or news search via exa. Returns title, url, and snippet for each result.",
+		promptSnippet:
+			"search(query, search_type, max_results?) — search_type: 'web' or 'news'. Defaults to 5 results, max 10.",
+		promptGuidelines: [
+			"Use search when you need up-to-date information or facts from the web.",
+			"Set search_type='web' for general web results, search_type='news' for recent news articles.",
+			"Always prefer search over raw curl/browser requests for information lookup.",
+		],
+		parameters: Type.Object({
+			query: Type.String({ description: "Search query" }),
+			search_type: StringEnum(["web", "news"] as const, {
+				description: "web or news search",
+			}),
+			max_results: Type.Optional(
+				Type.Number({
+					description: "Max results (default 5, max 10)",
+					default: 5,
+				}),
+			),
+		}),
+
+		async execute(_toolCallId, params, signal, onUpdate) {
+			const max = Math.min(params.max_results ?? 5, 10);
+			const searchType = params.search_type ?? "web";
+			let apiMsg = "";
+
+			try {
+				onUpdate?.({
+					content: [
+						{
+							type: "text",
+							text: `Searching (${searchType}): ${params.query}...`,
+						},
+					],
+				});
+
+				const raw = await apiPost(
+					"/search",
+					{
+						model: "exa",
+						query: params.query,
+						search_type: searchType,
+						max_results: max,
+					},
+					signal,
+				);
+
+				let parsed: unknown;
+				try {
+					parsed = JSON.parse(raw);
+				} catch {
+					parsed = raw;
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify(parsed, null, 2).slice(0, 20_000),
+						},
+					],
+					details: { source: "api" },
+				};
+			} catch (apiErr: unknown) {
+				apiMsg = apiErr instanceof Error ? apiErr.message : String(apiErr);
+				onUpdate?.({
+					content: [
+						{
+							type: "text",
+							text: `API failed: ${apiMsg}\nFalling back to curl...`,
+						},
+					],
+				});
+			}
+
+			try {
+				const body = JSON.stringify({
+					model: "exa",
+					query: params.query,
+					search_type: searchType,
+					max_results: max,
+				});
+				const raw = await curl([
+					"-X",
+					"POST",
+					"-H",
+					"Content-Type: application/json",
+					...(auth() ? ["-H", `Authorization: Bearer ${auth()}`] : []),
+					"-d",
+					body,
+					`${routerBaseUrl()}/search`,
+				]);
+
+				let parsed: unknown;
+				try {
+					parsed = JSON.parse(raw);
+				} catch {
+					parsed = raw;
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: `[FALLBACK — curl] API called via curl instead of fetch.\n\n${JSON.stringify(parsed, null, 2).slice(0, 19_500)}`,
+						},
+					],
+					details: { source: "curl-fallback" },
+				};
+			} catch (curlErr: unknown) {
+				const curlMsg =
+					curlErr instanceof Error ? curlErr.message : String(curlErr);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Search failed (both API and curl).\nAPI: ${apiMsg}\nCurl: ${curlMsg}`,
+						},
+					],
+					details: { source: "failed" },
+					isError: true,
+				};
+			}
+		},
+	});
+}