openmerit 0.1.0 → 0.1.2

package/dist/daemon.js

@@ -9,15 +9,46 @@ import { loadKey } from "./llm.js";
 import { providerAllowed } from "./policy.js";
 import { buildRecommendation } from "./recommend.js";
 import { appendJsonl, paths, readJson, readJsonl, writeJson, } from "./store.js";
-import { ingestNewTraces } from "./traces.js";
-import { budgetOk, ensureRubric, recordTrialSpend, runTrial } from "./trials.js";
+import { budgetOk, ensureRubric, recordMeritSpend, recordTrialSpend, runTrial, trialBudgetOk } from "./trials.js";
 import { JUDGE_PREFS } from "./judge.js";
-import { availablePiModels, runPiTrial, scorePiRun, settledActiveTask } from "./pi-trials.js";
+import { runPiTrial, scorePiRun, settledActiveTask } from "./pi-trials.js";
 import { taskInputKey } from "./task-input.js";
 import { pickNext, STRAT_PREFS } from "./strategist.js";
+import { enrichRouteEntry, routeCatalog, routeKey, routeLabel } from "./routes.js";
+import { PiCliChatClient } from "./llm.js";
+import { LocalJsonlEventSink, PiTraceObservationSource, meritEvent } from "./integrations.js";
+function resolveRoutePref(cat, prefs, label, requireImages = false) {
+    const available = [...cat.values()].filter((entry) => !!entry.route && entry.priceKnown !== false &&
+        (!requireImages || entry.inputModalities?.includes("image")));
+    for (const pref of prefs) {
+        if (!pref)
+            continue;
+        const routed = cat.get(pref);
+        if (routed && available.includes(routed))
+            return routed;
+        const exact = available.find((entry) => entry.id === pref);
+        if (exact)
+            return exact;
+    }
+    for (const pref of prefs) {
+        if (!pref)
+            continue;
+        const fuzzy = available.find((entry) => entry.id.includes(pref));
+        if (fuzzy)
+            return fuzzy;
+    }
+    const fallback = available.sort((a, b) => (a.priceKnown === false ? 1 : 0) - (b.priceKnown === false ? 1 : 0) || a.price - b.price)[0];
+    if (fallback)
+        return fallback;
+    throw new Error(`could not resolve ${label} route from Pi's eligible models`);
+}
 function emitTrialProgress(progress) {
     console.log(`[openmerit/progress] ${JSON.stringify(progress)}`);
 }
+function persistTrial(point, sink) {
+    appendJsonl(paths.trials(), point);
+    sink.emit(meritEvent("trial.completed", point));
+}
 function resolvePref(cat, prefs, label) {
     for (const p of prefs) {
         if (p && cat.has(p))
@@ -34,10 +65,12 @@ function resolvePref(cat, prefs, label) {
     throw new Error(`could not resolve ${label} model from preferences`);
 }
 /** Ingest new session-trace bytes into the observation log. */
-export function tracesTick() {
-    const fresh = ingestNewTraces();
-    for (const o of fresh)
+export function tracesTick(source = new PiTraceObservationSource(), sink = new LocalJsonlEventSink()) {
+    const fresh = source.read();
+    for (const o of fresh) {
         appendJsonl(paths.observations(), o);
+        sink.emit(meritEvent("observation.recorded", o, source.id));
+    }
     if (fresh.length > 0)
         console.log(`[openmerit] traces: ${fresh.length} new observation(s)`);
     return fresh;
@@ -68,6 +101,7 @@ export async function catalogTick(key, policy) {
  * thin). Budget-capped per policy.
  */
 export async function trialTick(key, policy) {
+    const sink = new LocalJsonlEventSink();
     const budget = budgetOk(policy);
     if (!budget.ok) {
         console.log(`[openmerit] trials paused: ${budget.reason}`);
@@ -106,7 +140,7 @@ export async function trialTick(key, policy) {
         const rubric = await ensureRubric(key, judge, obs.taskLabel, rubricCache);
         const { point, costUsd, error } = await runTrial(key, judge, obs.taskLabel, rubric, candidate.id, cat.get(candidate.id));
         recordTrialSpend(costUsd);
-        appendJsonl(paths.trials(), { ...point, taskKey: tKey });
+        persistTrial({ ...point, taskKey: tKey }, sink);
         if (error)
             console.log(`[openmerit] trial failed: ${error.slice(0, 120)}`);
         else
@@ -115,6 +149,7 @@ export async function trialTick(key, policy) {
 }
 /** Compare the one completed active pi task, sequentially, then target its session. */
 export async function autoTaskTick(key, policy, settledTask) {
+    const sink = new LocalJsonlEventSink();
     const task = settledTask === undefined ? settledActiveTask() : settledTask;
     if (!task)
         return null;
@@ -130,70 +165,94 @@ export async function autoTaskTick(key, policy, settledTask) {
     // Claim the settled turn before provider calls so the next poll cannot duplicate it.
     writeJson(processedPath, { marker, status: "running", updatedAt: new Date().toISOString() });
     try {
-        const cat = await fetchCatalog(key);
-        const piModels = availablePiModels();
-        for (const id of [...cat.keys()]) {
-            const e = cat.get(id);
-            if (!piModels.has(id) || e.price > policy.max_usd_per_m || !providerAllowed(policy, id) ||
-                (task.images.length > 0 && !e.inputModalities?.includes("image")))
+        let cat = routeCatalog(task.routes);
+        if (!cat.has(routeKey(task.route)))
+            cat.set(routeKey(task.route), routeCatalog([task.route]).values().next().value);
+        if (key) {
+            try {
+                const live = await fetchCatalog(key);
+                saveSnapshot(live);
+                cat = new Map([...cat].map(([id, entry]) => [id,
+                    entry.route?.provider === "openrouter" ? enrichRouteEntry(entry, live.get(entry.id)) : entry]));
+            }
+            catch (error) {
+                console.log(`[openmerit] OpenRouter enrichment unavailable: ${error.message}`);
+            }
+        }
+        for (const [id, entry] of [...cat]) {
+            if ((entry.priceKnown !== false && entry.price > policy.max_usd_per_m) ||
+                !providerAllowed(policy, entry.id, entry.route?.provider) ||
+                (task.images.length > 0 && !entry.inputModalities?.includes("image")) ||
+                (id !== routeKey(task.route) && !trialBudgetOk(policy, entry, task.task.length).ok))
                 cat.delete(id);
         }
-        if (!cat.has(task.model))
-            throw new Error(`active model ${task.model} is not trialable in pi/OpenRouter`);
-        const judge = resolvePref(cat, [policy.judge_model, ...JUDGE_PREFS], "judge");
-        const strategist = resolvePref(cat, [policy.strategist_model, ...STRAT_PREFS], "strategist");
+        const activeEntry = cat.get(routeKey(task.route));
+        if (!activeEntry)
+            throw new Error(`active route ${task.route.provider}/${task.route.modelId} is excluded by policy or task capabilities`);
+        if (cat.size < 2)
+            throw new Error("Pi exposes no eligible alternate model route for this task");
+        const judge = resolveRoutePref(cat, [policy.judge_model, ...JUDGE_PREFS, task.model], "judge", task.images.length > 0);
+        const strategist = resolveRoutePref(cat, [policy.strategist_model, ...STRAT_PREFS, task.model], "strategist");
+        const client = new PiCliChatClient(undefined, recordMeritSpend);
         const { category, benchmarks } = relevantBenchmarks(task.task);
         let benchmarkCandidates = [];
         try {
-            benchmarkCandidates = await openRouterBenchmarkCandidates(key, category, cat);
+            if (key)
+                benchmarkCandidates = await openRouterBenchmarkCandidates(key, category, new Map([...cat.values()].map((entry) => [entry.id, entry])));
         }
         catch (e) {
             console.log(`[openmerit] benchmark shortlist unavailable: ${e.message}`);
         }
-        const rubric = await ensureRubric(key, judge, task.task, new Map());
-        const tKey = taskInputKey(task.task, task.images);
+        const rubric = await ensureRubric(key ?? "", judge.route, task.task, new Map(), client);
+        const tKey = taskInputKey(task.task, task.images, task.files);
         const points = [];
         const tried = new Set();
         const failedVendors = new Set();
         const total = Math.max(1, Math.floor(policy.watch.models_per_task));
         if (settledTask !== undefined)
             emitTrialProgress({ phase: "start", taskKey: tKey,
-                model: task.model, index: 1, total });
-        const baseline = await scorePiRun(key, judge, task.task, rubric, task.model, cat.get(task.model), task.run, "trace", task.images);
+                model: routeLabel(task.route), index: 1, total });
+        const baseline = await scorePiRun(key ?? "", judge.route, task.task, rubric, task.model, activeEntry, task.run, "trace", task.images, client);
         points.push(baseline.point);
-        tried.add(task.model);
-        appendJsonl(paths.trials(), { ...baseline.point, taskKey: tKey, sessionFile: task.sessionFile });
+        tried.add(routeKey(task.route));
+        persistTrial({ ...baseline.point, taskKey: tKey, sessionFile: task.sessionFile }, sink);
         console.log(`[openmerit] task ${tKey}: A=${task.model} score=${baseline.point.score.toFixed(2)} from pi trace`);
         if (settledTask !== undefined)
             emitTrialProgress({ phase: "complete", taskKey: tKey,
-                model: task.model, index: 1, total, score: baseline.point.score,
+                model: routeLabel(task.route), index: 1, total, score: baseline.point.score,
                 price: baseline.point.price, latencyMs: baseline.point.latencyMs,
-                costUsd: baseline.costUsd });
+                costUsd: baseline.costUsd, toolCalls: baseline.point.toolCalls,
+                toolErrors: baseline.point.toolErrors, changedFiles: baseline.point.changedFiles });
         for (let i = 1; i < total; i++) {
             if (!budgetOk(policy).ok)
                 break;
-            const pick = await pickNext(key, strategist, task.task, rubric, benchmarks, points, cat, tried, policy.max_usd_per_m, failedVendors, benchmarkCandidates);
+            const pick = await pickNext(key ?? "", strategist.route, task.task, rubric, benchmarks, points, cat, tried, policy.max_usd_per_m, failedVendors, benchmarkCandidates, client);
             if (!pick)
                 break;
             if (settledTask !== undefined)
                 emitTrialProgress({ phase: "start", taskKey: tKey,
-                    model: pick.model, index: i + 1, total });
-            const { point, costUsd, error } = await runPiTrial(key, judge, task.task, rubric, pick.model, cat.get(pick.model), task.cwd, task.images);
-            tried.add(pick.model);
+                    model: pick.route ? routeLabel(pick.route) : pick.model, index: i + 1, total });
+            const entry = pick.route ? cat.get(routeKey(pick.route)) : cat.get(pick.model);
+            const { point, costUsd, error } = await runPiTrial(key ?? "", judge.route, task.task, rubric, pick.model, entry, task.cwd, task.images, task.files, undefined, client);
+            tried.add(pick.route ? routeKey(pick.route) : pick.model);
             points.push(point);
             recordTrialSpend(costUsd);
-            appendJsonl(paths.trials(), { ...point, taskKey: tKey, sessionFile: task.sessionFile });
+            persistTrial({ ...point, taskKey: tKey, sessionFile: task.sessionFile }, sink);
             if (error)
-                failedVendors.add(pick.model.split("/")[0]);
-            console.log(`[openmerit] task ${tKey}: ${pick.model} score=${point.score.toFixed(2)} cost=$${costUsd.toFixed(4)}${error ? ` error=${error.slice(0, 80)}` : ""}`);
+                failedVendors.add(pick.route?.provider ?? pick.model.split("/")[0]);
+            console.log(`[openmerit] task ${tKey}: ${pick.model} score=${point.score.toFixed(2)} cost=$${costUsd.toFixed(4)} ` +
+                `tools=${point.toolCalls ?? 0} toolErrors=${point.toolErrors ?? 0} changedFiles=${point.changedFiles ?? 0}` +
+                `${error ? ` error=${error.slice(0, 80)}` : ""}`);
             if (settledTask !== undefined)
                 emitTrialProgress({ phase: "complete", taskKey: tKey,
-                    model: pick.model, index: i + 1, total, score: point.score, price: point.price,
-                    latencyMs: point.latencyMs, costUsd, error: error?.slice(0, 120) });
+                    model: pick.route ? routeLabel(pick.route) : pick.model, index: i + 1, total, score: point.score, price: point.price,
+                    latencyMs: point.latencyMs, costUsd, error: error?.slice(0, 120),
+                    toolCalls: point.toolCalls, toolErrors: point.toolErrors, changedFiles: point.changedFiles });
         }
-        const rec = buildRecommendation(tKey, task.task.slice(0, 120), task.model, points, policy, task.sessionFile);
+        const rec = buildRecommendation(tKey, task.task.slice(0, 120), task.model, points, policy, task.sessionFile, task.route);
         if (rec) {
             appendJsonl(paths.recommendations(), rec);
+            sink.emit(meritEvent("recommendation.created", rec));
             console.log(`[openmerit] task ${tKey}: selected ${rec.recommended.model}; auto=${rec.policy.autoApply}`);
         }
         else
@@ -210,8 +269,10 @@ export async function autoTaskTick(key, policy, settledTask) {
 }
 /** Rebuild frontiers from trials and emit recommendations for the harness's current model. */
 export function recommendTick(policy) {
+    const sink = new LocalJsonlEventSink();
     const harness = readJson(paths.harnessState(), {});
     const currentModel = harness.currentModel ?? null;
+    const currentRoute = harness.currentRoute ?? null;
     const trials = readJsonl(paths.trials());
     const observations = readJsonl(paths.observations());
     const labelByTask = new Map();
@@ -233,16 +294,17 @@ export function recommendTick(policy) {
         latestById.set(r.id, r);
     const existing = new Set([...latestById.values()]
         .filter((r) => r.status === "pending" || r.status === "dismissed")
-        .map((r) => `${r.taskKey}:${r.recommended.model}`));
+        .map((r) => `${r.taskKey}:${r.recommended.route ? routeKey(r.recommended.route) : `openrouter:${r.recommended.model}`}`));
     const emitted = [];
     for (const [tKey, points] of byTask) {
-        const rec = buildRecommendation(tKey, labelByTask.get(tKey) ?? tKey, currentModel, points, policy);
+        const rec = buildRecommendation(tKey, labelByTask.get(tKey) ?? tKey, currentModel, points, policy, null, currentRoute);
         if (!rec)
             continue;
-        const dedupeKey = `${rec.taskKey}:${rec.recommended.model}`;
+        const dedupeKey = `${rec.taskKey}:${rec.recommended.route ? routeKey(rec.recommended.route) : `openrouter:${rec.recommended.model}`}`;
         if (existing.has(dedupeKey))
             continue;
         appendJsonl(paths.recommendations(), rec);
+        sink.emit(meritEvent("recommendation.created", rec));
         emitted.push(rec);
         console.log(`[openmerit] recommendation: ${rec.recommended.model} <- ${currentModel ?? "unknown"} ` +
             `(gain ${rec.evidence.scoreGain}, auto=${rec.policy.autoApply})`);
@@ -257,12 +319,12 @@ export async function tickOnce(policy) {
         key = loadKey();
     }
     catch (e) {
-        console.log(`[openmerit] ${e.message}; skipping provider ticks`);
+        console.log(`[openmerit] ${e.message}; OpenRouter enrichment disabled`);
     }
     if (key) {
         await catalogTick(key, policy);
-        await autoTaskTick(key, policy);
     }
+    await autoTaskTick(key, policy);
 }
 /** Run forever, honoring policy watch intervals. */
 export async function runDaemon(policy) {
@@ -287,17 +349,15 @@ export async function runDaemon(policy) {
             catch {
                 /* no key; skip provider ticks */
             }
-            if (key) {
-                try {
-                    if (wantCatalog) {
-                        await catalogTick(key, policy);
-                        lastCatalog = now;
-                    }
-                    await autoTaskTick(key, policy);
-                }
-                catch (e) {
-                    console.log(`[openmerit] provider tick failed: ${e.message}`);
+            try {
+                if (key && wantCatalog) {
+                    await catalogTick(key, policy);
+                    lastCatalog = now;
                 }
+                await autoTaskTick(key, policy);
+            }
+            catch (e) {
+                console.log(`[openmerit] provider tick failed: ${e.message}`);
             }
         }
         await new Promise((r) => setTimeout(r, tracesMs));

package/dist/frontier.js

@@ -1,10 +1,16 @@
 /** Pareto frontier over (score up, price down, latency down) + best-fit/fallback picks. */
+import { pointKey } from "./routes.js";
+function effectivePrice(point) {
+    return point.priceKnown === false ? Number.POSITIVE_INFINITY : point.price;
+}
 /** a dominates b if a is no worse on every objective and strictly better on one. */
 export function dominates(a, b) {
     const aLat = a.latencyMs ?? Number.POSITIVE_INFINITY;
     const bLat = b.latencyMs ?? Number.POSITIVE_INFINITY;
-    const noWorse = a.score >= b.score && a.price <= b.price && aLat <= bLat;
-    const better = a.score > b.score || a.price < b.price || aLat < bLat;
+    const aPrice = effectivePrice(a);
+    const bPrice = effectivePrice(b);
+    const noWorse = a.score >= b.score && aPrice <= bPrice && aLat <= bLat;
+    const better = a.score > b.score || aPrice < bPrice || aLat < bLat;
     return noWorse && better;
 }
 /**
@@ -14,11 +20,11 @@ export function dominates(a, b) {
  */
 export function paretoFrontier(points) {
     const fr = points.filter((p) => !points.some((q) => q !== p && dominates(q, p)));
-    return fr.sort((a, b) => a.price - b.price || b.score - a.score);
+    return fr.sort((a, b) => effectivePrice(a) - effectivePrice(b) || b.score - a.score);
 }
 /** Simple 2-objective chain (score vs price only), cheapest first. */
 export function scorePriceChain(points) {
-    const pts = [...points].sort((a, b) => a.price - b.price || b.score - a.score);
+    const pts = [...points].sort((a, b) => effectivePrice(a) - effectivePrice(b) || b.score - a.score);
     const chain = [];
     let best = -1;
     for (const p of pts) {
@@ -31,7 +37,8 @@ export function scorePriceChain(points) {
 }
 /** Highest score; ties broken by lower price then lower latency. */
 export function pickBest(points) {
-    return [...points].sort((a, b) => b.score - a.score || a.price - b.price || (a.latencyMs ?? 1e18) - (b.latencyMs ?? 1e18))[0];
+    return [...points].sort((a, b) => b.score - a.score || effectivePrice(a) - effectivePrice(b) ||
+        (a.latencyMs ?? 1e18) - (b.latencyMs ?? 1e18))[0];
 }
 /**
  * Fallback for `best`: prefer the cheapest frontier point that still clears
@@ -39,7 +46,7 @@ export function pickBest(points) {
  * `best` itself.
  */
 export function pickFallback(points, best, minScore) {
-    const others = points.filter((p) => p.model !== best.model);
+    const others = points.filter((p) => pointKey(p) !== pointKey(best));
     if (others.length === 0)
         return undefined;
     const fr = paretoFrontier(others).filter((p) => p.score >= minScore);

package/dist/harness.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations.js

@@ -0,0 +1,19 @@
+/** Stable boundaries for trace inputs and telemetry outputs. */
+import { randomUUID } from "node:crypto";
+import { appendJsonl, paths } from "./store.js";
+import { ingestNewTraces } from "./traces.js";
+export class PiTraceObservationSource {
+    sessionsDir;
+    id = "pi-jsonl";
+    constructor(sessionsDir) {
+        this.sessionsDir = sessionsDir;
+    }
+    read() { return ingestNewTraces(this.sessionsDir); }
+}
+export class LocalJsonlEventSink {
+    id = "local-jsonl";
+    emit(event) { appendJsonl(paths.events(), event); }
+}
+export function meritEvent(type, payload, source = "openmerit") {
+    return { schemaVersion: 1, id: randomUUID(), ts: new Date().toISOString(), source, type, payload };
+}

package/dist/judge.js

@@ -1,5 +1,5 @@
 /** Judge: score a model's answer against a rubric. */
-import { chat, chatWithImages } from "./llm.js";
+import { directChatClient } from "./llm.js";
 export const JUDGE_PREFS = ["openai/gpt-4o-mini", "openai/gpt-4o"];
 const JUDGE_PROMPT = `You are grading a model's answer.
 TASK: {task}
@@ -13,8 +13,8 @@ export function parseObj(txt) {
         throw new Error("no json object found");
     return JSON.parse(m[0]);
 }
-export async function judge(key, judgeModel, task, rubric, answer) {
-    const { content } = await chat(key, judgeModel, JUDGE_PROMPT.replace("{task}", task)
+export async function judge(key, judgeModel, task, rubric, answer, client = directChatClient(key)) {
+    const { content } = await client.chat(judgeModel, JUDGE_PROMPT.replace("{task}", task)
         .replace("{rubric}", rubric)
         .replace("{answer}", answer.slice(0, 16000)), 1024, 0);
     try {
@@ -26,13 +26,13 @@ export async function judge(key, judgeModel, task, rubric, answer) {
     }
 }
 /** Grade OCR answers against the actual uploaded pixels, not answer text alone. */
-export async function judgeWithImages(key, judgeModel, task, rubric, answer, images) {
+export async function judgeWithImages(key, judgeModel, task, rubric, answer, images, client = directChatClient(key)) {
     const prompt = `You are grading an answer to a visual task. Inspect the attached image carefully.\n` +
         `TASK: ${task}\nRUBRIC: ${rubric}\nANSWER: ${answer.slice(0, 16000)}\n` +
         `For invoice extraction, check every visible field and line item against the image. ` +
         `Penalize missing, invented, or mistyped values and invalid JSON. ` +
         `Return ONLY json: {"score": <0..1>, "why": "<one line>"}`;
-    const { content } = await chatWithImages(key, judgeModel, prompt, images, 1024);
+    const { content } = await client.chatWithImages(judgeModel, prompt, images, 1024);
     try {
         const j = parseObj(content);
         return { score: Number(j.score ?? 0), why: String(j.why ?? "") };

package/dist/llm.js

@@ -1,6 +1,10 @@
-/** Minimal OpenRouter chat client for catalog and trial requests. */
-import { existsSync, readFileSync } from "node:fs";
+/** Minimal provider clients for judge and strategist requests. */
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { paths } from "./store.js";
+import { legacyOpenRouterRoute } from "./routes.js";
 const OR = "https://openrouter.ai/api/v1";
 /** Load OPENROUTER_API_KEY from env or ~/.openmerit/.env. */
 export function loadKey() {
@@ -20,9 +24,9 @@ export function loadKey() {
         throw new Error("missing OPENROUTER_API_KEY (env or ~/.openmerit/.env)");
     return key;
 }
-async function request(key, path, body, tries = 3) {
+async function request(key, path, body, baseUrl = OR, tries = 3) {
     for (let attempt = 0; attempt < tries; attempt++) {
-        const res = await fetch(OR + path, {
+        const res = await fetch(baseUrl + path, {
             method: body === undefined ? "GET" : "POST",
             headers: {
                 Authorization: `Bearer ${key}`,
@@ -41,26 +45,159 @@ async function request(key, path, body, tries = 3) {
     }
     throw new Error("unreachable");
 }
+class OpenAICompatibleProvider {
+    id;
+    baseUrl;
+    key;
+    constructor(id, baseUrl, key) {
+        this.id = id;
+        this.baseUrl = baseUrl;
+        this.key = key;
+    }
+    model(model) { return this.id === "openrouter" ? model : model.split("/", 2).at(-1) ?? model; }
+    async chat(model, prompt, maxTokens, temperature) {
+        const r = await request(this.key, "/chat/completions", { model: this.model(model), messages: [{ role: "user", content: prompt }], max_tokens: maxTokens, temperature }, this.baseUrl);
+        return { content: r.choices[0]?.message?.content ?? "", usage: r.usage ?? {} };
+    }
+    async chatWithImages(model, prompt, images, maxTokens) {
+        const content = [{ type: "text", text: prompt }, ...images.map((image) => ({ type: "image_url", image_url: { url: `data:${image.mimeType};base64,${image.data}` } }))];
+        const r = await request(this.key, "/chat/completions", { model: this.model(model), messages: [{ role: "user", content }], max_tokens: maxTokens, temperature: 0 }, this.baseUrl);
+        return { content: r.choices[0]?.message?.content ?? "", usage: r.usage ?? {} };
+    }
+}
+class GeminiProvider {
+    key;
+    id = "google";
+    constructor(key) {
+        this.key = key;
+    }
+    async call(model, prompt, images = [], maxTokens) {
+        const name = model.split("/", 2).at(-1) ?? model;
+        const parts = [{ text: prompt }, ...images.map((image) => ({ inline_data: { mime_type: image.mimeType, data: image.data } }))];
+        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(name)}:generateContent?key=${encodeURIComponent(this.key)}`, {
+            method: "POST", headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ contents: [{ role: "user", parts }], generationConfig: { maxOutputTokens: maxTokens, temperature: images.length ? 0 : undefined } }),
+        });
+        if (!res.ok)
+            throw new Error(`Google Gemini HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
+        const raw = await res.json();
+        return { content: raw.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("") ?? "", usage: { prompt_tokens: raw.usageMetadata?.promptTokenCount, completion_tokens: raw.usageMetadata?.candidatesTokenCount, total_tokens: raw.usageMetadata?.totalTokenCount } };
+    }
+    chat(model, prompt, maxTokens) { return this.call(model, prompt, [], maxTokens); }
+    chatWithImages(model, prompt, images, maxTokens) { return this.call(model, prompt, images, maxTokens); }
+}
+export function providerFor(model, fallbackKey) {
+    const id = model.split("/", 1)[0] || "openrouter";
+    // OpenRouter model IDs are vendor/model (for example openai/gpt-4o-mini).
+    // Direct providers require an explicit opt-in to avoid routing those IDs
+    // away from OpenRouter when users have multiple credentials configured.
+    if (id === "openai" && process.env.OPENMERIT_DIRECT_PROVIDER === "openai" && process.env.OPENAI_API_KEY)
+        return new OpenAICompatibleProvider(id, "https://api.openai.com/v1", process.env.OPENAI_API_KEY);
+    if (id === "google" && process.env.OPENMERIT_DIRECT_PROVIDER === "google" && process.env.GEMINI_API_KEY)
+        return new GeminiProvider(process.env.GEMINI_API_KEY);
+    return new OpenAICompatibleProvider("openrouter", OR, fallbackKey);
+}
 export async function chat(key, model, prompt, maxTokens, temperature) {
-    const r = await request(key, "/chat/completions", {
-        model,
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: maxTokens,
-        temperature,
-    });
-    return { content: r.choices[0]?.message?.content ?? "", usage: r.usage ?? {} };
+    return providerFor(model, key).chat(model, prompt, maxTokens, temperature);
 }
 /** Send a visual grading request through the same OpenRouter account. */
 export async function chatWithImages(key, model, prompt, images, maxTokens) {
-    const r = await request(key, "/chat/completions", {
-        model,
-        messages: [{ role: "user", content: [
-                    { type: "text", text: prompt },
-                    ...images.map((image) => ({ type: "image_url",
-                        image_url: { url: `data:${image.mimeType};base64,${image.data}` } })),
-                ] }],
-        max_tokens: maxTokens,
-        temperature: 0,
-    });
-    return { content: r.choices[0]?.message?.content ?? "", usage: r.usage ?? {} };
+    return providerFor(model, key).chatWithImages(model, prompt, images, maxTokens);
+}
+export function directChatClient(key) {
+    const id = (model) => typeof model === "string" ? model : model.meritId;
+    return {
+        chat: (model, prompt, maxTokens, temperature) => chat(key, id(model), prompt, maxTokens, temperature),
+        chatWithImages: (model, prompt, images, maxTokens) => chatWithImages(key, id(model), prompt, images, maxTokens),
+    };
+}
+function textContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.filter((part) => !!part && typeof part === "object" && part.type === "text")
+        .map((part) => part.text ?? "").join("\n");
+}
+/** Use pi's model registry and credential store without exposing provider secrets to OpenMerit. */
+export class PiCliChatClient {
+    executable;
+    onSpend;
+    id = "pi-cli";
+    constructor(executable = process.env.OPENMERIT_PI_BIN?.trim() || "pi", onSpend) {
+        this.executable = executable;
+        this.onSpend = onSpend;
+    }
+    chat(model, prompt, _maxTokens, _temperature) {
+        return this.run(model, prompt, []);
+    }
+    chatWithImages(model, prompt, images, _maxTokens) {
+        return this.run(model, prompt, images);
+    }
+    async run(target, prompt, images) {
+        const route = typeof target === "string" ? legacyOpenRouterRoute(target) : target;
+        const dir = mkdtempSync(join(tmpdir(), "openmerit-pi-chat-"));
+        try {
+            const imageArgs = images.map((image, index) => {
+                const suffix = { "image/jpeg": "jpg", "image/png": "png", "image/webp": "webp", "image/gif": "gif" }[image.mimeType];
+                if (!suffix)
+                    throw new Error(`unsupported pi image: ${image.mimeType}`);
+                const file = join(dir, `image-${index}.${suffix}`);
+                writeFileSync(file, Buffer.from(image.data, "base64"));
+                return `@${file}`;
+            });
+            const child = spawn(this.executable, [
+                "--provider", route.provider, "--model", route.modelId, "--mode", "json", "--offline",
+                "--no-extensions", "--no-tools", "--print", ...imageArgs, prompt,
+            ], { cwd: dir, stdio: ["ignore", "pipe", "pipe"] });
+            let stdout = "";
+            let stderr = "";
+            child.stdout.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
+            child.stderr.on("data", (chunk) => { stderr += chunk.toString("utf8"); });
+            const code = await new Promise((resolve, reject) => {
+                child.on("error", reject);
+                child.on("close", (value) => resolve(value ?? 1));
+            });
+            let answer = "";
+            let promptTokens = 0;
+            let completionTokens = 0;
+            let totalTokens = 0;
+            let costUsd = 0;
+            let failed = false;
+            for (const line of stdout.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (event.type !== "message_end" || event.message?.role !== "assistant")
+                    continue;
+                answer = textContent(event.message.content) || answer;
+                promptTokens += event.message.usage?.input ?? 0;
+                completionTokens += event.message.usage?.output ?? 0;
+                totalTokens += event.message.usage?.totalTokens ?? 0;
+                costUsd += event.message.usage?.cost?.total ?? 0;
+                if (event.message.stopReason === "error")
+                    failed = true;
+            }
+            if (code !== 0 || failed || !answer.trim()) {
+                throw new Error(`pi model call ${route.provider}/${route.modelId} failed: ` +
+                    (stderr.trim().slice(0, 240) || `exit ${code}, empty answer`));
+            }
+            this.onSpend?.(costUsd);
+            return { content: answer, usage: {
+                    prompt_tokens: promptTokens || undefined,
+                    completion_tokens: completionTokens || undefined,
+                    total_tokens: totalTokens || promptTokens + completionTokens || undefined,
+                    costUsd,
+                } };
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
 }