@gafj/gafj 0.1.9 → 0.1.13

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

@@ -3,14 +3,30 @@
 const DEFAULT_URL = "https://api.anthropic.com";
 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

@@ -184,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` };
@@ -226,6 +230,7 @@ route("POST", "/api/run/:op", async (c, p, b, q) => {
   }
   const r = saveReply(c.db, { run_id: opened.run_id, content: reply.content, route: routeName, actor: ACTOR("run"), now: c.now(), provider: reply.provider, model: reply.model, tokens_in: reply.tokens_in, tokens_out: reply.tokens_out, latency_ms: reply.latency_ms });
   if (r.status !== "passed" && reply.stop_reason === "max_tokens") r.errors = [...(r.errors || []), "the reply was cut off at the token limit"];
+  Object.assign(r, { tokens_in: reply.tokens_in ?? null, tokens_out: reply.tokens_out ?? null, latency_ms: reply.latency_ms ?? null, model: reply.model || null });
   return reply.credits_left === undefined ? r : { ...r, charged: reply.charged, credits_left: reply.credits_left };
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gafj/gafj",
-  "version": "0.1.9",
+  "version": "0.1.13",
   "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/store/onboarding.js

@@ -96,11 +96,28 @@ function sourceText(db, source_document_id) {
 
 // ----- propose_from_source -----
 
+/**
+ * Excerpt or nothing, with the counting done here: a model quotes reliably but cannot count
+ * characters, so a span that does not match is relocated to where the quoted text actually
+ * sits in the source (the occurrence nearest the claimed start; whitespace runs may differ).
+ * A value that appears nowhere in the source, byte for byte and case for case, is refused.
+ */
 function checkAtom(atom, text, label, errors) {
   if (!atom) return;
   const { value, start, end } = atom;
-  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > text.length || end <= start) { errors.push(`${label}: span [${start}, ${end}) is not inside the source`); return; }
-  if (text.slice(start, end) !== value) errors.push(`${label}: "${String(value).slice(0, 40)}" is not the source text at [${start}, ${end})`);
+  if (!Number.isInteger(start) || !Number.isInteger(end)) { errors.push(`${label}: span [${start}, ${end}) is not inside the source`); return; }
+  if (start >= 0 && end <= text.length && end > start && text.slice(start, end) === value) return;
+  const v = String(value);
+  const near = Number.isInteger(start) ? Math.max(0, start) : 0;
+  let hits = [];
+  if (v.length) for (let i = text.indexOf(v); i !== -1; i = text.indexOf(v, i + 1)) hits.push([i, i + v.length]);
+  if (!hits.length && v.trim()) {
+    const re = new RegExp(v.trim().split(/\s+/).map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+"), "g");
+    for (let m = re.exec(text); m; m = re.exec(text)) { hits.push([m.index, m.index + m[0].length]); if (!m[0].length) break; }
+  }
+  if (!hits.length) { errors.push(`${label}: "${v.slice(0, 40)}" is not the source text at [${start}, ${end})`); return; }
+  const [s, e] = hits.reduce((best, h) => (Math.abs(h[0] - near) < Math.abs(best[0] - near) ? h : best));
+  atom.start = s; atom.end = e; atom.value = text.slice(s, e);
 }
 
 /** Validate a draft against its source: every atom cited and verbatim, else the whole draft is rejected. */

package/ui/app.css

@@ -182,3 +182,7 @@ mark { background: var(--good-bg); color: var(--good-bright); border-radius: 3px
 .switch input:checked + .track { background: var(--accent); }
 .switch input:checked + .track::after { left: 18px; }
 .switch input:focus-visible + .track { outline: 2px solid var(--accent); outline-offset: 2px; }
+/* a small spinner beside anything that is with the model */
+.spin { display: inline-block; width: 10px; height: 10px; border: 2px solid var(--line-2); border-top-color: var(--accent); border-radius: 50%; animation: spin .8s linear infinite; vertical-align: -1px; }
+@keyframes spin { to { transform: rotate(360deg); } }
+@media (prefers-reduced-motion: reduce) { .spin { animation: none; border-top-color: var(--line-2); } }

package/ui/screens/kb.js

@@ -15,13 +15,21 @@ export function Onboarding({ d, reload, setErr, route, compact }) {
   const b = d.batch;
   const direct = route === "byo_key" || route === "credits";
   // with a provider or credits the extraction runs here; otherwise the packet opens for paste
+  // a ticking clock while a file is with the model, so a long call is visibly alive
+  const [, tick] = useState(0);
+  useEffect(() => { const t = setInterval(() => tick((n) => n + 1), 1000); return () => clearInterval(t); }, []);
+  const since = {};
+  const elapsed = (ms) => { const sec = Math.round(ms / 1000); return `${Math.floor(sec / 60)}:${String(sec % 60).padStart(2, "0")}`; };
   const runOne = async (s) => {
-    setRunning((r) => ({ ...r, [s.source_document_id]: "running" }));
+    const started = Date.now();
+    setRunning((r) => ({ ...r, [s.source_document_id]: { started } }));
     try {
       const r = await api.post(`/api/run/extract?source_document_id=${s.source_document_id}`, {});
-      setRunning((x) => ({ ...x, [s.source_document_id]: r.status === "passed" ? `${r.pending_ids.length} records proposed` : `refused: ${(r.errors || []).slice(0, 2).join("; ")}` }));
+      const took = `${elapsed(Date.now() - started)}${r.tokens_in ? ` · ${(r.tokens_in + (r.tokens_out || 0)).toLocaleString()} tokens` : ""}`;
+      setRunning((x) => ({ ...x, [s.source_document_id]: r.status === "passed" ? `${r.pending_ids.length} records proposed in ${took}` : `refused after ${took}: ${(r.errors || []).slice(0, 2).join("; ")}` }));
     } catch (e) { setRunning((x) => ({ ...x, [s.source_document_id]: "failed: " + e.message })); }
   };
+  const isRunning = (id) => running[id] && typeof running[id] === "object";
   const extract = async (s) => {
     if (!direct) { setModal({ source: s }); return; }
     await runOne(s);
@@ -57,9 +65,9 @@ export function Onboarding({ d, reload, setErr, route, compact }) {
     ${b ? html`<ul class="list">${b.sources.map((s) => html`<li key=${s.source_document_id}><b>${s.filename}</b> <span class="tag">${s.kind}</span>
       ${s.empty ? html`<span class="tag blocked">no text</span>` : html`<span class="muted small">${s.chars} chars</span>`}
       <span class="muted small">${s.pending} pending, ${s.runs} runs</span>
-      ${!s.empty ? html`<button class="small" disabled=${running[s.source_document_id] === "running"} onClick=${() => extract(s)}>${running[s.source_document_id] === "running" ? "extracting" : direct ? "Extract" : "Extract (paste)"}</button>` : ""}
+      ${!s.empty ? html`<button class="small" disabled=${isRunning(s.source_document_id)} onClick=${() => extract(s)}>${isRunning(s.source_document_id) ? html`<span class="spin"></span> extracting · ${elapsed(Date.now() - running[s.source_document_id].started)}` : direct ? "Extract" : "Extract (paste)"}</button>` : ""}
       <button class="small danger" title="remove this file and anything proposed from it; confirmed records stay" onClick=${async () => { if (!confirm(`Remove ${s.filename}? Records already confirmed stay; pending rows from this file go.`)) return; try { await api.del(`/api/sources/${s.source_document_id}`); await reload(); } catch (e) { setErr(e.message); } }}>remove</button>
-      ${running[s.source_document_id] && running[s.source_document_id] !== "running" ? html`<span class="small muted">${running[s.source_document_id]}</span>` : ""}</li>`)}
+      ${running[s.source_document_id] && !isRunning(s.source_document_id) ? html`<span class="small muted">${running[s.source_document_id]}</span>` : ""}</li>`)}
       ${b.sources.length ? "" : html`<li class="muted">upload a resume to start</li>`}</ul>` : ""}
     ${b && b.pending.length ? html`<div class="row"><button onClick=${() => post(`/api/onboarding/batches/${b.batch_id}/dedup`)}>Suggest duplicates</button><span class="small muted">same employer, overlapping dates, a shared figure; nothing merges without you</span></div>` : ""}
     ${groups.map((g) => html`<div class="block warn" key=${g.id}><b>These may be the same accomplishment</b>

package/ui/screens/settings.js

@@ -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">