@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/jev-tool-ranker.test.ts

@@ -0,0 +1,185 @@
+/**
+ * The Jev tool ranker: what tool_search and searchTools() get back, what Jev is sent, and that
+ * discovery keeps working (BM25) whenever Jev cannot answer.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+const state = vi.hoisted(() => ({ settingsPath: "" }));
+
+vi.mock("@selesai/code", async () => ({
+	...(await import("./tool-search/tool.ts")),
+	getSettingsPath: () => state.settingsPath,
+}));
+
+import { TOKENIN_JEV_CLASSIFIER } from "./jev/classifier.ts";
+import { JEV_ROUTING_EVENT } from "./jev/decisions.ts";
+import { classifierResponse, providerTemplate } from "./jev/test-support.ts";
+import { createJevToolRanker, TOOL_RANK_MAX_REQUESTS } from "./jev-tool-ranker.ts";
+import { FIND_BATCH } from "./jev-ask-tool.ts";
+import { Bm25Ranker, createToolSearchDocument, type ToolSearchDocument } from "./tool-search/tool.ts";
+
+let root: string;
+beforeAll(() => {
+	root = mkdtempSync(join(tmpdir(), "jev-tool-ranker-"));
+	mkdirSync(join(root, "agent"), { recursive: true });
+	state.settingsPath = join(root, "agent", "settings.json");
+});
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+
+const tool = (name: string, description: string): ToolSearchDocument =>
+	createToolSearchDocument({ name, description, parameters: {} as never });
+
+const TOOLS = [
+	tool("mcp__gh__create_issue", "Open a new issue in a repository to track a defect or task."),
+	tool("mcp__db__run_query", "Run a read-only SQL query against the analytics database."),
+	tool("mcp__cal__add_event", "Add an event to the calendar."),
+];
+
+interface Sent {
+	state: { request: string; tools: Record<string, string> };
+	questions: Record<string, { instructions: string }>;
+}
+
+function setup(options: { enabled?: boolean; credential?: boolean; relevant?: string[]; score?: number } = {}) {
+	writeFileSync(
+		state.settingsPath,
+		JSON.stringify({ jevAdvisory: { routes: { toolSearch: { enabled: options.enabled ?? true } } } }),
+		"utf-8",
+	);
+	const relevant = new Set(options.relevant ?? []);
+	const sent: Sent[] = [];
+	const classify = vi.fn(async (_model: unknown, context: Sent) => {
+		sent.push(context);
+		const names = Object.keys(context.state.tools);
+		const answers = Object.fromEntries(
+			Object.keys(context.questions).map((id, index) => [
+				id,
+				{ noul: relevant.has(names[Number(id.slice(1))]) ? (options.score ?? 0.92) : 0.08 },
+			]),
+		);
+		return classifierResponse(JSON.stringify({ answers }));
+	});
+	const events: Record<string, unknown>[] = [];
+	const ranker = createJevToolRanker({
+		events: { emit: (channel, data) => channel === JEV_ROUTING_EVENT && events.push(data as Record<string, unknown>) },
+	});
+	const ctx = {
+		modelRegistry: {
+			getAll: () => [providerTemplate()],
+			// Only Jev is registered: asking for any other model would find none and fall back to BM25.
+			findOfType: (type: string, provider: string, id: string) =>
+				type === "classifier" && provider === "tokenin" && id === "jev-1.13"
+					? { ...TOKENIN_JEV_CLASSIFIER }
+					: undefined,
+			getApiKeyAndHeaders: async () => (options.credential === false ? { ok: false } : { ok: true, apiKey: "key", headers: {} }),
+			classify,
+		},
+	};
+	return { ranker, ctx: ctx as never, classify, sent, events };
+}
+
+beforeEach(() => vi.clearAllMocks());
+
+describe("Jev tool ranker", () => {
+	it("finds a tool whose words the query never uses", async () => {
+		const query = "file a bug report for the crash";
+		expect(new Bm25Ranker().rank(query, TOOLS, 5)).toEqual([]);
+		const { ranker, ctx, classify, sent, events } = setup({ relevant: ["mcp__gh__create_issue"] });
+
+		const matches = await ranker.rank(query, TOOLS, 5, { ctx });
+
+		expect(matches.map((match) => match.name)).toEqual(["mcp__gh__create_issue"]);
+		expect(classify.mock.calls[0][0]).toMatchObject({ id: "jev-1.13", api: "typesafe-system-one" });
+		expect(sent).toHaveLength(1);
+		expect(sent[0].state.request).toBe(query);
+		expect(Object.keys(sent[0].state.tools)).toEqual(TOOLS.map((document) => document.name));
+		expect(sent[0].state.tools["mcp__cal__add_event"]).toContain("Add an event to the calendar.");
+		expect(events).toEqual([
+			expect.objectContaining({ route: "toolSearch", outcome: "jev", candidates: 3, judged: 3, matched: 1, confidence: "high" }),
+		]);
+		// Telemetry is shape only.
+		expect(JSON.stringify(events)).not.toContain("bug report");
+	});
+
+	it("orders matches by Jev's probability and honors the limit", async () => {
+		const { ranker, ctx } = setup({ relevant: ["mcp__db__run_query", "mcp__cal__add_event"] });
+		const matches = await ranker.rank("anything", TOOLS, 1, { ctx });
+		expect(matches).toHaveLength(1);
+	});
+
+	it("treats Jev as the judge: low probabilities mean no match", async () => {
+		const { ranker, ctx } = setup({ relevant: [] });
+		expect(await ranker.rank("calendar event", TOOLS, 5, { ctx })).toEqual([]);
+	});
+
+	it("ranks with BM25 and sends nothing without a session", async () => {
+		const { ranker, classify } = setup({ relevant: ["mcp__gh__create_issue"] });
+		const matches = await ranker.rank("calendar event", TOOLS, 5);
+		expect(matches.map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(classify).not.toHaveBeenCalled();
+	});
+
+	it("ranks with BM25 when the route is off", async () => {
+		const { ranker, ctx, classify } = setup({ enabled: false });
+		expect((await ranker.rank("calendar event", TOOLS, 5, { ctx })).map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(classify).not.toHaveBeenCalled();
+	});
+
+	it("ranks with BM25 without a Token-In credential", async () => {
+		const { ranker, ctx, classify, events } = setup({ credential: false });
+		expect((await ranker.rank("calendar event", TOOLS, 5, { ctx })).map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(classify).not.toHaveBeenCalled();
+		expect(events).toEqual([expect.objectContaining({ route: "toolSearch", outcome: "fallback", reason: "no-credential" })]);
+	});
+
+	it("ranks with BM25 when every request fails", async () => {
+		const { ranker, ctx, classify, events } = setup();
+		classify.mockRejectedValue(new Error("down"));
+		expect((await ranker.rank("calendar event", TOOLS, 5, { ctx })).map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(events).toEqual([expect.objectContaining({ outcome: "fallback" })]);
+	});
+
+	it("ranks with BM25 when the caller already aborted", async () => {
+		const { ranker, ctx } = setup({ relevant: ["mcp__gh__create_issue"] });
+		const controller = new AbortController();
+		controller.abort();
+		const matches = await ranker.rank("calendar event", TOOLS, 5, { ctx, signal: controller.signal });
+		expect(matches.map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+	});
+
+	it("keeps BM25 hits for tools whose batch failed", async () => {
+		// 18 BM25 hits fill one batch of 16 and spill two into a second batch.
+		const documents = Array.from({ length: FIND_BATCH + 2 }, (_, index) => tool(`mcp__x__gadget_${index}`, `A gadget, number ${index}.`));
+		const { ranker, ctx, classify } = setup({ relevant: ["mcp__x__gadget_3"] });
+		const answer = classify.getMockImplementation()!;
+		classify.mockImplementation(async (model, context) => {
+			if ("mcp__x__gadget_16" in context.state.tools) throw new Error("down");
+			return answer(model, context);
+		});
+
+		const matches = await ranker.rank("gadget", documents, 30, { ctx });
+
+		// Jev's verdicts come first, then the tools Jev never scored in BM25 order; scored-and-rejected tools are gone.
+		expect(matches.map((match) => match.name)).toEqual(["mcp__x__gadget_3", "mcp__x__gadget_16", "mcp__x__gadget_17"]);
+	});
+
+	it("sends at most TOOL_RANK_MAX_REQUESTS requests, choosing by BM25 past the cap", async () => {
+		const cap = TOOL_RANK_MAX_REQUESTS * FIND_BATCH;
+		const documents = [
+			...Array.from({ length: cap + 50 }, (_, index) => tool(`mcp__bulk__tool_${index}`, `Generic helper ${index}.`)),
+			tool("mcp__late__quokka", "Pet the quokka."),
+		];
+		const { ranker, ctx, classify, sent } = setup({ relevant: ["mcp__late__quokka"] });
+
+		const matches = await ranker.rank("quokka", documents, 3, { ctx });
+
+		expect(classify.mock.calls.length).toBeLessThanOrEqual(TOOL_RANK_MAX_REQUESTS);
+		const judged = sent.flatMap((request) => Object.keys(request.state.tools));
+		expect(judged).toHaveLength(cap);
+		expect(judged).toContain("mcp__late__quokka");
+		expect(matches.map((match) => match.name)).toEqual(["mcp__late__quokka"]);
+	});
+});

package/dist/extensions/jev-tool-ranker.ts

@@ -0,0 +1,169 @@
+/**
+ * jev-tool-ranker — ranks tools for `tool_search` and codemode's `searchTools()` with Jev.
+ *
+ * Each candidate tool is one yes/no question ("would this tool help with the request?"), batched
+ * into parallel requests; the model's probability is the score. This is the `toolSearch` route of
+ * `jevAdvisory` (on by default). It asks the shared Jev model; set
+ * `jevAdvisory.routes.toolSearch.model` to use another decisions model from `jev/classifier.ts`.
+ * The ranker never throws and never blocks discovery: with no
+ * session, the route off, no Token-In credential, or any request failing, it returns the local
+ * BM25 ranking, and tools the model did not score are appended in BM25 order.
+ *
+ * Which tools are sent: every candidate, up to TOOL_RANK_MAX_REQUESTS * FIND_BATCH. Past that cap
+ * the BM25 order decides which candidates are sent; the rest keep their BM25 place.
+ */
+import { Bm25Ranker, getSettingsPath, registerToolRanker } from "@selesai/code";
+import type {
+	ExtensionAPI,
+	ToolRankOptions,
+	ToolRanker,
+	ToolSearchDocument,
+	ToolSearchMatch,
+} from "@selesai/code";
+import { FIND_BATCH, FindRequests, type JudgeItem, type JudgeStage, judgeNouls } from "./jev-ask-tool.ts";
+import {
+	askJevAnswers,
+	confidenceBucket,
+	emitJevTelemetry,
+	type JevAdvisoryConfig,
+	jevConnection,
+	type JevRuntime,
+	jevUnavailable,
+	readJevAdvisoryConfig,
+} from "./jev/decisions.ts";
+
+/** Parallel Jev requests one ranking may send (16 tools each). */
+export const TOOL_RANK_MAX_REQUESTS = 12;
+/** Spare requests for retrying transport failures. */
+export const TOOL_RANK_RETRIES = 2;
+/** A tool is a match at this probability or above: matches become part of the model's context. */
+export const TOOL_RANK_KEEP = 0.5;
+/** Characters of a tool's summary shown to Jev. */
+export const TOOL_RANK_SUMMARY_CHARS = 480;
+
+const STAGE: Pick<JudgeStage, "stateKey" | "criteria"> = {
+	stateKey: "tools",
+	criteria: {
+		true: "The tool's name and description show it can do what the request asks for, or is a direct step toward it.",
+		false: "The tool does something unrelated to the request.",
+	},
+};
+
+export interface JevToolRankerOptions {
+	/** Receives route telemetry (shape and outcome only; never the query or tool text). */
+	events?: { emit(channel: string, data: unknown): void };
+	/** Ranks when Jev cannot, and orders the candidates sent past the cap. Default: BM25. */
+	fallback?: ToolRanker;
+	/** Reads the `jevAdvisory` settings. Default: the agent settings file. */
+	readConfig?: () => JevAdvisoryConfig;
+}
+
+/** Resolves with `work`, or rejects if `signal` aborts first. The request itself is not cancelled. */
+function abortable<T>(work: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+	if (!signal) return work;
+	return new Promise<T>((resolve, reject) => {
+		const onAbort = () => reject(new Error("aborted"));
+		if (signal.aborted) return onAbort();
+		signal.addEventListener("abort", onAbort, { once: true });
+		work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+
+export function createJevToolRanker(options: JevToolRankerOptions = {}): ToolRanker {
+	const fallback = options.fallback ?? new Bm25Ranker();
+	const readConfig = options.readConfig ?? (() => readJevAdvisoryConfig(getSettingsPath()));
+
+	return {
+		async rank(
+			query: string,
+			documents: readonly ToolSearchDocument[],
+			limit: number,
+			rankOptions?: ToolRankOptions,
+		): Promise<ToolSearchMatch[]> {
+			const local = await fallback.rank(query, documents, documents.length, rankOptions);
+			const ctx = rankOptions?.ctx;
+			if (!ctx || documents.length === 0 || limit <= 0 || query.trim() === "") return local.slice(0, limit);
+
+			const started = Date.now();
+			const telemetry = (outcome: "jev" | "fallback", extra: Record<string, unknown> = {}) =>
+				emitJevTelemetry(options.events, "decision", {
+					route: "toolSearch",
+					outcome,
+					candidates: documents.length,
+					elapsedMs: Date.now() - started,
+					...extra,
+				});
+
+			try {
+				// Same cast as ask_jev: the session registry is wider than JevRuntime's header type.
+				const runtime = ctx as unknown as JevRuntime;
+				const config = readConfig();
+				const route = config.routes.toolSearch;
+				if (!route.enabled) return local.slice(0, limit);
+				const connection = jevConnection(config, route);
+				const unreachable = await jevUnavailable(runtime, connection);
+				if (unreachable) {
+					telemetry("fallback", { confidence: confidenceBucket(undefined), reason: unreachable });
+					return local.slice(0, limit);
+				}
+
+				// BM25 hits first, then the rest in document order: the cap drops the least likely tools.
+				const byName = new Map(documents.map((document) => [document.name, document]));
+				const hits = new Set(local.map((match) => match.name));
+				const order = [...local.map((match) => match.name), ...documents.map((d) => d.name).filter((n) => !hits.has(n))];
+				const judged = order.slice(0, TOOL_RANK_MAX_REQUESTS * FIND_BATCH).map((name) => byName.get(name)!);
+				const items: JudgeItem[] = judged.map((document) => ({
+					key: document.name,
+					text: (document.summary ?? document.text).slice(0, TOOL_RANK_SUMMARY_CHARS),
+					question: `Would calling the tool "${document.name}" help carry out the request?`,
+				}));
+
+				const requests = new FindRequests(
+					(payload) => askJevAnswers(runtime, connection, { payload, maxBytes: route.payloadBytes }),
+					TOOL_RANK_MAX_REQUESTS + TOOL_RANK_RETRIES,
+				);
+				const outcome = await abortable(
+					judgeNouls(requests, { request: query, ...STAGE }, items, route.payloadBytes, {
+						send: TOOL_RANK_MAX_REQUESTS,
+						retry: TOOL_RANK_MAX_REQUESTS + TOOL_RANK_RETRIES,
+					}),
+					rankOptions?.signal,
+				);
+
+				const unscored = new Set(documents.map((document) => document.name));
+				const position = new Map(order.map((name, index) => [name, index]));
+				const scored: ToolSearchMatch[] = [];
+				items.forEach((item, index) => {
+					const score = outcome.scores[index];
+					if (typeof score !== "number" || !Number.isFinite(score)) return;
+					unscored.delete(item.key);
+					if (score >= TOOL_RANK_KEEP) scored.push({ name: item.key, score });
+				});
+				if (unscored.size === documents.length) {
+					telemetry("fallback", { confidence: confidenceBucket(undefined), reason: outcome.reasons[0] ?? "missing" });
+					return local.slice(0, limit);
+				}
+				scored.sort((a, b) => b.score - a.score || (position.get(a.name) ?? 0) - (position.get(b.name) ?? 0));
+				const extras = local.filter((match) => unscored.has(match.name)).map((match) => ({ name: match.name, score: 0 }));
+				telemetry("jev", {
+					judged: items.length,
+					matched: scored.length,
+					confidence: confidenceBucket(scored[0]?.score),
+					...(unscored.size > 0 ? { unscored: unscored.size } : {}),
+				});
+				return [...scored, ...extras].slice(0, limit);
+			} catch {
+				// Discovery must work without Jev: an abort, a transport error, or a bad answer ranks locally.
+				telemetry("fallback", { confidence: confidenceBucket(undefined), reason: "transport" });
+				return local.slice(0, limit);
+			}
+		},
+	};
+}
+
+export default function jevToolRankerExtension(pi: ExtensionAPI): void {
+	const dispose = registerToolRanker(createJevToolRanker({ events: pi.events }));
+	pi.on("session_shutdown", () => {
+		dispose();
+	});
+}

package/dist/{core → extensions}/llama/client.d.ts

@@ -30,6 +30,7 @@ export interface LlamaModelsResponse {
 }
 export interface LlamaServerProps {
     models_autoload?: boolean;
+    chat_template?: string;
 }
 export interface LlamaModelEvent {
     model: string;
@@ -54,6 +55,7 @@ export declare class LlamaClient {
         signal?: AbortSignal;
     }): Promise<LlamaModelInfo[]>;
     props(options?: {
+        model?: string;
         signal?: AbortSignal;
     }): Promise<LlamaServerProps>;
     load(model: string, signal?: AbortSignal): Promise<void>;

package/dist/{core → extensions}/llama/client.js

@@ -151,11 +151,15 @@ export class LlamaClient {
         return data;
     }
     async props(options = {}) {
-        const payload = await this.request("/props", { signal: options.signal });
+        const query = options.model ? `?${new URLSearchParams({ model: options.model, autoload: "false" })}` : "";
+        const payload = await this.request(`/props${query}`, { signal: options.signal });
         if (typeof payload !== "object" || payload === null)
             return {};
-        const { models_autoload: modelsAutoload } = payload;
-        return typeof modelsAutoload === "boolean" ? { models_autoload: modelsAutoload } : {};
+        const { models_autoload: modelsAutoload, chat_template: chatTemplate } = payload;
+        return {
+            ...(typeof modelsAutoload === "boolean" ? { models_autoload: modelsAutoload } : {}),
+            ...(typeof chatTemplate === "string" ? { chat_template: chatTemplate } : {}),
+        };
     }
     async load(model, signal) {
         await this.request("/models/load", { method: "POST", body: JSON.stringify({ model }), signal });

package/dist/{core → extensions}/llama/index.js

@@ -36,9 +36,20 @@ export default function llamaExtension(pi) {
     const provider = createLlamaProvider();
     pi.registerProvider(provider.provider);
     const syncCatalog = async (ctx, client, catalog) => {
-        const current = catalog ?? (await client.list());
+        const signal = AbortSignal.timeout(15_000);
+        const current = catalog ?? (await client.list({ signal }));
         provider.setCatalog(current, client.serverUrl);
-        await ctx.modelRegistry.refresh();
+        const result = await ctx.modelRegistry.refresh({
+            providers: [LLAMA_PROVIDER_ID],
+            // /llama already contacted the configured llama.cpp server, so keep this refresh live even in PI_OFFLINE.
+            allowNetwork: true,
+            signal,
+        });
+        if (result.aborted)
+            throw new Error("Model catalog refresh timed out.");
+        const refreshError = result.errors.get(LLAMA_PROVIDER_ID);
+        if (refreshError)
+            throw refreshError;
         return current;
     };
     const loadModel = async (ctx, ui, client, catalog, target) => {

package/dist/{core → extensions}/llama/provider.d.ts

@@ -1,4 +1,4 @@
-import type { Provider } from "@earendil-works/pi-ai";
+import { type Provider } from "@earendil-works/pi-ai";
 import { type LlamaModelInfo } from "./client.ts";
 export declare const LLAMA_PROVIDER_ID = "llama.cpp";
 export declare const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";

package/dist/extensions/llama/provider.js

@@ -0,0 +1,235 @@
+import { isModelType, } from "@earendil-works/pi-ai";
+import { llamaCppClassifyApi } from "@earendil-works/pi-ai/api/llama-cpp-classify.lazy";
+import { typesafeSystemOneApi } from "@earendil-works/pi-ai/api/typesafe-system-one.lazy";
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import { LlamaClient, llamaInferenceUrl, normalizeLlamaServerUrl, } from "./client.js";
+export const LLAMA_PROVIDER_ID = "llama.cpp";
+export const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";
+function credentialServerUrl(credential) {
+    const value = credential?.env?.LLAMA_BASE_URL;
+    return typeof value === "string" && value.trim() ? normalizeLlamaServerUrl(value) : undefined;
+}
+async function resolveServerUrl(ctx, credential) {
+    const configured = credentialServerUrl(credential) ?? (await ctx.env("LLAMA_BASE_URL"))?.trim();
+    return configured ? normalizeLlamaServerUrl(configured) : undefined;
+}
+function modelIsSelectable(model, routerAutoload) {
+    if (model.status.value === "loaded")
+        return true;
+    // llama.cpp reports idle-slept models as "sleeping"; requests wake them automatically.
+    if (model.status.value === "sleeping")
+        return true;
+    // Unloaded presets are routable only when llama.cpp router autoload can load them on first use.
+    return routerAutoload && model.status.value === "unloaded" && !model.status.failed && model.source === "preset";
+}
+async function routerAutoloadEnabled(client, catalog, signal) {
+    if (!catalog.some((model) => model.status.value === "unloaded" && model.source === "preset"))
+        return false;
+    try {
+        return (await client.props({ signal })).models_autoload === true;
+    }
+    catch {
+        return false;
+    }
+}
+function configuredContextWindow(model) {
+    const args = model.status.args ?? [];
+    for (let index = 0; index < args.length - 1; index++) {
+        const flag = args[index];
+        if (flag !== "--ctx-size" && flag !== "-c" && flag !== "-ctx")
+            continue;
+        const contextWindow = Number(args[index + 1]);
+        if (Number.isSafeInteger(contextWindow) && contextWindow > 0)
+            return contextWindow;
+    }
+    return undefined;
+}
+function contextWindowOf(model, cachedContextWindow) {
+    const runtimeContextWindow = model.meta?.n_ctx;
+    if (runtimeContextWindow && runtimeContextWindow > 0)
+        return runtimeContextWindow;
+    const configuredContext = configuredContextWindow(model);
+    if (configuredContext)
+        return configuredContext;
+    if (cachedContextWindow && cachedContextWindow > 0)
+        return cachedContextWindow;
+    const trainingContextWindow = model.meta?.n_ctx_train;
+    return trainingContextWindow && trainingContextWindow > 0 ? trainingContextWindow : 128000;
+}
+/**
+ * Whether llama.cpp reports a native decision model. Since llama.cpp 0.6.0, `GET /models` lists
+ * `decisions` in `architecture.output_modalities` for these models, including unloaded and sleeping ones.
+ * Older servers report `["text"]` or omit `architecture`, so their models are treated as chat models.
+ */
+function isDecisionModel(model) {
+    return model.architecture?.output_modalities?.includes("decisions") === true;
+}
+/** Decision-only models cannot generate text and are not listed for chat. */
+function isChatModel(model) {
+    return !isDecisionModel(model) || model.architecture?.output_modalities?.includes("text") === true;
+}
+/**
+ * A llama.cpp model used as a classifier. Decision models answer natively through llama.cpp's
+ * System One endpoint (`/v1/systemone`). Chat models fall back to `llama-cpp-classify`, which reads
+ * answers from next-token label probabilities.
+ */
+function toPiClassifierModel(model, serverUrl, cachedContextWindow) {
+    const decision = isDecisionModel(model);
+    return {
+        type: "classifier",
+        id: model.id,
+        name: model.id,
+        api: decision ? "typesafe-system-one" : "llama-cpp-classify",
+        provider: LLAMA_PROVIDER_ID,
+        baseUrl: decision ? llamaInferenceUrl(serverUrl) : serverUrl,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: contextWindowOf(model, cachedContextWindow),
+    };
+}
+function isLlamaClassifierModel(model) {
+    return (isModelType(model, "classifier") && (model.api === "llama-cpp-classify" || model.api === "typesafe-system-one"));
+}
+function toPiModel(model, serverUrl, props, cachedContextWindow) {
+    const contextWindow = contextWindowOf(model, cachedContextWindow);
+    const reasoning = props?.chat_template?.includes("enable_thinking") === true;
+    return {
+        id: model.id,
+        name: model.id,
+        api: "openai-completions",
+        provider: LLAMA_PROVIDER_ID,
+        baseUrl: llamaInferenceUrl(serverUrl),
+        reasoning,
+        ...(reasoning && {
+            thinkingLevelMap: { off: "off", minimal: null, low: null, medium: "medium", high: null, xhigh: null },
+        }),
+        input: model.architecture?.input_modalities?.includes("image") ? ["text", "image"] : ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow,
+        maxTokens: contextWindow,
+        compat: {
+            supportsStore: false,
+            supportsDeveloperRole: false,
+            supportsReasoningEffort: false,
+            supportsUsageInStreaming: true,
+            supportsStrictMode: false,
+            maxTokensField: "max_tokens",
+            ...(reasoning && { thinkingFormat: "qwen-chat-template" }),
+        },
+    };
+}
+export function createLlamaProvider() {
+    let models = [];
+    let classifiers = [];
+    const fallbackClassifier = llamaCppClassifyApi();
+    const decisionClassifier = typesafeSystemOneApi();
+    const setCatalog = (catalog, serverUrl, options = {}) => {
+        const selectable = catalog.filter((model) => modelIsSelectable(model, options.routerAutoload === true));
+        models = selectable.filter(isChatModel).map((model) => toPiModel(model, serverUrl));
+        classifiers = selectable.map((model) => toPiClassifierModel(model, serverUrl));
+    };
+    const provider = {
+        id: LLAMA_PROVIDER_ID,
+        name: "llama.cpp",
+        baseUrl: llamaInferenceUrl(DEFAULT_LLAMA_SERVER_URL),
+        auth: {
+            apiKey: {
+                name: "llama.cpp server",
+                login: async (interaction) => {
+                    const enteredUrl = await interaction.prompt({
+                        type: "text",
+                        message: "llama.cpp server URL",
+                        placeholder: process.env.LLAMA_BASE_URL ?? DEFAULT_LLAMA_SERVER_URL,
+                    });
+                    const serverUrl = normalizeLlamaServerUrl(enteredUrl.trim() || process.env.LLAMA_BASE_URL || DEFAULT_LLAMA_SERVER_URL);
+                    const apiKey = (await interaction.prompt({
+                        type: "secret",
+                        message: "API key (optional)",
+                    })).trim();
+                    await new LlamaClient(serverUrl, apiKey || undefined).list({ signal: interaction.signal });
+                    return {
+                        type: "api_key",
+                        key: apiKey || undefined,
+                        env: { LLAMA_BASE_URL: serverUrl },
+                    };
+                },
+                check: async ({ ctx, credential }) => {
+                    const serverUrl = await resolveServerUrl(ctx, credential);
+                    return serverUrl
+                        ? { type: "api_key", source: credential ? "stored credential" : "LLAMA_BASE_URL" }
+                        : undefined;
+                },
+                resolve: async ({ ctx, credential }) => {
+                    const serverUrl = await resolveServerUrl(ctx, credential);
+                    if (!serverUrl)
+                        return undefined;
+                    const apiKey = credential?.key ?? (await ctx.env("LLAMA_API_KEY")) ?? "local";
+                    return {
+                        auth: { apiKey, baseUrl: llamaInferenceUrl(serverUrl) },
+                        env: { ...credential?.env, LLAMA_BASE_URL: serverUrl },
+                        source: credential ? "stored credential" : "LLAMA_BASE_URL",
+                    };
+                },
+            },
+        },
+        getModels: () => models,
+        getAllModels: () => [...models, ...classifiers],
+        refreshModels: async (context) => {
+            const cachedContextWindows = new Map();
+            if (context.stored) {
+                const stored = context.stored.models.filter((model) => model.provider === LLAMA_PROVIDER_ID);
+                const restored = stored.filter((model) => isModelType(model, "chat") && model.api === "openai-completions");
+                const restoredClassifiers = stored.filter(isLlamaClassifierModel);
+                for (const model of [...restored, ...restoredClassifiers]) {
+                    cachedContextWindows.set(model.id, model.contextWindow);
+                }
+                if (!(await context.publish({
+                    update: () => {
+                        models = restored;
+                        classifiers = restoredClassifiers;
+                    },
+                }))) {
+                    return;
+                }
+            }
+            if (!context.allowNetwork || context.signal.aborted || context.credential?.type !== "api_key")
+                return;
+            const serverUrl = credentialServerUrl(context.credential);
+            if (!serverUrl)
+                return;
+            const client = new LlamaClient(serverUrl, context.credential.key);
+            const catalog = await client.list({ signal: context.signal });
+            if (context.signal.aborted)
+                return;
+            const routerAutoload = await routerAutoloadEnabled(client, catalog, context.signal);
+            if (context.signal.aborted)
+                return;
+            const selectable = catalog.filter((model) => modelIsSelectable(model, routerAutoload));
+            // Only loaded models expose their chat template without side effects. Unloaded autoload presets would
+            // need to be loaded, while querying sleeping models may wake them. Those models remain without thinking
+            // support until they are loaded and a later catalog refresh discovers it. Decision models need no
+            // template, and llama.cpp reports them in the catalog regardless of their status.
+            const refreshed = await Promise.all(selectable.filter(isChatModel).map(async (model) => {
+                const cachedContextWindow = cachedContextWindows.get(model.id);
+                if (model.status.value !== "loaded")
+                    return toPiModel(model, serverUrl, undefined, cachedContextWindow);
+                const props = await client.props({ model: model.id, signal: context.signal });
+                return toPiModel(model, serverUrl, props, cachedContextWindow);
+            }));
+            const refreshedClassifiers = selectable.map((model) => toPiClassifierModel(model, serverUrl, cachedContextWindows.get(model.id)));
+            if (context.signal.aborted)
+                return;
+            await context.publish({
+                persist: { models: [...refreshed, ...refreshedClassifiers], checkedAt: Date.now() },
+                update: () => {
+                    models = refreshed;
+                    classifiers = refreshedClassifiers;
+                },
+            });
+        },
+        stream: (model, context, options) => stream(model, context, options),
+        streamSimple: (model, context, options) => streamSimple(model, context, options),
+        classify: (model, context, options) => (model.api === "typesafe-system-one" ? decisionClassifier : fallbackClassifier).classify(model, context, options),
+    };
+    return { provider, setCatalog };
+}