@gafj/gafj 0.1.8 → 0.1.11

package/bridge/byo_key.js

@@ -33,18 +33,48 @@ async function testProvider(homeDir, id, fetchImpl) {
   }
 }
 
+/** The provider's live model list and the id the rule would pick; the stored choice, if any, is echoed so the form can show it. */
+async function listModels(homeDir, id, fetchImpl) {
+  const p = providerById(homeDir, id);
+  const adapter = providers.adapterFor(p.kind);
+  try {
+    const models = await adapter.listModels({ provider: p, fetch: fetchImpl });
+    return { ok: true, models, suggested: providers.pickDefault(models.map((m) => m.id)), chosen: p.model || null };
+  } catch (e) {
+    return { ok: false, message: scrub(e.message, p.api_key), models: [], suggested: null, chosen: p.model || null };
+  }
+}
+
 /** Run one packet through the provider; returns what ingest needs plus attempt metadata. */
+const autoCache = new Map(); // provider id -> { model, at }
+async function autoModel(p, fetchImpl) {
+  const hit = autoCache.get(p.id);
+  if (hit && Date.now() - hit.at < 3600 * 1000) return hit.model;
+  try {
+    const models = await providers.adapterFor(p.kind).listModels({ provider: p, fetch: fetchImpl });
+    const model = providers.pickDefault(models.map((m) => m.id));
+    if (model) { autoCache.set(p.id, { model, at: Date.now() }); return model; }
+  } catch (_) { /* the adapter's own default stands */ }
+  return null;
+}
+
+/** Reasoning depth per operation: quoting and classifying need little; the writing operations keep the provider's default. */
+const EFFORT = { extract: "low", categories: "low", discover: "medium" };
+const MAX_OUT = { extract: 32000, discover: 12000 };
+
 async function runPacket(homeDir, id, { packet, fetchImpl }) {
-  const p = providerById(homeDir, id);
+  const stored = providerById(homeDir, id);
+  const p = stored.model ? stored : { ...stored, model: (await autoModel(stored, fetchImpl)) || "" };
   const adapter = providers.adapterFor(p.kind);
   const { renderPasteText } = require("./paste");
   const started = Date.now();
   try {
-    const r = await adapter.complete({ provider: p, system: "You are a careful writing engine. Reply with exactly one fenced json block matching OUTPUT SCHEMA and nothing else.", user: renderPasteText(packet), max_tokens: 16000, fetch: fetchImpl });
+    const op = packet.operation || packet.op;
+    const r = await adapter.complete({ provider: p, system: "You are a careful writing engine. Reply with exactly one fenced json block matching OUTPUT SCHEMA and nothing else.", user: renderPasteText(packet), max_tokens: MAX_OUT[op] || 16000, effort: EFFORT[op], fetch: fetchImpl });
     return { content: r.text, provider: p.kind, model: r.model || p.model, tokens_in: r.tokens_in, tokens_out: r.tokens_out, latency_ms: Date.now() - started, stop_reason: r.stop_reason || null };
   } catch (e) {
     throw Object.assign(new Error(scrub(e.message, p.api_key)), { status: 502 });
   }
 }
 
-module.exports = { testProvider, runPacket, providerById };
+module.exports = { testProvider, runPacket, listModels, providerById };

package/bridge/providers/anthropic.js

@@ -1,16 +1,32 @@
 "use strict";
 
 const DEFAULT_URL = "https://api.anthropic.com";
-const DEFAULT_MODEL = "claude-fable-5-1";
+const DEFAULT_MODEL = "claude-sonnet-5";
 
-async function complete({ provider, system, user, max_tokens = 4000, fetch }) {
+/**
+ * Claude 5 models reason before they answer, and that reasoning is billed and counted against
+ * max_tokens (on Fable it cannot be switched off). A quoting job does not need it, so the caller
+ * passes effort ("low" for extraction) and it goes out as output_config.effort; the thinking
+ * parameter itself is never sent, which is the setting every current model accepts.
+ */
+async function complete({ provider, system, user, max_tokens = 4000, effort, fetch }) {
   const { post } = require("./index");
   const base = (provider.base_url || DEFAULT_URL).replace(/\/$/, "");
   const model = provider.model || DEFAULT_MODEL;
-  const data = await post(fetch, `${base}/v1/messages`, { "x-api-key": provider.api_key || "", "anthropic-version": "2023-06-01" },
-    { model, max_tokens, system, messages: [{ role: "user", content: user }] });
+  const body = { model, max_tokens, system, messages: [{ role: "user", content: user }] };
+  if (effort) body.output_config = { effort };
+  const data = await post(fetch, `${base}/v1/messages`, { "x-api-key": provider.api_key || "", "anthropic-version": "2023-06-01" }, body);
+  if (data.stop_reason === "refusal") throw new Error(`the model declined this request${data.stop_details && data.stop_details.category ? ` (${data.stop_details.category})` : ""}`);
   const text = (data.content || []).filter((c) => c.type === "text").map((c) => c.text).join("\n");
   return { text, model: data.model || model, tokens_in: data.usage && data.usage.input_tokens, tokens_out: data.usage && data.usage.output_tokens, stop_reason: data.stop_reason || null };
 }
 
-module.exports = { complete, DEFAULT_URL, DEFAULT_MODEL };
+/** The live model list, newest first as the API orders it; ids only. */
+async function listModels({ provider, fetch }) {
+  const { get } = require("./index");
+  const base = (provider.base_url || DEFAULT_URL).replace(/\/$/, "");
+  const data = await get(fetch, `${base}/v1/models?limit=100`, { "x-api-key": provider.api_key || "", "anthropic-version": "2023-06-01" });
+  return (data.data || []).map((m) => ({ id: m.id, name: m.display_name || m.id, created: m.created_at || null }));
+}
+
+module.exports = { complete, listModels, DEFAULT_URL, DEFAULT_MODEL };

package/bridge/providers/gemini.js

@@ -12,4 +12,12 @@ async function complete({ provider, system, user, max_tokens = 4000, fetch }) {
   return { text, model, tokens_in: data.usageMetadata && data.usageMetadata.promptTokenCount, tokens_out: data.usageMetadata && data.usageMetadata.candidatesTokenCount };
 }
 
-module.exports = { complete, DEFAULT_URL };
+async function listModels({ provider, fetch }) {
+  const { get } = require("./index");
+  const base = (provider.base_url || DEFAULT_URL).replace(/\/$/, "");
+  const data = await get(fetch, `${base}/models?pageSize=100`, { "x-goog-api-key": provider.api_key || "" });
+  return (data.models || []).filter((m) => (m.supportedGenerationMethods || []).includes("generateContent"))
+    .map((m) => ({ id: String(m.name || "").replace(/^models\//, ""), name: m.displayName || m.name, created: null }));
+}
+
+module.exports = { complete, listModels, DEFAULT_URL };

package/bridge/providers/index.js

@@ -37,4 +37,30 @@ async function post(fetchImpl, url, headers, body, timeoutMs = 600000) {
   } finally { clearTimeout(t); }
 }
 
-module.exports = { adapterFor, post, checkUrl, ADAPTERS };
+/** GET with the same rules as post: no redirects, https unless loopback, a short limit. */
+async function get(fetchImpl, url, headers, timeoutMs = 20000) {
+  const f = fetchImpl || globalThis.fetch;
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const r = await f(checkUrl(url), { method: "GET", headers, redirect: "error", signal: ac.signal });
+    const text = await r.text();
+    let data;
+    try { data = JSON.parse(text); } catch (_) { data = { raw: text.slice(0, 300) }; }
+    if (!r.ok) throw new Error(`${r.status} from provider: ${(data.error && (data.error.message || data.error)) || data.raw || r.statusText}`.slice(0, 300));
+    return data;
+  } finally { clearTimeout(t); }
+}
+
+/**
+ * The default model is chosen from the live list by rule, not by a name frozen in code: the
+ * newest mid-tier model first (sonnet, flash, mini), then the small one, then the first listed.
+ * A provider's own "recommended" flag or ordering wins where the API gives one.
+ */
+const PREFER = [/sonnet/i, /flash(?!-lite)/i, /-mini\b|\bmini\b/i, /haiku/i, /gpt-\d/i, /pro/i];
+function pickDefault(ids) {
+  for (const re of PREFER) { const hit = ids.find((id) => re.test(id)); if (hit) return hit; }
+  return ids[0] || null;
+}
+
+module.exports = { adapterFor, post, get, checkUrl, pickDefault, ADAPTERS };

package/bridge/providers/openai_compatible.js

@@ -14,4 +14,13 @@ async function complete({ provider, system, user, max_tokens = 4000, fetch }) {
   return { text, model: data.model || model, tokens_in: data.usage && data.usage.prompt_tokens, tokens_out: data.usage && data.usage.completion_tokens };
 }
 
-module.exports = { complete, DEFAULT_URL };
+async function listModels({ provider, fetch }) {
+  const { get } = require("./index");
+  const base = (provider.base_url || DEFAULT_URL).replace(/\/$/, "");
+  const headers = provider.api_key ? { authorization: `Bearer ${provider.api_key}` } : {};
+  const data = await get(fetch, `${base}/models`, headers);
+  return (data.data || []).map((m) => ({ id: m.id, name: m.id, created: m.created ? new Date(m.created * 1000).toISOString() : null }))
+    .sort((a, b) => String(b.created || "").localeCompare(String(a.created || "")));
+}
+
+module.exports = { complete, listModels, DEFAULT_URL };

package/http/api.js

@@ -154,9 +154,14 @@ route("POST", "/api/kb/questions/:id/dismiss", (c, p) => discover.dismissQuestio
 
 // usage: tokens per operation from the attempts the app recorded; the pricing test reads this
 route("GET", "/api/usage", (c) => ({
-  by_op: c.db.prepare(`SELECT r.operation AS op, count(*) AS attempts, sum(CASE WHEN a.result = 'passed' THEN 1 ELSE 0 END) AS passed,
+  by_op: c.db.prepare(`SELECT r.operation AS op, count(*) AS attempts,
+      sum(CASE WHEN a.result = 'passed' THEN 1 ELSE 0 END) AS passed, sum(CASE WHEN a.result <> 'passed' THEN 1 ELSE 0 END) AS failed,
+      coalesce(sum(CASE WHEN a.result = 'passed' THEN a.tokens_in END), 0) AS in_passed, coalesce(sum(CASE WHEN a.result = 'passed' THEN a.tokens_out END), 0) AS out_passed,
+      coalesce(sum(CASE WHEN a.result <> 'passed' THEN a.tokens_in END), 0) AS in_failed, coalesce(sum(CASE WHEN a.result <> 'passed' THEN a.tokens_out END), 0) AS out_failed,
       coalesce(sum(a.tokens_in), 0) AS tokens_in, coalesce(sum(a.tokens_out), 0) AS tokens_out, coalesce(avg(a.latency_ms), 0) AS avg_ms, max(a.model) AS model
     FROM ai_attempt a JOIN ai_run r ON r.id = a.ai_run_id WHERE r.candidate_id = ? AND a.tokens_in IS NOT NULL GROUP BY r.operation ORDER BY r.operation`).all(c.candidate_id),
+  // calls that never returned (a timeout, a network drop) recorded no tokens here but were still billed by the provider
+  unrecorded: c.db.prepare("SELECT count(*) c FROM ai_run r WHERE r.candidate_id = ? AND r.route IN ('byo_key', 'credits') AND NOT EXISTS (SELECT 1 FROM ai_attempt a WHERE a.ai_run_id = r.id)").get(c.candidate_id).c,
   since: c.db.prepare("SELECT min(a.started_at) AS s FROM ai_attempt a JOIN ai_run r ON r.id = a.ai_run_id WHERE r.candidate_id = ? AND a.tokens_in IS NOT NULL").get(c.candidate_id).s,
 }));
 
@@ -179,6 +184,10 @@ route("POST", "/api/settings/providers/:id/test", async (c, p) => {
   settings.recordTest(c.home, p.id, { ok: r.ok, at: c.now(), message: r.message });
   return r;
 });
+route("GET", "/api/settings/providers/:id/models", async (c, p) => {
+  const { listModels } = require("../bridge/byo_key");
+  return listModels(c.home, p.id, c.fetch);
+});
 route("GET", "/api/mcp-config", (c) => {
   const cli = path.resolve(__dirname, "..", "bin", "cli.js");
   return { desktop: { mcpServers: { gafj: { command: process.execPath, args: [cli, "mcp"], env: { GAFJ_HOME: c.home } } } }, code: `claude mcp add gafj -e GAFJ_HOME=${JSON.stringify(c.home)} -- ${JSON.stringify(process.execPath)} ${JSON.stringify(cli)} mcp` };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gafj/gafj",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "description": "GAF-J: a local campaign engine for job search. One SQLite file, one ingest door, your own AI subscription.",
   "homepage": "https://gaf-j.com",
   "repository": {

package/ui/screens/settings.js

@@ -5,7 +5,7 @@ import { api, useInstall } from "../lib.js";
 
 const KINDS = ["resume", "cover", "onepager", "email", "prep", "deep_answers", "practice", "cheatsheet"];
 const KIND_LABEL = { anthropic: "Anthropic (Claude)", openai_compatible: "OpenAI, or any OpenAI-compatible server", gemini: "Google Gemini" };
-const KIND_MODEL = { anthropic: "claude-fable-5-1" };
+const KIND_MODEL = { anthropic: "claude-sonnet-5" };
 
 export function Settings({ live }) {
   const [s, setS] = useState(null);
@@ -14,6 +14,7 @@ export function Settings({ live }) {
   const [prov, setProv] = useState(null);
   const [mcp, setMcp] = useState(null);
   const [usage, setUsage] = useState(null);
+  const [models, setModels] = useState({});
   const inst = useInstall();
   const load = () => Promise.all([api.get("/api/settings"), api.get("/api/usage").catch(() => null)]).then(([x, u]) => { setS(x); setUsage(u); setErr(""); }).catch((e) => setErr(e.message));
   useEffect(() => { load(); }, [live]);
@@ -48,7 +49,12 @@ export function Settings({ live }) {
       ${s.providers.length && !s.providers.some((p) => p.id === s.active_provider_id) ? html`<div class="block warn"><b>No provider is switched on.</b> Turn one on below, or nothing can run. Exactly one is on at a time.</div>` : ""}
       <ul class="list">${s.providers.map((p) => html`<li key=${p.id}>
       <label class="switch" title=${s.active_provider_id === p.id ? "on: this provider runs your documents" : "off"}><input type="checkbox" checked=${s.active_provider_id === p.id} onChange=${(e) => put({ active_provider_id: e.target.checked ? p.id : null })} /><span class="track"></span><span class="small">${s.active_provider_id === p.id ? "on" : "off"}</span></label>
-      <b>${p.label}</b> <span class="tag">${p.kind}</span> <span class="muted">${p.model || ""}</span> <span class="mono small">${p.key || "no key"}</span> <span class="muted small">${p.base_url || ""}</span>
+      <b>${p.label}</b> <span class="tag">${p.kind}</span> <span class="mono small">${p.key || "no key"}</span> <span class="muted small">${p.base_url || ""}</span>
+      ${models[p.id] ? html`<select onChange=${async (e) => { await api.put(`/api/settings/providers/${p.id}`, { kind: p.kind, label: p.label, model: e.target.value === "__auto" ? "" : e.target.value, base_url: p.base_url || "" }); load(); }}>
+          <option value="__auto" selected=${!p.model}>auto: ${models[p.id].suggested || "provider default"}</option>
+          ${models[p.id].models.map((m) => html`<option key=${m.id} value=${m.id} selected=${p.model === m.id}>${m.id}${m.id === models[p.id].suggested ? " (suggested)" : ""}</option>`)}
+        </select>${models[p.id].ok ? "" : html`<span class="small error">${models[p.id].message}</span>`}`
+        : html`<span class="muted">${p.model || "model: auto"}</span> <button class="small" onClick=${async () => setModels({ ...models, [p.id]: await api.get(`/api/settings/providers/${p.id}/models`) })}>choose model</button>`}
       ${p.last_test ? html`<span class=${"tag " + (p.last_test.ok ? "passed" : "blocked")}>${p.last_test.ok ? "ok" : "failed"}</span>` : ""}
       <button class="small" onClick=${() => post(`/api/settings/providers/${p.id}/test`, {}, "test")}>test</button>
       <button class="small" onClick=${() => setProv({ id: p.id, kind: p.kind, label: p.label, model: p.model || "", base_url: p.base_url || "", api_key: "" })}>edit</button>
@@ -73,7 +79,7 @@ export function Settings({ live }) {
           <input placeholder=${"model, default " + (KIND_MODEL[prov.kind] || "the provider's current default")} value=${prov.model} onInput=${(e) => setProv({ ...prov, model: e.target.value })} />
           ${prov.kind === "openai_compatible" ? html`<input placeholder="base url, blank for api.openai.com; http only on localhost" value=${prov.base_url} onInput=${(e) => setProv({ ...prov, base_url: e.target.value })} />` : ""}
         </details></form>` : html`<button class="small" onClick=${() => setProv({ id: null, kind: "anthropic", label: "", model: "", base_url: "", api_key: "" })}>+ add</button>`}
-      <p class="small muted">Keys live in config.json under your user only, never in the store, never in a log. A read shows the last four characters.</p>
+      <p class="small muted">Keys live in config.json under your user only, never in the store, never in a log. A read shows the last four characters. "auto" asks the provider for its current models and picks the newest mid-tier one, so a new model is used the day it exists; pick one by name to pin it.</p>
     </div>`}
     <h2>Credits</h2>
     <div class="card">
@@ -92,10 +98,14 @@ export function Settings({ live }) {
     </div>
     <h2>Usage</h2>
     <div class="card">
-      ${usage && usage.by_op.length ? html`<table class="cats"><thead><tr><th>operation</th><th>runs</th><th>passed</th><th>tokens in</th><th>tokens out</th><th>avg seconds</th><th>model</th></tr></thead><tbody>
-        ${usage.by_op.map((u) => html`<tr key=${u.op}><td>${u.op}</td><td>${u.attempts}</td><td>${u.passed}</td><td>${u.tokens_in.toLocaleString()}</td><td>${u.tokens_out.toLocaleString()}</td><td>${(u.avg_ms / 1000).toFixed(1)}</td><td class="small muted">${u.model || ""}</td></tr>`)}
-        <tr><td><b>total</b></td><td>${usage.by_op.reduce((n, u) => n + u.attempts, 0)}</td><td>${usage.by_op.reduce((n, u) => n + u.passed, 0)}</td><td><b>${usage.by_op.reduce((n, u) => n + u.tokens_in, 0).toLocaleString()}</b></td><td><b>${usage.by_op.reduce((n, u) => n + u.tokens_out, 0).toLocaleString()}</b></td><td></td><td></td></tr>
-      </tbody></table><p class="small muted">Counted from every run through your own provider or credits since ${usage.since ? new Date(usage.since).toLocaleDateString() : "the start"}. Paste runs are not counted; the app never sees those token counts. Multiply by your provider's price per million tokens for the cost.</p>`
+      ${usage && usage.by_op.length ? html`<table class="cats"><thead><tr><th>operation</th><th>result</th><th>runs</th><th>tokens in</th><th>tokens out</th><th>model</th></tr></thead><tbody>
+        ${usage.by_op.flatMap((u) => [
+          html`<tr key=${u.op + "p"}><td rowspan="2"><b>${u.op}</b><div class="small muted">${(u.avg_ms / 1000).toFixed(0)} s avg</div></td><td><span class="tag passed">passed</span></td><td>${u.passed}</td><td>${u.in_passed.toLocaleString()}</td><td>${u.out_passed.toLocaleString()}</td><td rowspan="2" class="small muted">${u.model || ""}</td></tr>`,
+          html`<tr key=${u.op + "f"}><td><span class="tag blocked">failed</span></td><td>${u.failed}</td><td>${u.in_failed.toLocaleString()}</td><td>${u.out_failed.toLocaleString()}</td></tr>`,
+        ])}
+        <tr><td><b>total</b></td><td></td><td>${usage.by_op.reduce((n, u) => n + u.attempts, 0)}</td><td><b>${usage.by_op.reduce((n, u) => n + u.tokens_in, 0).toLocaleString()}</b></td><td><b>${usage.by_op.reduce((n, u) => n + u.tokens_out, 0).toLocaleString()}</b></td><td></td></tr>
+        <tr><td colspan="2"><b>of which wasted on failures</b></td><td>${usage.by_op.reduce((n, u) => n + u.failed, 0)}</td><td>${usage.by_op.reduce((n, u) => n + u.in_failed, 0).toLocaleString()}</td><td>${usage.by_op.reduce((n, u) => n + u.out_failed, 0).toLocaleString()}</td><td></td></tr>
+      </tbody></table><p class="small muted">Counted from every run through your own provider or credits since ${usage.since ? new Date(usage.since).toLocaleDateString() : "the start"}. "Failed" is a reply that came back but did not pass the gate. ${usage.unrecorded ? `${usage.unrecorded} call${usage.unrecorded === 1 ? "" : "s"} never returned (a timeout or a dropped connection): no tokens recorded here, but the provider still billed the input.` : ""} Paste runs are not counted. Multiply by your provider's price per million tokens for the cost.</p>`
         : html`<p class="small muted">Nothing counted yet. Runs through your own provider key or credits record their token counts here.</p>`}
     </div>
     <h2>Bullet register</h2>