@haoyiyin/9router 0.1.0

package/src/provider.ts

@@ -0,0 +1,158 @@
+/**
+ * provider.ts — 9Router model provider
+ *
+ * Registers the "9router" provider in Pi, pulling the live router model list
+ * plus OpenCode's free oc/-free models. Falls back to an empty model list if
+ * the API key is unset (so the /9router command can re-register after config
+ * is saved).
+ *
+ * Config (base URL + key, with env fallback) is owned by ./config.ts.
+ */
+
+import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import type { ModelsDevModel, RouterModel } from "./data.ts";
+import { fetchModelsDevIndex, lookupInIndex, routerBaseUrl, routerModels } from "./data.ts";
+import { getZenFreeModels } from "./zen.ts";
+import { loadConfig } from "./config.ts";
+
+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];
+
+export 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"];
+}
+
+export function getModelName(model: RouterModel, devModel?: ModelsDevModel): string {
+	return model.name || devModel?.name || model.id || "unknown";
+}
+
+export function getContextWindow(model: RouterModel, devModel?: ModelsDevModel): number {
+	return (
+		model.context_window ||
+		model.contextWindow ||
+		model.capabilities?.contextWindow ||
+		devModel?.limit?.context ||
+		DEFAULT_CONTEXT_WINDOW
+	);
+}
+
+export function getMaxTokens(model: RouterModel, devModel?: ModelsDevModel): number {
+	return (
+		model.max_tokens ||
+		model.maxTokens ||
+		model.capabilities?.maxOutput ||
+		devModel?.limit?.output ||
+		DEFAULT_MAX_TOKENS
+	);
+}
+
+export 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 async function registerProvider(pi: ExtensionAPI): Promise<void> {
+	const cfg = loadConfig();
+
+	if (!cfg.apiKey) {
+		// Register shell provider so the name is known; no models available yet.
+		pi.registerProvider("9router", {
+			name: "9Router",
+			baseUrl: cfg.baseUrl,
+			apiKey: "",
+			api: "openai-completions",
+			models: [],
+		});
+		return;
+	}
+
+	const [models, devIndex, zenIds] = await Promise.all([
+		routerModels.get(),
+		fetchModelsDevIndex().catch(() => new Map<string, ModelsDevModel>()),
+		getZenFreeModels(),
+	]);
+
+	// Upstream moved OpenAI `compat` settings from the provider level to the
+	// per-model level (ProviderModelConfig.compat). Apply the same shim to every
+	// registered model.
+	const COMPAT = {
+		supportsDeveloperRole: false,
+		supportsUsageInStreaming: false,
+		maxTokensField: "max_tokens",
+	} as const;
+
+	const seen = new Set<string>();
+	const out: ProviderModelConfig[] = [];
+
+	// Router models (live list), mapped the same as the original registration.
+	for (const model of models) {
+		const id = model.id ?? "";
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		const devModel = lookupInIndex(id, devIndex);
+		out.push({
+			id,
+			name: getModelName(model, devModel),
+			reasoning: getReasoning(model, devModel),
+			input: getInputTypes(model, devModel),
+			cost: ZERO_COST,
+			contextWindow: getContextWindow(model, devModel),
+			maxTokens: getMaxTokens(model, devModel),
+			compat: COMPAT,
+		});
+	}
+
+	// OpenCode free models (zen) — bare ids, no auth needed.
+	// ponytail: zen returns bare ids (e.g. "deepseek-v4-flash-free") with no
+	// metadata, so the contextWindow/maxTokens defaults below are guesses.
+	// Upgrade when zen ships model detail.
+	for (const id of zenIds) {
+		const ocId = `oc/${id}`;
+		if (seen.has(ocId)) continue;
+		seen.add(ocId);
+		out.push({
+			id: ocId,
+			name: id,
+			reasoning: /reasoner|thinking|xhigh|high|max|pro|codex|opus|sonnet|fable|terra/i.test(id),
+			input: /claude|gpt-|grok|gemini|kimi|glm|qwen|minimax|mimo/i.test(id)
+				? ["text", "image"]
+				: ["text"],
+			cost: ZERO_COST,
+			contextWindow: 200_000,
+			maxTokens: 32_000,
+			compat: COMPAT,
+		});
+	}
+
+	if (typeof (pi as { unregisterProvider?: unknown }).unregisterProvider === "function") {
+		pi.unregisterProvider("9router");
+	}
+	pi.registerProvider("9router", {
+		name: "9Router",
+		baseUrl: cfg.baseUrl,
+		apiKey: cfg.apiKey,
+		api: "openai-completions",
+		headers: { "User-Agent": "pi-coding-agent" },
+		models: out,
+	});
+}
+
+export default registerProvider;

package/src/render.ts

@@ -0,0 +1,147 @@
+/**
+ * render.ts — shared dim renderers for fetch/search tool output.
+ *
+ * fetch/search return external web content the model already consumed; the
+ * full body is noise in the transcript. We render it dim (theme `dim` token)
+ * so it reads like faded reasoning — present for inspection, visually quiet.
+ * The tool title line stays normal so calls remain scannable.
+ *
+ * pi-tui's Text component is loaded via require() so the renderers degrade to
+ * the default pi renderer (undefined-safe via cast) when pi-tui is absent.
+ */
+
+import type {
+	AgentToolResult,
+	Theme,
+	ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import {
+	type CollapsedToolStatus,
+	formatCollapsedToolRow,
+	hideCollapsedToolCall,
+} from "@xynogen/pix-pretty/utils";
+import { type CollapseState, tickCollapse } from "@xynogen/pix-runtime/collapse";
+
+interface TextLike extends Component {
+	setText(text: string): void;
+}
+
+// ToolRenderContext is not re-exported by pi-coding-agent; model the fields the
+// renderers actually read. Structurally compatible with the SDK context.
+interface RenderCtx {
+	lastComponent: Component | undefined;
+	isError: boolean;
+	state: Record<string, unknown>;
+	expanded: boolean;
+	invalidate: () => void;
+}
+
+interface CompactRendererConfig<TDetails> {
+	tool: string;
+	target: (details: TDetails) => string;
+	meta: (details: TDetails) => string;
+	status?: (details: TDetails) => CollapsedToolStatus;
+}
+
+type TextCtor = new (text?: string, padX?: number, padY?: number) => TextLike;
+
+// Preview cap is intentionally generous — dimming already de-emphasises the
+// body, so we only truncate to keep pathological multi-thousand-line dumps
+// from flooding the viewport. Expanding shows everything.
+const MAX_PREVIEW_LINES = 32;
+
+let TextComponent: TextCtor | undefined;
+try {
+	TextComponent = (require("@earendil-works/pi-tui") as { Text: TextCtor }).Text;
+} catch {
+	TextComponent = undefined;
+}
+
+function getText(lastComponent: Component | undefined): TextLike {
+	if (lastComponent && "setText" in lastComponent) return lastComponent as TextLike;
+	// TextComponent is always present in the interactive TUI (pi-tui peer); the
+	// require() guard only matters for headless/test contexts where renderers
+	// are never invoked.
+	if (TextComponent) return new TextComponent("", 0, 0);
+	throw new Error("pi-tui Text component unavailable");
+}
+
+function allText(result: AgentToolResult<unknown>): string {
+	return (result.content ?? [])
+		.filter((block): block is { type: "text"; text: string } => block.type === "text")
+		.map((block) => block.text)
+		.join("\n");
+}
+
+function dimBody(body: string, theme: Theme, expanded: boolean): string {
+	const lines = body.split("\n");
+	const maxShow = expanded ? lines.length : MAX_PREVIEW_LINES;
+	const shown = lines.slice(0, maxShow);
+	const out = shown.map((line) => `  ${theme.fg("dim", line)}`);
+	const remaining = lines.length - maxShow;
+	if (remaining > 0) {
+		out.push(`  ${theme.fg("dim", `… ${remaining} more lines`)}`);
+	}
+	return out.join("\n");
+}
+
+/** Build a `renderCall` that shows `<title> <accent arg>`. */
+export function makeRenderCall<TArgs>(title: string, pickArg: (args: TArgs) => string) {
+	return (args: TArgs, theme: Theme, ctx: RenderCtx): Component => {
+		const text = getText(ctx.lastComponent);
+		if (
+			hideCollapsedToolCall(ctx.state as CollapseState, ctx.expanded, (value) =>
+				text.setText(value),
+			)
+		)
+			return text;
+		const arg = pickArg(args);
+		text.setText(`${theme.fg("toolTitle", theme.bold(title))} ${theme.fg("muted", arg)}`);
+		return text;
+	};
+}
+
+/** Build a `renderResult` with a bounded detail preview and optional compact terminal row. */
+export function makeRenderResult<TDetails>(config?: CompactRendererConfig<TDetails>) {
+	return (
+		result: AgentToolResult<unknown>,
+		opts: ToolRenderResultOptions,
+		theme: Theme,
+		ctx: RenderCtx,
+	): Component => {
+		const text = getText(ctx.lastComponent);
+		const body = allText(result);
+
+		if (ctx.isError) {
+			text.setText(`  ${theme.fg("error", body || "Error")}`);
+			return text;
+		}
+		if (!body.trim()) {
+			text.setText(`  ${theme.fg("dim", "(empty)")}`);
+			return text;
+		}
+
+		const details = result.details as TDetails | undefined;
+		if (
+			!opts.isPartial &&
+			config &&
+			details &&
+			tickCollapse(config.tool, ctx.state as CollapseState, ctx.invalidate, opts.expanded)
+		) {
+			text.setText(
+				formatCollapsedToolRow(
+					theme,
+					config.tool,
+					config.target(details),
+					config.meta(details),
+					config.status?.(details) ?? "success",
+				),
+			);
+			return text;
+		}
+
+		text.setText(dimBody(body, theme, opts.expanded));
+		return text;
+	};
+}

package/src/search.ts

@@ -0,0 +1,283 @@
+/**
+ * search.ts — search tool via 9Router API, with curl fallback.
+ *
+ * Environment:
+ *   ROUTER_API_BASE  — router API base URL (default: https://9router.example.com/v1)
+ *   ROUTER_API_KEY   — bearer token for the router
+ */
+
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { routerBaseUrl } from "./data.ts";
+import { apiPost, auth, curl, isCancelled } from "./http.ts";
+import { makeRenderCall, makeRenderResult } from "./render.ts";
+
+type RouterOutcome = "running" | "fallback" | "success" | "cancelled" | "error";
+type SearchType = "web" | "news";
+
+export interface SearchResultDetails {
+	_type: "searchResult";
+	outcome: RouterOutcome;
+	query: string;
+	searchType: SearchType;
+	source?: "api" | "curl-fallback" | "failed";
+	resultCount?: number;
+}
+
+export interface SearchParams {
+	query: string;
+	search_type?: SearchType;
+	max_results?: number;
+}
+
+interface SearchResult {
+	content: { type: "text"; text: string }[];
+	details: SearchResultDetails;
+	isError?: boolean;
+}
+
+interface SearchDependencies {
+	apiPost: typeof apiPost;
+	curl: typeof curl;
+}
+
+interface SearchResultItem {
+	title?: string | null;
+	url?: string | null;
+	snippet?: string | null;
+	published_at?: string | null;
+	metadata?: { author?: string | null } | null;
+	author?: string | null;
+}
+
+/** Parse and format a raw exa search response with its authoritative result count. */
+export function parseSearchResults(raw: string): { text: string; count: number } {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return { text: raw.slice(0, 20_000), count: 0 };
+	}
+
+	const obj = parsed as Record<string, unknown>;
+	const results = obj?.results;
+	if (!Array.isArray(results)) {
+		return { text: JSON.stringify(parsed, null, 2).slice(0, 20_000), count: 0 };
+	}
+
+	if (results.length === 0) return { text: "No results.", count: 0 };
+
+	const lines: string[] = [];
+	results.forEach((r: SearchResultItem, i: number) => {
+		const title = (r.title ?? "").trim() || r.url || "(untitled)";
+		lines.push(`${i + 1}. ${title}`);
+		if (r.url) lines.push(`   ${r.url}`);
+		const meta: string[] = [];
+		const author = r.author ?? r.metadata?.author;
+		if (author) meta.push(author);
+		if (r.published_at) meta.push(r.published_at.slice(0, 10));
+		if (meta.length > 0) lines.push(`   (${meta.join(" — ")})`);
+		const snippet = (r.snippet ?? "").trim();
+		if (snippet) lines.push(`   ${snippet.replace(/\s+/g, " ").slice(0, 300)}`);
+		lines.push("");
+	});
+
+	return {
+		text: lines.join("\n").trim().slice(0, 20_000),
+		count: results.length,
+	};
+}
+
+/** Format a raw exa search response as a compact markdown list. */
+export function formatSearchResults(raw: string): string {
+	return parseSearchResults(raw).text;
+}
+
+export async function executeSearch(
+	params: SearchParams,
+	signal?: AbortSignal,
+	onUpdate?: (result: SearchResult) => void,
+	dependencies: SearchDependencies = { apiPost, curl },
+): Promise<SearchResult> {
+	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}...` }],
+			details: {
+				_type: "searchResult",
+				outcome: "running",
+				query: params.query,
+				searchType,
+			},
+		});
+
+		const raw = await dependencies.apiPost(
+			"/search",
+			{
+				model: "exa",
+				query: params.query,
+				search_type: searchType,
+				max_results: max,
+			},
+			signal,
+		);
+		const parsed = parseSearchResults(raw);
+
+		return {
+			content: [{ type: "text", text: parsed.text }],
+			details: {
+				_type: "searchResult",
+				outcome: "success",
+				query: params.query,
+				searchType,
+				source: "api",
+				resultCount: parsed.count,
+			},
+		};
+	} catch (apiErr: unknown) {
+		apiMsg = apiErr instanceof Error ? apiErr.message : String(apiErr);
+		if (isCancelled(apiErr, signal)) {
+			return {
+				content: [{ type: "text", text: `Search cancelled.\nAPI: ${apiMsg}` }],
+				details: {
+					_type: "searchResult",
+					outcome: "cancelled",
+					query: params.query,
+					searchType,
+				},
+			};
+		}
+		onUpdate?.({
+			content: [
+				{
+					type: "text",
+					text: `API failed: ${apiMsg}\nFalling back to curl...`,
+				},
+			],
+			details: {
+				_type: "searchResult",
+				outcome: "running",
+				query: params.query,
+				searchType,
+			},
+		});
+	}
+
+	try {
+		const body = JSON.stringify({
+			model: "exa",
+			query: params.query,
+			search_type: searchType,
+			max_results: max,
+		});
+		const raw = await dependencies.curl([
+			"-X",
+			"POST",
+			"-H",
+			"Content-Type: application/json",
+			...(auth() ? ["-H", `Authorization: Bearer ${auth()}`] : []),
+			"-d",
+			body,
+			`${routerBaseUrl()}/search`,
+		]);
+		const parsed = parseSearchResults(raw);
+
+		return {
+			content: [
+				{
+					type: "text",
+					text: `[FALLBACK — curl] API called via curl instead of fetch.\n\n${parsed.text.slice(0, 19_500)}`,
+				},
+			],
+			details: {
+				_type: "searchResult",
+				outcome: "fallback",
+				query: params.query,
+				searchType,
+				source: "curl-fallback",
+				resultCount: parsed.count,
+			},
+		};
+	} 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: {
+				_type: "searchResult",
+				outcome: "error",
+				query: params.query,
+				searchType,
+				source: "failed",
+			},
+			isError: true,
+		};
+	}
+}
+
+export default function registerSearch(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "search",
+		label: "Search",
+		renderShell: "self",
+		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.",
+		],
+		renderCall: makeRenderCall<unknown>("search", (args) =>
+			String((args as Partial<SearchParams>).query ?? ""),
+		),
+		renderResult: (
+			(renderTerminal) => (result, options, theme, context) =>
+				renderTerminal(result, options, theme, {
+					...context,
+					isError: context.isError && options.expanded,
+				})
+		)(
+			makeRenderResult<SearchResultDetails>({
+				tool: "search",
+				target: (details) => `“${details.query}”`,
+				meta: (details) => {
+					if (details.outcome === "error") return "failed";
+					if (details.outcome === "cancelled") return "cancelled";
+					const count = details.resultCount ?? 0;
+					return `${count} ${count === 1 ? "result" : "results"} · ${details.searchType}`;
+				},
+				status: (details) =>
+					details.outcome === "error"
+						? "error"
+						: details.outcome === "fallback" || details.outcome === "cancelled"
+							? "warning"
+							: "success",
+			}),
+		),
+		parameters: Type.Object({
+			query: Type.String({ description: "Search query" }),
+			search_type: StringEnum(["web", "news"] as const, {
+				description:
+					'Required choice. Enter exactly "web" for general web results or "news" for recent news articles.',
+			}),
+			max_results: Type.Optional(
+				Type.Number({
+					description: "Max results (default 5, max 10)",
+					default: 5,
+				}),
+			),
+		}),
+
+		async execute(_toolCallId, params, signal, onUpdate) {
+			return executeSearch(params as SearchParams, signal, onUpdate);
+		},
+	});
+}