@selesai/code 0.14.0 → 0.14.3

package/dist/config.d.ts

@@ -187,6 +187,15 @@ export declare function seedMissingSubagentSettings(destPath: string, bundledDef
  * rewritten.
  */
 export declare function seedMissingGraftSettings(destPath: string, bundledDefaultsDir?: string): boolean;
+/**
+ * Add the bundled `defaultTools` selection (which enables `codemode`) to an existing user
+ * settings file that does not set `defaultTools` at all. Settings files created before the
+ * bundled default existed would otherwise never get it. A user-provided `defaultTools`, even an
+ * empty one or one with only `-name` entries, is never touched. The file is modified with a
+ * minimal textual insertion, so other settings keep their formatting. Returns true when the file
+ * was rewritten.
+ */
+export declare function seedMissingDefaultToolsSettings(destPath: string, bundledDefaultsDir?: string): boolean;
 /**
  * Bundled extensions load directly from the installed package. Do not copy them
  * into the user's agent dir, otherwise startup discovers both copies and tool
@@ -213,7 +222,7 @@ export declare function seedDefaultSkills(agentDir: string, bundledSkillsDir?: s
 export declare function seedDefaultThemes(agentDir: string, bundledThemesDir?: string): string[];
 /**
  * Run bootstrap for the agent dir: ensure directories, seed a missing
- * settings.json, and add missing bundled subagent defaults. Idempotent — safe
+ * settings.json, and add missing bundled subagent, graft, and default-tools settings. Idempotent — safe
  * on every startup.
  * Bundled models load package-locally; copying them would expose internal
  * providers as user config. Bundled extensions also stay package-local.

package/dist/config.js

@@ -801,6 +801,43 @@ export function seedMissingGraftSettings(destPath, bundledDefaultsDir = getBundl
         return false;
     }
 }
+/**
+ * Add the bundled `defaultTools` selection (which enables `codemode`) to an existing user
+ * settings file that does not set `defaultTools` at all. Settings files created before the
+ * bundled default existed would otherwise never get it. A user-provided `defaultTools`, even an
+ * empty one or one with only `-name` entries, is never touched. The file is modified with a
+ * minimal textual insertion, so other settings keep their formatting. Returns true when the file
+ * was rewritten.
+ */
+export function seedMissingDefaultToolsSettings(destPath, bundledDefaultsDir = getBundledDefaultsDir()) {
+    if (!existsSync(destPath))
+        return false;
+    try {
+        const raw = readFileSync(destPath, "utf-8");
+        const settings = JSON.parse(raw);
+        const defaults = JSON.parse(readFileSync(join(bundledDefaultsDir, "settings.json"), "utf-8"));
+        if (typeof settings !== "object" ||
+            settings === null ||
+            Array.isArray(settings) ||
+            Object.hasOwn(settings, "defaultTools") ||
+            typeof defaults !== "object" ||
+            defaults === null ||
+            Array.isArray(defaults)) {
+            return false;
+        }
+        const defaultTools = defaults.defaultTools;
+        if (!Array.isArray(defaultTools) || !defaultTools.every((entry) => typeof entry === "string"))
+            return false;
+        const injected = injectRootObjectKey(raw, "defaultTools", defaultTools);
+        if (injected === undefined)
+            return false;
+        writeFileSync(destPath, injected);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Recursively copy a bundled directory tree into the user's agent dir,
  * overwriting any existing file so the bundled copy stays authoritative.
@@ -902,7 +939,7 @@ export function seedDefaultThemes(agentDir, bundledThemesDir = getBundledThemesD
 }
 /**
  * Run bootstrap for the agent dir: ensure directories, seed a missing
- * settings.json, and add missing bundled subagent defaults. Idempotent — safe
+ * settings.json, and add missing bundled subagent, graft, and default-tools settings. Idempotent — safe
  * on every startup.
  * Bundled models load package-locally; copying them would expose internal
  * providers as user config. Bundled extensions also stay package-local.
@@ -913,6 +950,7 @@ export function bootstrapAgentDir(agentDir = getAgentDir()) {
     seedDefaultConfigFile(settingsPath, "settings.json");
     seedMissingSubagentSettings(settingsPath);
     seedMissingGraftSettings(settingsPath);
+    seedMissingDefaultToolsSettings(settingsPath);
     seedDefaultExtensions(agentDir);
     seedDefaultSkills(agentDir);
     seedDefaultThemes(agentDir);

package/dist/core/resource-loader.js

@@ -389,6 +389,8 @@ export class DefaultResourceLoader {
         if (this.loaded) {
             clearExtensionCache();
         }
+        // The filter closes over the previous extension runtime (now stale); the reloaded extensions re-register theirs.
+        this.skillsIndexFilter = undefined;
         let preTrustExtensions;
         if (options?.resolveProjectTrust) {
             preTrustExtensions = await this.loadProjectTrustExtensions();

package/dist/extensions/codemode/execute.js

@@ -7,12 +7,14 @@ import { getCodemodeWorkerSpecifier, getQuickJSWasmPath } from "../../config.js"
 import { formatSize } from "../../core/tools/truncate.js";
 import { combineUsage } from "../../core/usage-totals.js";
 import { writeOutputFile } from "../../utils/output-files.js";
-import { Bm25Ranker, createToolSearchDocument, DEFAULT_TOOL_SEARCH_LIMIT } from "../tool-search/tool.js";
+import { createToolSearchDocument, DEFAULT_TOOL_SEARCH_LIMIT, getToolRanker } from "../tool-search/tool.js";
 import { CODEMODE_DOCS_PATH, CODEMODE_STORE_ENTRY_TYPE, getCodemodeCallableTools, toCodemodeDeclaration, } from "./tool.js";
 const ARGS_PREVIEW_CHARS = 200;
 const ERROR_PREVIEW_CHARS = 500;
 /** `models.classify()` and `models.generateImages()` calls one script may have in flight; `Promise.all` over many items queues the rest. */
 const MAX_CONCURRENT_MODEL_CALLS = 4;
+/** `searchTools()` calls per script that may use a model-backed ranker; later calls rank locally. */
+const MAX_SESSION_SEARCHES_PER_SCRIPT = 8;
 /**
  * Heap limit for the QuickJS VM. The worker shares pi's process, so without a limit a runaway
  * script can grow to wasm32's 4 GiB and take the session down. Overruns throw
@@ -413,7 +415,7 @@ export async function executeCodemode(toolCallId, input, signal, onUpdate, ctx,
     const sandbox = new CodemodeSandbox({
         tools: sandboxTools,
         globals: [
-            ...createDiscoveryGlobals(callable, samples, options),
+            ...createDiscoveryGlobals(callable, samples, options, ctx),
             ...(options.models && ctx
                 ? createModelGlobals(ctx.modelRegistry, toolCallId, calls, publish, addModelUsage, addGeneratedImages)
                 : []),
@@ -485,14 +487,16 @@ function isNamespaceName(namespace, query) {
  * `searchTools()`, `describeTool()`, and `describeNamespace()`: ranked search and lookup over the
  * script's nested tools and their namespaces.
  */
-function createDiscoveryGlobals(tools, samples, options) {
-    const ranker = new Bm25Ranker();
+function createDiscoveryGlobals(tools, samples, options, ctx) {
+    // A script may loop over searchTools(). Past this many searches the session is withheld from the
+    // ranker, so a model-backed ranker falls back to its local ranking instead of billing per iteration.
+    let sessionSearches = 0;
     const entry = (name) => ({ name: toCodemodeIdentifier(name), description: samples.get(name) ?? "" });
     return [
         {
             name: "searchTools",
             spread: true,
-            execute: (args) => {
+            execute: async (args, { signal }) => {
                 const [query, searchOptions] = args;
                 if (typeof query !== "string")
                     throw new Error("searchTools() expects a query string");
@@ -510,7 +514,15 @@ function createDiscoveryGlobals(tools, samples, options) {
                         return [];
                     return [createToolSearchDocument(tool, toolNamespace)];
                 });
-                return ranker.rank(query, documents, limit).map((match) => entry(match.name));
+                const session = ctx && sessionSearches < MAX_SESSION_SEARCHES_PER_SCRIPT ? ctx : undefined;
+                if (session)
+                    sessionSearches += 1;
+                const ranked = await getToolRanker().rank(query, documents, limit, { signal, ctx: session });
+                const known = new Set(documents.map((document) => document.name));
+                return ranked
+                    .filter((match) => known.has(match.name))
+                    .slice(0, limit)
+                    .map((match) => entry(match.name));
             },
         },
         {

package/dist/extensions/jev/classifier.test.ts

@@ -1,6 +1,6 @@
 import { expect, it, vi } from "vitest";
 import type { ClassifierContext } from "@earendil-works/pi-ai";
-import { classifyTokenIn, TOKENIN_JEV_CLASSIFIER } from "./classifier.ts";
+import { classifyTokenIn, MAX_IMAGE_BYTES, TOKENIN_CLASSIFIERS, TOKENIN_JEV_CLASSIFIER } from "./classifier.ts";
 import { fitsClassifierRequest, toClassifierContext } from "./classifier-context.ts";
 import { askJevAnswers } from "./decisions.ts";
 
@@ -9,38 +9,57 @@ const context: ClassifierContext = { state: { public: "protocol fixture" }, ques
 	risk: { type: "score", instructions: "Rate", criteria: ["low", "high"] },
 	ready: { type: "bool", instructions: "Ready?", criteria: { true: "Ready", false: "Not ready" } },
 } };
-const cost = { input: .001, output: .002, cacheRead: 0, cacheWrite: 0, total: .003 };
+const billed = .0000158;
 const body = () => ({ answers: {
 	pick: { type: "choice", choice: "yes", probabilities: { yes: .9, no: .1 }, confidence: .9 },
 	risk: { type: "score", score: 1.4, confidence: .8, legend: { 0: "low", 1: "high" } },
 	ready: { type: "noul", noul: .87, confidence: .93 },
-}, usage: { input_tokens: 10, output_tokens: 7, cost } });
-function transport(response: unknown) {
-	return vi.fn(async (_input: string | URL | Request, _init?: RequestInit) => new Response(JSON.stringify(response), { headers: { "content-type": "application/json" } }));
+}, usage: { input_tokens: 10, output_tokens: 7, cost: .0000122 } });
+/** The gateway's reply: the System One body is a chat completion's message content, the billed cost a header. */
+function transport(response: unknown, headers: Record<string, string> = { "x-litellm-response-cost": String(billed) }) {
+	return vi.fn(async (_input: string | URL | Request, _init?: RequestInit) =>
+		new Response(JSON.stringify({ choices: [{ message: { role: "assistant", content: JSON.stringify(response) } }] }), { headers: { "content-type": "application/json", ...headers } }));
 }
-it("uses the exact native endpoint, bearer key and TypeSafe wire shape, including bool -> noul", async () => {
+it("posts the System One request as a chat message to the gateway, with bool -> noul, and reports the billed cost", async () => {
 	const fetch = transport(body());
 	const result = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch });
 	expect(result.stopReason).toBe("stop");
-	expect(String(fetch.mock.calls[0][0])).toBe("https://lite.andlet.me/v1/systemone");
+	expect(String(fetch.mock.calls[0][0])).toBe("https://lite.andlet.me/v1/chat/completions");
 	const init = fetch.mock.calls[0][1]!;
 	expect(new Headers(init.headers).get("authorization")).toBe("Bearer fixture");
-	expect(JSON.parse(String(init.body))).toEqual({ model: "jev-1.13", state: JSON.stringify(context.state), questions: { ...context.questions, ready: { ...context.questions.ready, type: "noul" } } });
+	const sent = JSON.parse(String(init.body));
+	expect(sent).toEqual({ model: "jev-1.13", messages: [{ role: "user", content: expect.any(String) }] });
+	expect(JSON.parse(sent.messages[0].content)).toEqual({ state: JSON.stringify(context.state), questions: { ...context.questions, ready: { ...context.questions.ready, type: "noul" } } });
 	expect(result.answers.ready).toEqual({ type: "bool", probability: .87, confidence: .93 });
 	expect(result.answers.risk).toMatchObject({ legend: { 0: "low", 1: "high" } });
-	expect(result.usage).toMatchObject({ input: 10, output: 7, totalTokens: 17, cost });
+	// The header is the only cost; the body's own usage.cost is the provider's raw charge.
+	expect(result.reportedCost).toBe(billed);
+	expect(result.usage).toBeUndefined();
+	expect(result.unpricedUsage).toMatchObject({ input: 10, output: 7, totalTokens: 17 });
 });
-it("does not represent missing or invalid service pricing as a free catalog estimate", async () => {
-	for (const usage of [{ input_tokens: 10, output_tokens: 7 }, { input_tokens: 10, output_tokens: 7, cost: { ...cost, total: -1 } }]) {
-		const result = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch: transport({ ...body(), usage }) });
+it("reports no cost when the gateway sends none or an invalid one, and 0 for a cache hit", async () => {
+	for (const headers of [{}, { "x-litellm-response-cost": "-1" }, { "x-litellm-response-cost": "free" }, { "x-litellm-response-cost": "" }]) {
+		const result = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch: transport(body(), headers) });
+		expect(result.stopReason).toBe("stop");
+		expect(result.reportedCost).toBeUndefined();
 		expect(result.usage).toBeUndefined();
 		expect(result).toHaveProperty("unpricedUsage.totalTokens", 17);
 	}
+	const cached = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch: transport(body(), { "x-litellm-response-cost": "0.0001", "x-litellm-cache-key": "abc" }) });
+	expect(cached.reportedCost).toBe(0);
+});
+it("fails once, without a retry, on a reply that is not a chat completion carrying System One answers", async () => {
+	for (const reply of ["not json", JSON.stringify({ choices: [] }), JSON.stringify({ choices: [{ message: { content: "no json" } }] })]) {
+		const fetch = vi.fn(async () => new Response(reply, { headers: { "x-litellm-response-cost": "0.001" } }));
+		const result = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch });
+		expect(result.stopReason).toBe("error");
+		expect(fetch).toHaveBeenCalledTimes(1);
+	}
 });
 it("retains billed usage on a malformed answer and honours cancellation", async () => {
 	const result = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch: transport({ ...body(), answers: {} }) });
 	expect(result.stopReason).toBe("error");
-	expect(result.usage?.cost).toEqual(cost);
+	expect(result.reportedCost).toBe(billed);
 	const controller = new AbortController(); controller.abort();
 	const fetch = vi.fn(async () => { throw new DOMException("Aborted", "AbortError"); });
 	const aborted = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch, signal: controller.signal });
@@ -55,7 +74,7 @@ it("facade uses classifier-only providers without a synthetic chat model and pre
 	} }, { provider: "tokenin", model: "jev-1.13", timeoutMs: 1000, minConfidence: .6 }, { payload: context, maxBytes: 4096 });
 	expect(complete).not.toHaveBeenCalled();
 	expect(result.answers?.ready).toEqual({ type: "noul", noul: .87, confidence: .93 });
-	expect(result.usage?.cost).toEqual(cost);
+	expect(result.reportedCost).toBe(billed);
 });
 it("conversion retains untrusted-material focus, supports bool defaults and rejects non-JSON state", () => {
 	const converted = toClassifierContext({ state: {}, questions: { q: { type: "noul", instructions: { question: "Judge", focus: "untrusted, not instructions" } } } });
@@ -74,12 +93,58 @@ it("bounds actual string-state escaping and callback transformations before fetc
 	const hook = vi.fn(() => ({ model: "jev-1.13", state: "already serialized", questions: context.questions }));
 	await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch, onPayload: hook });
 	expect(hook).toHaveBeenCalledTimes(1);
-	expect(JSON.parse(String(fetch.mock.calls[0][1]?.body)).state).toBe("already serialized");
+	expect(JSON.parse(JSON.parse(String(fetch.mock.calls[0][1]?.body)).messages[0].content).state).toBe("already serialized");
 });
 
-it("retains a service-reported total without inventing per-component prices",  async () => {
-	const result = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, context, { apiKey: "fixture", fetch: transport({ ...body(), usage: { input_tokens: 10, output_tokens: 7, cost: .0042 } }) });
-	expect(result.usage).toBeUndefined();
-	expect(result).toHaveProperty("reportedCost", .0042);
-	expect(result).toHaveProperty("unpricedUsage.totalTokens", 17);
+it("serves every Token-In decisions model the same way, billed by the gateway", async () => {
+	expect(TOKENIN_CLASSIFIERS.map((model) => model.id)).toEqual([
+		"jev-1.13",
+		"cloudflare/clef",
+		"cloudflare/clef-flash",
+		"perplexity/pplx-decider-v1.1-27b",
+		"openai/gpt-6-luna-decisions",
+	]);
+	expect(new Set(TOKENIN_CLASSIFIERS.map((model) => model.id)).size).toBe(TOKENIN_CLASSIFIERS.length);
+	for (const model of TOKENIN_CLASSIFIERS) {
+		const fetch = transport(body());
+		const result = await classifyTokenIn(model, context, { apiKey: "fixture", fetch });
+		expect(result.stopReason, model.id).toBe("stop");
+		expect(String(fetch.mock.calls[0][0]), model.id).toBe("https://lite.andlet.me/v1/chat/completions");
+		expect(JSON.parse(String(fetch.mock.calls[0][1]!.body)), model.id).toMatchObject({ model: model.id });
+		expect(result.answers.ready, model.id).toMatchObject({ type: "bool", probability: .87 });
+		expect(result.reportedCost, model.id).toBe(billed);
+		expect(model.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+	}
+});
+
+const image = { type: "image" as const, data: "QUJD", mimeType: "image/png" };
+it("sends images inside the state array, only to the models that read them", async () => {
+	expect(TOKENIN_CLASSIFIERS.filter((model) => model.input.includes("image")).map((model) => model.id)).toEqual([
+		"perplexity/pplx-decider-v1.1-27b",
+		"openai/gpt-6-luna-decisions",
+	]);
+	for (const model of TOKENIN_CLASSIFIERS.filter((m) => m.input.includes("image"))) {
+		const fetch = transport(body());
+		const result = await classifyTokenIn(model, { ...context, images: [image, image] }, { apiKey: "fixture", fetch });
+		expect(result.stopReason, model.id).toBe("stop");
+		const request = JSON.parse(JSON.parse(String(fetch.mock.calls[0][1]!.body)).messages[0].content);
+		expect(request.images, model.id).toBeUndefined();
+		expect(request.state, model.id).toEqual([
+			JSON.stringify(context.state),
+			{ type: "image_url", image_url: { url: "data:image/png;base64,QUJD" } },
+			{ type: "image_url", image_url: { url: "data:image/png;base64,QUJD" } },
+		]);
+	}
+	// A text-only model is not sent the image: the call fails before any request.
+	const fetch = transport(body());
+	const result = await classifyTokenIn(TOKENIN_JEV_CLASSIFIER, { ...context, images: [image] }, { apiKey: "fixture", fetch });
+	expect(result.stopReason).toBe("error");
+	expect(fetch).not.toHaveBeenCalled();
+});
+it("refuses images over the size cap before sending anything", async () => {
+	const fetch = transport(body());
+	const lune = TOKENIN_CLASSIFIERS[4];
+	const result = await classifyTokenIn(lune, { ...context, images: [{ ...image, data: "A".repeat(MAX_IMAGE_BYTES + 1) }] }, { apiKey: "fixture", fetch });
+	expect(result.stopReason).toBe("error");
+	expect(fetch).not.toHaveBeenCalled();
 });

package/dist/extensions/jev/classifier.ts

@@ -1,86 +1,176 @@
-/** TokenIn's native System One classifier. Protocol parsing/retries remain upstream-owned. */
-import type { ClassifierModel, ClassifierResult, Usage } from "@earendil-works/pi-ai";
+/**
+ * TokenIn's decisions classifiers: Jev and the gateway's other decisions models (Clef, Perplexity
+ * Decider, GPT-6 Luna). They all take the same System One request and answer in the same format, so
+ * one implementation serves every model; the model id in the request body picks the deployment.
+ *
+ * Transport: the gateway serves them as chat deployments, so a request is `POST {baseUrl}/chat/completions`
+ * with one user message whose content is the JSON System One request `{state, questions}`, and the
+ * answer is the System One body (`{answers, usage}`) as the reply's message content. (Its
+ * `/v1/systemone` route is not deployed.) Protocol parsing and retries stay upstream-owned: this runs
+ * upstream's System One classifier and only changes the envelope through its `onPayload` and `fetch` hooks.
+ *
+ * Images travel inside the request's `state` array as `{ type: "image_url", image_url: { url: "data:..." } }`
+ * parts; the gateway rejects a top-level `images`. Only models that really read them declare image input.
+ *
+ * Billing: the gateway bills more than the provider's raw charge and puts what the account was charged
+ * in the `x-litellm-response-cost` header (0 for a response-cache hit). That is the only cost reported.
+ * The `usage.cost` in the body is the provider's raw charge (and 0 for some models), and the catalog
+ * price below is a placeholder, so neither is ever presented as cost.
+ */
+import type {
+	ClassifierApi,
+	ClassifierContext,
+	ClassifierModel,
+	ClassifierOptions,
+	ClassifierResult,
+	ImageContent,
+	Usage,
+} from "@earendil-works/pi-ai";
 import { classify as classifySystemOne } from "@earendil-works/pi-ai/api/typesafe-system-one";
 import { fitsClassifierRequest, tokenInWirePayload } from "./classifier-context.ts";
 
-export const TOKENIN_JEV_CLASSIFIER: ClassifierModel<"typesafe-system-one"> = {
-	type: "classifier", provider: "tokenin", id: "jev-1.13", name: "Jev 1.13 (service-priced)",
-	api: "typesafe-system-one", baseUrl: "https://lite.andlet.me/v1", input: ["text"], contextWindow: 64000,
-	// Required catalog fields, NOT a free-price assertion. Never return catalog-computed cost:
-	// expose usage.cost only when the service explicitly reports its monetary breakdown.
-	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-};
+/**
+ * `cost` is a required catalog field, NOT a price. Context windows are the ones pi-ai's OpenRouter
+ * catalog lists for the same models. `vision` models were checked against the live gateway with
+ * solid-colour images: Perplexity Decider and GPT-6 Luna answered every colour correctly, while Clef and
+ * Clef Flash accept an image but answer as if they had not seen it (their token counts follow the
+ * base64 text), so they are text-only here even though the OpenRouter catalog lists image input.
+ */
+function tokenInDecisionsModel(
+	id: string,
+	name: string,
+	contextWindow: number,
+	vision = false,
+): ClassifierModel<"typesafe-system-one"> {
+	return {
+		type: "classifier", provider: "tokenin", id, name: `${name} (service-priced)`,
+		api: "typesafe-system-one", baseUrl: "https://lite.andlet.me/v1", input: vision ? ["text", "image"] : ["text"], contextWindow,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	};
+}
+
+export const TOKENIN_JEV_CLASSIFIER = tokenInDecisionsModel("jev-1.13", "Jev 1.13", 64000);
+
+/** Cloudflare's Clef Flash: 65,536 tokens of context. */
+export const TOKENIN_CLEF_FLASH_CLASSIFIER = tokenInDecisionsModel("cloudflare/clef-flash", "Clef Flash", 65536);
+
+/** Every decisions model Token-In serves, Jev first. */
+export const TOKENIN_CLASSIFIERS: readonly ClassifierModel<"typesafe-system-one">[] = [
+	TOKENIN_JEV_CLASSIFIER,
+	tokenInDecisionsModel("cloudflare/clef", "Clef", 65536),
+	TOKENIN_CLEF_FLASH_CLASSIFIER,
+	tokenInDecisionsModel("perplexity/pplx-decider-v1.1-27b", "Perplexity Decider 1.1 27B", 262144, true),
+	tokenInDecisionsModel("openai/gpt-6-luna-decisions", "GPT-6 Luna Decisions", 1050000, true),
+];
+
+const COST_HEADER = "x-litellm-response-cost";
+const CACHE_HIT_HEADER = "x-litellm-cache-key";
+/** The request without its images: state and questions, as before. */
+const MAX_TEXT_BYTES = 64 * 1024;
+/** ponytail: 2 MiB of base64 in total, the most checked against the live gateway; raise once larger ones are measured. */
+export const MAX_IMAGE_BYTES = 2 * 1024 * 1024;
 
 function record(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function reportedCost(value: unknown): Usage["cost"] | undefined {
-	if (!record(value)) return undefined;
-	const { input, output, cacheRead, cacheWrite, total } = value;
-	const money = (n: unknown): n is number => typeof n === "number" && Number.isFinite(n) && n >= 0;
-	return money(input) && money(output) && money(cacheRead) && money(cacheWrite) && money(total)
-		? { input, output, cacheRead, cacheWrite, total } : undefined;
-}
 
 export interface ServicePricedClassifierResult extends ClassifierResult {
-	/** Counts without a monetary claim when billing data is absent/unrecognised. */
+	/** Token counts without a monetary claim: the catalog has no price for these calls. */
 	unpricedUsage?: Omit<Usage, "cost">;
-	/** Service-reported total when no per-component breakdown is supplied. */
+	/** What the gateway billed for the call; absent when it did not say. */
 	reportedCost?: number;
 }
 
-export const classifyTokenIn: typeof classifySystemOne = async (model, context, options) => {
-	let cost: Usage["cost"] | undefined;
-	let totalCost: number | undefined;
+function imagePart(image: ImageContent): unknown {
+	return { type: "image_url", image_url: { url: `data:${image.mimeType};base64,${image.data}` } };
+}
+
+/** The System One request upstream built, as the gateway's chat body, with any images added to its `state`. */
+function chatBody(payload: unknown, images: readonly ImageContent[]): unknown {
+	const wire = tokenInWirePayload(payload);
+	if (!record(wire) || typeof wire.model !== "string") throw new Error("TokenIn classifier requires a model");
+	if (!fitsClassifierRequest(wire, MAX_TEXT_BYTES)) throw new Error("TokenIn classifier payload exceeds 64 KiB");
+	if (images.reduce((total, image) => total + image.data.length, 0) > MAX_IMAGE_BYTES) {
+		throw new Error(`TokenIn classifier images exceed ${MAX_IMAGE_BYTES / 1024 / 1024} MiB`);
+	}
+	const { model, ...request } = wire;
+	const state = images.length > 0 ? [wire.state, ...images.map(imagePart)] : wire.state;
+	return { model, messages: [{ role: "user", content: JSON.stringify({ ...request, state }) }] };
+}
+
+/** The System One body a chat completion carries as its message content, or undefined. */
+function systemOneBody(completion: unknown): Record<string, unknown> | undefined {
+	const choices = record(completion) ? completion.choices : undefined;
+	const message = Array.isArray(choices) && record(choices[0]) ? choices[0].message : undefined;
+	const content = record(message) ? message.content : undefined;
+	if (typeof content !== "string") return undefined;
+	try {
+		const body: unknown = JSON.parse(content);
+		return record(body) ? body : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** The amount the account was charged for this response, or undefined when the gateway did not say. */
+function billedCost(headers: Headers): number | undefined {
+	if ((headers.get(CACHE_HIT_HEADER) ?? "").trim() !== "") return 0;
+	const reported = headers.get(COST_HEADER);
+	if (reported === null || reported.trim() === "") return undefined;
+	const cost = Number(reported);
+	return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
+}
+
+export const classifyTokenIn = async (
+	model: ClassifierModel<ClassifierApi>,
+	context: ClassifierContext,
+	options?: ClassifierOptions,
+): Promise<ServicePricedClassifierResult> => {
+	let billed: number | undefined;
 	let booleanConfidence: Record<string, number> = {};
 	let scoreLegend: Record<string, Record<string, string> | string[]> = {};
 	const requestFetch = options?.fetch ?? globalThis.fetch;
-	const result: ServicePricedClassifierResult = await classifySystemOne(model, context, {
+	// Upstream's System One client rejects images, so a model that reads them gets them through `state`
+	// instead. For a text-only model they stay in the context and upstream reports them as unsupported.
+	const images = model.input.includes("image") ? (context.images ?? []) : [];
+	const { images: _inState, ...textContext } = context;
+	const result: ServicePricedClassifierResult = await classifySystemOne(model, images.length > 0 ? textContext : context, {
 		...options,
 		onPayload: async (payload, requestModel) => {
 			const transformed = await options?.onPayload?.(payload, requestModel);
-			const wire = tokenInWirePayload(transformed === undefined ? payload : transformed);
-			if (!fitsClassifierRequest(wire, 64 * 1024)) throw new Error("TokenIn classifier payload exceeds 64 KiB");
-			return wire;
+			return chatBody(transformed === undefined ? payload : transformed, images);
 		},
 		fetch: async (input, init) => {
 			// Reset per attempt: a retry must not inherit pricing from another response.
-			cost = undefined;
-			totalCost = undefined;
+			billed = undefined;
 			booleanConfidence = {};
 			scoreLegend = {};
-			const response = await requestFetch(input, init);
-			if (response.ok) {
-				try {
-					const body: unknown = await response.clone().json();
-					if (record(body)) {
-						if (record(body.usage)) {
-							cost = reportedCost(body.usage.cost);
-							const total = body.usage.cost;
-							if (typeof total === "number" && Number.isFinite(total) && total >= 0) totalCost = total;
-						}
-						if (record(body.answers)) for (const [id, answer] of Object.entries(body.answers)) {
-							if (record(answer)) {
-								if (typeof answer.confidence === "number" && Number.isFinite(answer.confidence) && answer.confidence >= 0 && answer.confidence <= 1) booleanConfidence[id] = answer.confidence;
-								const legend = answer.legend;
-								if (Array.isArray(legend) && legend.every((value) => typeof value === "string")) scoreLegend[id] = legend;
-								else if (record(legend)) {
-									const labels: Record<string, string> = {};
-									for (const [key, label] of Object.entries(legend)) if (/^\d+$/.test(key) && typeof label === "string") labels[key] = label;
-									if (Object.keys(labels).length === Object.keys(legend).length) scoreLegend[id] = labels;
-								}
-							}
-						}
-					}
-				} catch { /* Upstream owns malformed-response diagnostics. */ }
+			const url = new URL(input instanceof Request ? input.url : String(input));
+			url.pathname = url.pathname.replace(/\/systemone$/u, "/chat/completions");
+			const response = await requestFetch(url, init);
+			if (!response.ok) return response;
+			billed = billedCost(response.headers);
+			// An unreadable envelope becomes an empty body: upstream reports the missing answers once,
+			// instead of this layer failing the attempt and having it retried (and billed) again.
+			const body = systemOneBody(await response.json().catch(() => undefined)) ?? {};
+			if (record(body.answers)) for (const [id, answer] of Object.entries(body.answers)) {
+				if (!record(answer)) continue;
+				if (typeof answer.confidence === "number" && Number.isFinite(answer.confidence) && answer.confidence >= 0 && answer.confidence <= 1) booleanConfidence[id] = answer.confidence;
+				const legend = answer.legend;
+				if (Array.isArray(legend) && legend.every((value) => typeof value === "string")) scoreLegend[id] = legend;
+				else if (record(legend)) {
+					const labels: Record<string, string> = {};
+					for (const [key, label] of Object.entries(legend)) if (/^\d+$/.test(key) && typeof label === "string") labels[key] = label;
+					if (Object.keys(labels).length === Object.keys(legend).length) scoreLegend[id] = labels;
+				}
 			}
-			return response;
+			return new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json" } });
 		},
 	});
 	for (const [id, confidence] of Object.entries(booleanConfidence)) {
 		const answer = result.answers[id];
 		if (answer?.type === "bool") {
-			const reported = { ...answer, confidence };
+			const reported = { ...answer, confidence }; // not a fresh literal: the public type has no `confidence`
 			result.answers[id] = reported;
 		}
 	}
@@ -92,14 +182,10 @@ export const classifyTokenIn: typeof classifySystemOne = async (model, context,
 		}
 	}
 	if (result.usage) {
-		if (cost) result.usage.cost = cost;
-		else {
-			const { cost: _catalogEstimate, ...counts } = result.usage;
-			result.unpricedUsage = counts;
-			delete result.usage;
-		}
+		const { cost: _catalogEstimate, ...counts } = result.usage;
+		result.unpricedUsage = counts;
+		delete result.usage;
 	}
-	if (totalCost !== undefined) result.reportedCost = totalCost;
-	else if (!result.usage && cost) result.reportedCost = cost.total;
+	if (billed !== undefined) result.reportedCost = billed;
 	return result;
 };

package/dist/extensions/jev/decisions.test.ts

@@ -130,6 +130,27 @@ describe("readJevAdvisoryConfig", () => {
 			minConfidence: 0.8,
 		});
 	});
+
+	it("asks the shared Jev model for tool search, on by default, unless the route names its own model", () => {
+		state.settingsPath = join(tmpdir(), "missing-settings.json");
+		const defaults = readJevAdvisoryConfig(state.settingsPath);
+		expect(defaults.routes.toolSearch).toMatchObject({ enabled: true });
+		expect(defaults.routes.toolSearch.model).toBeUndefined();
+		expect(jevConnection(defaults, defaults.routes.toolSearch)).toMatchObject({ provider: "tokenin", model: "jev-1.13" });
+
+		write({ jevAdvisory: { model: "jev-9", baseUrl: "https://custom/v1", routes: { toolSearch: { timeoutMs: 2_000 } } } });
+		const config = readJevAdvisoryConfig(state.settingsPath);
+		expect(jevConnection(config, config.routes.toolSearch)).toMatchObject({ model: "jev-9", baseUrl: "https://custom/v1", timeoutMs: 2_000 });
+
+		// A route with its own model never inherits the shared endpoint override.
+		write({ jevAdvisory: { baseUrl: "https://custom/v1", routes: { toolSearch: { model: "cloudflare/clef-flash" } } } });
+		const own = readJevAdvisoryConfig(state.settingsPath);
+		expect(jevConnection(own, own.routes.toolSearch)).toMatchObject({ provider: "tokenin", model: "cloudflare/clef-flash", baseUrl: undefined });
+
+		write({ jevAdvisory: { routes: { toolSearch: { model: "cloudflare/clef", provider: "other", enabled: false } } } });
+		const custom = readJevAdvisoryConfig(state.settingsPath).routes.toolSearch;
+		expect(custom).toMatchObject({ enabled: false, model: "cloudflare/clef", provider: "other" });
+	});
 });
 
 describe("buildJevPayload", () => {