@xynogen/pix-9router 0.4.3 → 0.4.4

package/src/provider.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { ModelsDevModel, RouterModel } from "./data.ts";
-import {
-	getContextWindow,
-	getInputTypes,
-	getMaxTokens,
-	getModelName,
-	getReasoning,
-} from "./provider.ts";
-
-// ── 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 capabilities.contextWindow (9router v1 nested shape)", () => {
-		expect(getContextWindow({ id: "x", capabilities: { contextWindow: 1_000_000 } })).toBe(
-			1_000_000,
-		);
-	});
-
-	it("top-level fields beat capabilities.contextWindow", () => {
-		expect(
-			getContextWindow({
-				id: "x",
-				contextWindow: 64_000,
-				capabilities: { contextWindow: 1_000_000 },
-			}),
-		).toBe(64_000);
-	});
-
-	it("capabilities.contextWindow beats devModel.limit.context", () => {
-		expect(
-			getContextWindow(
-				{ id: "x", capabilities: { contextWindow: 1_000_000 } },
-				{ id: "x", limit: { context: 200_000 } },
-			),
-		).toBe(1_000_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(128_000);
-	});
-});
-
-// ── 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 capabilities.maxOutput (9router v1 nested shape)", () => {
-		expect(getMaxTokens({ id: "x", capabilities: { maxOutput: 64_000 } })).toBe(64_000);
-	});
-
-	it("top-level fields beat capabilities.maxOutput", () => {
-		expect(getMaxTokens({ id: "x", maxTokens: 8_192, capabilities: { maxOutput: 64_000 } })).toBe(
-			8_192,
-		);
-	});
-
-	it("capabilities.maxOutput beats devModel.limit.output", () => {
-		expect(
-			getMaxTokens(
-				{ id: "x", capabilities: { maxOutput: 64_000 } },
-				{ id: "x", limit: { output: 16_000 } },
-			),
-		).toBe(64_000);
-	});
-
-	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(16_384);
-	});
-
-	it("handles the PR #9 regression case (qwen3-coder-flash nested capabilities)", () => {
-		const model: RouterModel = {
-			id: "alims-intl/qwen3-coder-flash-2025-07-28",
-			capabilities: { contextWindow: 1_000_000, maxOutput: 64_000 },
-		};
-		expect(getContextWindow(model)).toBe(1_000_000);
-		expect(getMaxTokens(model)).toBe(64_000);
-	});
-});
-
-// ── 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/render.test.ts

@@ -1,218 +0,0 @@
-import { expect, test } from "bun:test";
-import { COLLAPSED_TOOL_GLYPH } from "@xynogen/pix-pretty/utils";
-import { makeRenderCall, makeRenderResult } from "./render.js";
-
-const theme = {
-	fg: (t: string, s: string) => `[${t}]${s}`,
-	bold: (s: string) => `*${s}*`,
-} as never;
-
-function stubComponent() {
-	let captured = "";
-	const component = {
-		setText: (s: string) => {
-			captured = s;
-		},
-		render: (_width?: number) => captured.split("\n"),
-		invalidate: () => {},
-	};
-	return { component, get: () => captured };
-}
-
-function context(stub: ReturnType<typeof stubComponent>, overrides: Record<string, unknown> = {}) {
-	return {
-		lastComponent: stub.component as never,
-		isError: false,
-		state: {},
-		expanded: false,
-		invalidate: () => {},
-		...overrides,
-	} as never;
-}
-
-const config = {
-	tool: "fetch",
-	target: (_details: { _type: "fetchResult"; chars: number }) => "https://example.com",
-	meta: (details: { _type: "fetchResult"; chars: number }) => `${details.chars} chars`,
-};
-
-test("renderCall shows title + dim arg", () => {
-	const stub = stubComponent();
-	const rc = makeRenderCall<{ url: string }>("fetch", (a) => a.url);
-	rc({ url: "https://x.com" }, theme, context(stub));
-	// Only the tool name is accent/toolTitle-colored; the arg is secondary.
-	expect(stub.get()).toBe("[toolTitle]*fetch* [dim]https://x.com");
-});
-
-test("renderCall hides only an effectively collapsed call row", () => {
-	const stub = stubComponent();
-	const rc = makeRenderCall<{ url: string }>("fetch", (a) => a.url);
-	rc({ url: "https://x.com" }, theme, context(stub, { state: { collapsed: true } }));
-	expect(stub.get()).toBe("");
-
-	rc(
-		{ url: "https://x.com" },
-		theme,
-		context(stub, { state: { collapsed: true }, expanded: true }),
-	);
-	expect(stub.get()).toBe("[toolTitle]*fetch* [dim]https://x.com");
-});
-
-test("renderResult renders structured compact details after collapse", () => {
-	const stub = stubComponent();
-	const rr = makeRenderResult(config);
-	rr(
-		{
-			content: [{ type: "text", text: "full body" }],
-			details: { _type: "fetchResult", chars: 9 },
-		} as never,
-		{ expanded: false, isPartial: false },
-		theme,
-		context(stub, { state: { collapsed: true } }),
-	);
-	expect(stub.get()).toContain("[success]✓");
-	expect(stub.get()).toContain("https://example.com");
-	expect(stub.get()).toContain("9 chars");
-});
-
-test("partial updates keep detail visible and do not schedule collapse", () => {
-	const stub = stubComponent();
-	const state: Record<string, unknown> = {};
-	const rr = makeRenderResult(config);
-	rr(
-		{
-			content: [{ type: "text", text: "streaming body" }],
-			details: { _type: "fetchResult", chars: 14 },
-		} as never,
-		{ expanded: false, isPartial: true },
-		theme,
-		context(stub, { state }),
-	);
-	expect(stub.get()).toContain("streaming body");
-	expect(stub.component.render(20)).toEqual(["  [dim]streaming body"]);
-	expect(state.timer).toBeUndefined();
-});
-
-test("expanded mode restores full joined text", () => {
-	const stub = stubComponent();
-	const rr = makeRenderResult(config);
-	const component = rr(
-		{
-			content: [
-				{ type: "text", text: "first" },
-				{ type: "image", data: "ignored", mimeType: "image/png" },
-				{ type: "text", text: "second" },
-			],
-			details: { _type: "fetchResult", chars: 12 },
-		} as never,
-		{ expanded: true, isPartial: false },
-		theme,
-		context(stub, { state: { collapsed: true }, expanded: true }),
-	);
-	expect(stub.get()).toBe("  [dim]first\n  [dim]second");
-	expect(component.render(20)).toEqual([
-		"[success]────────────────────",
-		"  [dim]first",
-		"  [dim]second",
-		"[success]────────────────────",
-	]);
-});
-
-test("structured errors get red open frames but collapsed summaries stay unframed", () => {
-	const rr = makeRenderResult({ ...config, status: () => "error" as const });
-	const open = stubComponent();
-	const openComponent = rr(
-		{
-			content: [{ type: "text", text: "failed body" }],
-			details: { _type: "fetchResult", chars: 11 },
-		} as never,
-		{ expanded: false, isPartial: false },
-		theme,
-		context(open),
-	);
-	expect(openComponent.render(20)[0]).toBe("[error]────────────────────");
-
-	const collapsed = stubComponent();
-	const collapsedComponent = rr(
-		{
-			content: [{ type: "text", text: "failed body" }],
-			details: { _type: "fetchResult", chars: 11 },
-		} as never,
-		{ expanded: false, isPartial: false },
-		theme,
-		context(collapsed, { state: { collapsed: true } }),
-	);
-	expect(collapsedComponent.render(20).join("\n")).not.toContain("────");
-});
-
-test("terminal error body gets an error frame", () => {
-	const stub = stubComponent();
-	const component = makeRenderResult(config)(
-		{ content: [{ type: "text", text: "boom" }] } as never,
-		{ expanded: true, isPartial: false },
-		theme,
-		context(stub, { isError: true, expanded: true }),
-	);
-	expect(component.render(20)).toEqual([
-		"[error]────────────────────",
-		"  [error]boom",
-		"[error]────────────────────",
-	]);
-});
-
-test("renderResult caps the normal preview", () => {
-	const stub = stubComponent();
-	const rr = makeRenderResult(config);
-	const body = Array.from({ length: 37 }, (_, i) => `L${i}`).join("\n");
-	rr(
-		{
-			content: [{ type: "text", text: body }],
-			details: { _type: "fetchResult", chars: body.length },
-		} as never,
-		{ expanded: false, isPartial: false },
-		theme,
-		context(stub, { state: { timer: 1 } }),
-	);
-	expect(stub.get()).toContain("… 5 more lines");
-});
-
-test("warning and error callbacks select shared status glyphs", () => {
-	for (const [status, glyph] of [
-		["warning", COLLAPSED_TOOL_GLYPH.warning],
-		["error", COLLAPSED_TOOL_GLYPH.error],
-	] as const) {
-		const stub = stubComponent();
-		const rr = makeRenderResult({ ...config, status: () => status });
-		rr(
-			{
-				content: [{ type: "text", text: "body" }],
-				details: { _type: "fetchResult", chars: 4 },
-			} as never,
-			{ expanded: false, isPartial: false },
-			theme,
-			context(stub, { state: { collapsed: true } }),
-		);
-		expect(stub.get()).toContain(`[${status}]${glyph}`);
-	}
-});
-
-test("renderResult renders empty and errors without compacting", () => {
-	const rr = makeRenderResult(config);
-	const empty = stubComponent();
-	rr(
-		{ content: [{ type: "text", text: "   " }] } as never,
-		{ expanded: false, isPartial: false },
-		theme,
-		context(empty),
-	);
-	expect(empty.get()).toBe("  [muted](empty)");
-
-	const failed = stubComponent();
-	rr(
-		{ content: [{ type: "text", text: "boom" }] } as never,
-		{ expanded: false, isPartial: false },
-		theme,
-		context(failed, { isError: true, state: { collapsed: true } }),
-	);
-	expect(failed.get()).toBe("  [error]boom");
-});

package/src/tool-schema.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import registerFetch from "./fetch.ts";
-import registerSearch from "./search.ts";
-
-function captureParameters(register: (pi: never) => void): {
-	properties: Record<string, { type?: string; enum?: string[]; description?: string }>;
-	required?: string[];
-} {
-	let parameters: unknown;
-	register({
-		registerTool(tool: { parameters: unknown }) {
-			parameters = tool.parameters;
-		},
-	} as never);
-	if (!parameters) throw new Error("tool parameters not captured");
-	return parameters as {
-		properties: Record<string, { type?: string; enum?: string[]; description?: string }>;
-		required?: string[];
-	};
-}
-
-describe("enum-like tool parameters", () => {
-	test("search_type exposes values and their semantics", () => {
-		const searchType = captureParameters(registerSearch).properties.search_type;
-		if (!searchType) throw new Error("search_type schema not found");
-
-		expect(searchType.type).toBe("string");
-		expect(searchType.enum).toEqual(["web", "news"]);
-		expect(searchType.description).toContain('exactly "web"');
-		expect(searchType.description).toContain('"news"');
-	});
-
-	test("fetch format exposes values and their semantics", () => {
-		const format = captureParameters(registerFetch).properties.format;
-		if (!format) throw new Error("format schema not found");
-
-		expect(format.type).toBe("string");
-		expect(format.enum).toEqual(["markdown", "text", "html"]);
-		expect(format.description).toContain('exactly "markdown"');
-		expect(format.description).toContain('"html"');
-	});
-});
-
-describe("fetch parameter requiredness", () => {
-	test("only url is required; format is optional and defaults to markdown", () => {
-		const params = captureParameters(registerFetch);
-
-		// url must be required, format must NOT be — this is the exact validator
-		// bug the optionality fix addresses (executeFetch already defaults format
-		// to "markdown"), so guard against a regression back to a required format.
-		expect(params.required).toEqual(["url"]);
-		expect(params.required).not.toContain("format");
-
-		// format stays a fully described enum in properties even while optional.
-		const format = params.properties.format;
-		if (!format) throw new Error("format schema not found");
-		expect(format.enum).toEqual(["markdown", "text", "html"]);
-		expect(format.description?.toLowerCase()).toContain("default");
-	});
-});