settings

appearance

\n width \n font \n size \n theme \n accent \n density \n timestamps\n telemetry tags\n wrap long code lines\n

thinking & tools

\n thinking \n show tool chain\n live thinking while generating\n

router

\n router url \n router key \n vendor order \n key rotation \n

model

\n routing \n pin \n reasoning effort \n temperature \n max_tokens policy \n fixed max_tokens \n history sent to the model \n expected length \n in-turn continues \n auto-continue across turns \n auto-continue unfinished work (rounds) \n keep retrying when providers are exhausted (min) \n swarm builders in parallel \n work until I say /finalize — unlimited retries and continues; after each completed round, ship the next upgrades\n auto-compact history when it outgrows the context budget\n two top-tier examples in every prompt (few-shot; off saves input tokens on tight free tiers)\n app-scale asks go through /build automatically (architect → parallel builders → integrate)\n inline preview on artifact cards\n turn budget (s) \n

governor

\n plan before answering (complex asks)\n verification pass\n ensemble on high-stakes\n long-term memory\n

tools

custom instructions

\n \n

prompts

\n edit \n

\n \n

import

skills

Instruction packs the model receives as binding rules. always = every turn; auto = when the message matches the keywords (comma-separated) or a /regex/i.

input

\n send with \n auto-scroll to new replies\n

data

\n`;\n\nexport const settingsScript: string = String.raw`\n// Runtime error ring buffer, installed at module load (this script loads before main-script.ts's own\n// bootstrap — see main-html.tsx's script order) so it catches errors from the moment the page is live,\n// not just from when the settings drawer happens to be opened. Feeds SETTINGS.copyDiagnostics() below.\nconst DIAG_LOG = [];\nfunction diagPush(kind, parts) {\n try {\n const msg = parts.map(a => { try { return typeof a === 'string' ? a : JSON.stringify(a); } catch { return String(a); } }).join(' ').slice(0, 400);\n DIAG_LOG.push({ t: Date.now(), kind, msg });\n if (DIAG_LOG.length > 40) DIAG_LOG.shift();\n } catch {}\n}\n(() => {\n const origError = console.error.bind(console);\n console.error = (...args) => { diagPush('console.error', args); origError(...args); };\n window.addEventListener('error', (e) => diagPush('window.onerror', [e.message + ' @ ' + (e.filename || '?') + ':' + (e.lineno || '?')]));\n window.addEventListener('unhandledrejection', (e) => diagPush('unhandledrejection', [String((e.reason && e.reason.message) || e.reason)]));\n})();\n\nconst SETTINGS = (() => {\n const KEY = 'omni.settings';\n const DEF = { width: '760', font: 'mono', fontSize: 13, theme: 'midnight', accent: '#4f8cff', density: 'cozy', timestamps: true, telemetry: true, codeWrap: false,\n thinking: 'collapsed', showTools: true, liveThinking: true, mode: 'auto', pin: '', reasoning: '', temp10: -1, maxTokens: 0, continueMax: 3, budgetS: 52,\n plan: true, verify: true, ensemble: true, memory: true, tools: null, system: '', sendKey: 'enter', autoScroll: true, prompts: {}, skills: [],\n routerUrl: '', routerKey: '', maxMode: 'auto', expect: 'auto', autoContinue: 6, swarm: 3, cardPreview: true, autoSwarm: true, examples: true, untilStopped: false, autoCompact: true, keyPolicy: '', contextChars: 16000, retryMinutes: 5, vendorOrder: 'openrouter', autoComplete: 4 };\n const PRESETS = {\n 'single-file html': { name: 'single-file html', mode: 'auto', when: 'html, webgl, canvas, shader, game, app, visuali', body: 'Deliver browser artifacts as ONE self-contained index.html: inline all CSS in '; });\n const base = '';\n html = /]*>/i.test(html) ? html.replace(/]*>/i, (m) => m + base + HOOK) : base + HOOK + html;\n return html;\n }\n function reload(fromServer) {\n if (!cur) return;\n if (!fromServer && liveCb.checked) { const doc = buildLive(); if (doc !== null) { frame.srcdoc = doc; return; } }\n frame.removeAttribute('srcdoc'); frame.src = '/artifact/' + cur.id + '/?v=' + Date.now();\n }\n function scheduleLive() { if (!liveCb.checked) return; clearTimeout(liveTimer); liveTimer = setTimeout(() => { clearConsole(); reload(false); }, E.liveDelay); }\n function scheduleSave() { if (!E.autoSave) return; clearTimeout(saveTimer); saveTimer = setTimeout(() => save(), E.autoSaveDelay); }\n\n // ─── file tree ──────────────────────────────────────────────────────────────\n function renderTree() {\n treeB.innerHTML = '';\n const root = {};\n for (const f of [...cur.files].sort((a, b) => a.path.localeCompare(b.path))) { const parts = f.path.split('/'); let n = root; for (const p of parts.slice(0, -1)) n = n[p] = n[p] || {}; n[parts[parts.length - 1]] = f; }\n const walk = (node, host, prefix, depth) => {\n const names = Object.keys(node).sort((a, b) => (typeof node[a].path === 'string') - (typeof node[b].path === 'string') || a.localeCompare(b));\n for (const name of names) {\n const v = node[name];\n if (typeof v.path === 'string') { const d = document.createElement('div'); d.className = 'tr-f' + (v.path === active ? ' on' : '') + (cur.dirty.has(v.path) ? ' dirty' : ''); d.style.paddingLeft = (8 + depth * 12) + 'px'; d.textContent = name; d.title = v.path; d.onclick = () => showFile(v.path); host.appendChild(d); }\n else { const dir = prefix + name + '/'; const d = document.createElement('div'); d.className = 'tr-d' + (closedDirs.has(dir) ? ' closed' : ''); d.style.paddingLeft = (6 + depth * 12) + 'px'; d.textContent = name; d.onclick = () => { closedDirs.has(dir) ? closedDirs.delete(dir) : closedDirs.add(dir); renderTree(); }; host.appendChild(d); const kids = document.createElement('div'); kids.className = 'tr-kids'; host.appendChild(kids); walk(v, kids, dir, depth + 1); }\n }\n };\n walk(root, treeB, '', 0);\n }\n function showFile(p) {\n if (!cur) return; const f = cur.files.find(x => x.path === p); if (!f) return;\n active = p;\n if (isBin(p, f.content)) { bin.hidden = false; ta.hidden = true; gutter.hidden = true; if (cm) cm.getWrapperElement().style.display = 'none'; bin.innerHTML = /^data:image\\//.test(f.content) ? '' : 'binary · ' + Math.round(f.content.length * 0.75 / 1024) + ' KB'; if (bin.querySelector('img')) bin.querySelector('img').src = f.content; }\n else { bin.hidden = true; if (cm) { cm.getWrapperElement().style.display = ''; } else { ta.hidden = false; gutter.hidden = !E.lineNumbers || !!E.wrap; } ED.mode(p); ED.set(f.content); }\n renderTree(); updState(); updPos(); ED.refresh();\n }\n function onEdit() { if (!cur || !active) return; const f = cur.files.find(x => x.path === active); if (!f || isBin(active, f.content)) return; f.content = ED.get(); cur.dirty.add(active); renderTree(); updState(); renderGutter(); lintLocal(); scheduleLive(); scheduleSave(); }\n function renderGutter() { if (cm || !E.lineNumbers || E.wrap) return; const n = ta.value.split('\\n').length; if (gutter.dataset.n == n) return; gutter.dataset.n = n; let s = ''; for (let i = 1; i <= n; i++) s += i + '\\n'; gutter.textContent = s; }\n ta.addEventListener('scroll', () => { gutter.scrollTop = ta.scrollTop; });\n function updState() { const f = cur.files.find(x => x.path === active); state.textContent = (f ? (isBin(f.path, f.content) ? 'binary' : f.content.length + ' chars · ' + f.content.split('\\n').length + ' lines') : '') + (cur.dirty.size ? ' · ' + cur.dirty.size + ' unsaved' : ''); }\n function updPos() { const [l, c, s] = ED.cursor(); pos.textContent = l + ':' + c + (s ? ' (' + s + ' sel)' : ''); }\n let lintIssues = []; const autoFixed = {}; // artifact id → rounds used\n function showLint(issues) {\n lintIssues = issues || [];\n if (lintIssues.length) { lint.hidden = false; $('ap-lint-n').textContent = lintIssues.length + ' lint issue' + (lintIssues.length > 1 ? 's' : ''); $('ap-lint-b').textContent = lintIssues.join('\\n'); maybeAutoFix(); }\n else lint.hidden = true;\n }\n function lintVars() { return { ...vars(), lint: lintIssues.join('\\n') }; }\n function fixLint() { if (!cur || !lintIssues.length || typeof sendWith !== 'function') return; const text = tpl(E.pLint, lintVars()); askSt.textContent = 'fixing lint'; sendWith(text, focusPayload()); }\n function copyLint() { navigator.clipboard.writeText(lintIssues.join('\\n')); }\n function maybeAutoFix() {\n if (!E.autoFixLint || !cur || !lintIssues.length || (window.inflightTurn && window.inflightTurn())) return;\n const key = cur.id + ':' + lintIssues.join('|');\n autoFixed[cur.id] = autoFixed[cur.id] || { rounds: 0, last: '' };\n const st = autoFixed[cur.id]; if (st.rounds >= 2 || st.last === key) return;\n st.rounds++; st.last = key; setTimeout(fixLint, 400);\n }\n function lintLocal() { if (!E.lintOnType || !active || !/\\.m?js$/.test(active)) return; try { new Function(ED.get().replace(/^\\s*import\\s[\\s\\S]*?from\\s*[\"'][^\"']+[\"']\\s*;?/gm, '').replace(/^\\s*export\\s*\\{[\\s\\S]*?\\}\\s*;?/gm, '').replace(/^\\s*export\\s+(default\\s+)?/gm, '')); showLint(null); } catch (e) { showLint([active + ': ' + e.message]); } }\n // textarea fallback keys\n ta.addEventListener('input', onEdit); ta.addEventListener('keyup', updPos); ta.addEventListener('click', updPos);\n ta.addEventListener('keydown', (e) => {\n const s = ta.selectionStart, en = ta.selectionEnd, ind = E.softTabs ? ' '.repeat(E.tabSize) : '\\t';\n if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 's') { e.preventDefault(); save(); }\n else if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') { e.preventDefault(); reload(true); }\n else if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'f') { e.preventDefault(); findToggle(true); }\n else if (e.key === 'Tab') { e.preventDefault(); ta.setRangeText(ind, s, en, 'end'); ta.dispatchEvent(new Event('input')); }\n else if (e.key === 'Enter' && E.autoIndent) { const line = ta.value.slice(0, s).split('\\n').pop(); const base = line.match(/^\\s*/)[0] + (/[{(\\[:]\\s*$/.test(line) ? ind : ''); e.preventDefault(); ta.setRangeText('\\n' + base, s, en, 'end'); ta.dispatchEvent(new Event('input')); }\n });\n\n // ─── find / replace ─────────────────────────────────────────────────────────\n const fbox = $('ap-find'), fin = $('ap-find-in'), frep = $('ap-find-rep'), fn = $('ap-find-n'), fall = $('ap-find-all');\n function findToggle(open) { const o = open ?? fbox.hidden; fbox.hidden = !o; if (o) { fin.value = ED.sel() || fin.value; fin.focus(); fin.select(); } else ED.focus(); }\n function rx() { try { return new RegExp(fin.value, 'gi'); } catch { return new RegExp(fin.value.replace(/[.*+?^$\\{\\}()|[\\]\\\\]/g, '\\\\$&'), 'gi'); } }\n function findNext(dir) {\n if (!fin.value) return;\n if (fall.checked) { const hits = cur.files.filter(f => !isBin(f.path, f.content) && rx().test(f.content)); fn.textContent = hits.length + ' files'; const i = hits.findIndex(f => f.path === active); const nxt = hits[(i + (dir > 0 ? 1 : hits.length - 1)) % Math.max(1, hits.length)]; if (nxt && nxt.path !== active) { showFile(nxt.path); } }\n const v = ED.get(), re = rx(); const all = [...v.matchAll(re)]; fn.textContent = (fall.checked ? fn.textContent + ' · ' : '') + all.length + ' here'; if (!all.length) return;\n const from = cm ? cm.indexFromPos(dir > 0 ? cm.getCursor('to') : cm.getCursor('from')) : (dir > 0 ? ta.selectionEnd : ta.selectionStart);\n const m = dir > 0 ? (all.find(x => x.index >= from) || all[0]) : ([...all].reverse().find(x => x.index < from) || all[all.length - 1]);\n if (cm) { cm.setSelection(cm.posFromIndex(m.index), cm.posFromIndex(m.index + m[0].length)); cm.scrollIntoView(cm.posFromIndex(m.index), 60); } else { ta.focus(); ta.setSelectionRange(m.index, m.index + m[0].length); }\n }\n function replaceOne() { const sel = ED.sel(); if (!sel || !rx().test(sel)) { findNext(1); return; } if (cm) cm.replaceSelection(sel.replace(rx(), frep.value)); else { ta.setRangeText(sel.replace(rx(), frep.value), ta.selectionStart, ta.selectionEnd, 'end'); ta.dispatchEvent(new Event('input')); } if (cm) onEdit(); findNext(1); }\n function replaceAll() {\n if (!fin.value) return; let n = 0;\n const targets = fall.checked ? cur.files.filter(f => !isBin(f.path, f.content)) : cur.files.filter(f => f.path === active);\n for (const f of targets) { const out = f.content.replace(rx(), (m) => { n++; return frep.value; }); if (out !== f.content) { f.content = out; cur.dirty.add(f.path); } }\n fn.textContent = n + ' replaced'; showFile(active); scheduleLive();\n }\n fin.addEventListener('keydown', (e) => { if (e.key === 'Enter') findNext(e.shiftKey ? -1 : 1); if (e.key === 'Escape') findToggle(false); });\n\n // ─── save / files ───────────────────────────────────────────────────────────\n async function save() {\n if (!cur || !cur.dirty.size) return true;\n const files = [...cur.dirty].map(p => cur.files.find(x => x.path === p)).filter(Boolean).map(f => ({ path: f.path, content: f.content }));\n const r = await post('?artifact_save_many', { id: cur.id, session: cur.session, files });\n if (!r.ok) { state.textContent = 'save failed: ' + r.status; return false; }\n const j = await r.json(); for (const f of files) { cur.dirty.delete(f.path); cur.orig[f.path] = f.content; }\n showLint(j.issues); renderTree(); updState(); state.textContent += ' · saved'; clearConsole(); reload(true); return true;\n }\n function ask(label, def) { return new Promise((res) => { const box = $('ap-prompt'), inp = $('ap-prompt-in'); inp.placeholder = label; inp.value = def || ''; box.hidden = false; inp.focus(); inp.select();\n const done = (v) => { box.hidden = true; $('ap-prompt-ok').onclick = $('ap-prompt-no').onclick = null; inp.onkeydown = null; res(v); };\n $('ap-prompt-ok').onclick = () => done(inp.value.trim()); $('ap-prompt-no').onclick = () => done(null); inp.onkeydown = (e) => { if (e.key === 'Enter') done(inp.value.trim()); if (e.key === 'Escape') done(null); }; }); }\n async function addFile() { const p = await ask('path, e.g. src/game/enemy.js'); if (!p || !cur) return; const clean = p.replace(/^\\/+/, ''); if (!cur.files.some(f => f.path === clean)) cur.files.push({ path: clean, content: '' }); cur.dirty.add(clean); showFile(clean); ED.focus(); }\n async function renameFile() {\n if (!cur || !active || /^index\\.html?$/.test(active)) return; const p = await ask('new path', active); if (!p || p === active) return;\n const f = cur.files.find(x => x.path === active); const old = active;\n await post('?artifact_save_many', { id: cur.id, session: cur.session, files: [{ path: p, content: f.content }] });\n await post('?artifact_delete_file', { id: cur.id, path: old });\n f.path = p; cur.dirty.delete(old); cur.orig[p] = f.content; showFile(p); reload(true);\n }\n async function deleteFile() {\n if (!cur || !active || /^index\\.html?$/.test(active)) return; const ok = await ask('type DELETE to remove ' + active); if (ok !== 'DELETE') return;\n await post('?artifact_delete_file', { id: cur.id, path: active });\n cur.files = cur.files.filter(f => f.path !== active); cur.dirty.delete(active); showFile(cur.files[0].path); reload(true);\n }\n function revert() { if (!cur || !active) return; const f = cur.files.find(x => x.path === active); f.content = cur.orig[active] ?? f.content; cur.dirty.delete(active); showFile(active); scheduleLive(); }\n function copy() { if (cur && active) navigator.clipboard.writeText(cur.files.find(x => x.path === active)?.content ?? ''); }\n async function loadZip() { if (!window.JSZip) await new Promise((res, rej) => { const s = document.createElement('script'); s.src = 'https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js'; s.onload = res; s.onerror = rej; document.head.appendChild(s); }); return window.JSZip; }\n async function zip() {\n if (!cur) return; const J = await loadZip(); const z = new J();\n for (const f of cur.files) { if (isBin(f.path, f.content)) { const m = f.content.match(/^data:[^;,]*;base64,(.*)$/s); if (m) z.file(f.path, m[1], { base64: true }); } else z.file(f.path, f.content); }\n const blob = await z.generateAsync({ type: 'blob' }); const a = document.createElement('a'); a.href = URL.createObjectURL(blob); a.download = (cur.title || 'artifact').replace(/[^\\w.-]+/g, '_') + '.zip'; a.click();\n }\n /** Upload loose files or a .zip into the open artifact (or create a new artifact from a zip when none is open). Text as-is, binaries as data: URLs. */\n async function upload(fileList) {\n const files = [];\n const readText = (f) => f.text(); const readData = (f) => new Promise((res) => { const r = new FileReader(); r.onload = () => res(r.result); r.readAsDataURL(f); });\n for (const f of fileList) {\n if (/\\.zip$/i.test(f.name)) { const J = await loadZip(); const z = await J.loadAsync(f); const names = Object.keys(z.files).filter(n => !z.files[n].dir && !/(^|\\/)(\\.|__MACOSX)/.test(n)); const strip = names.every(n => n.includes('/')) && new Set(names.map(n => n.split('/')[0])).size === 1 ? names[0].split('/')[0].length + 1 : 0;\n for (const n of names) { const path = n.slice(strip); if (!path) continue; if (isBin(path)) { const b64 = await z.files[n].async('base64'); files.push({ path, content: 'data:' + (mimeOf(path)) + ';base64,' + b64 }); } else files.push({ path, content: await z.files[n].async('string') }); } }\n else files.push({ path: f.name, content: isBin(f.name) ? await readData(f) : await readText(f) });\n }\n if (!files.length) return;\n if (!cur) { const r = await post('?artifact_save_many', { session: window.currentSession, title: files.find(f => /\\.zip$/i.test(f.path))?.path || 'Imported', files }); const j = await r.json(); if (j.id) { open(j.id, 'split'); listForSession(window.currentSession); } return; }\n for (const f of files) { const ex = cur.files.find(x => x.path === f.path); if (ex) ex.content = f.content; else cur.files.push(f); cur.dirty.add(f.path); }\n renderTree(); updState(); state.textContent = files.length + ' file' + (files.length > 1 ? 's' : '') + ' added (unsaved)'; if (!E.autoSave) scheduleLive(); else scheduleSave();\n }\n const mimeOf = (p) => ({ png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp', ico: 'image/x-icon', woff: 'font/woff', woff2: 'font/woff2', ttf: 'font/ttf', otf: 'font/otf', mp3: 'audio/mpeg', ogg: 'audio/ogg', wav: 'audio/wav', mp4: 'video/mp4', webm: 'video/webm', wasm: 'application/wasm' })[(p.split('.').pop() || '').toLowerCase()] || 'application/octet-stream';\n const tree = $('ap-tree');\n ['dragenter', 'dragover'].forEach(ev => tree.addEventListener(ev, (e) => { e.preventDefault(); tree.classList.add('drag'); }));\n ['dragleave', 'drop'].forEach(ev => tree.addEventListener(ev, (e) => { e.preventDefault(); tree.classList.remove('drag'); if (ev === 'drop' && e.dataTransfer?.files?.length) upload(e.dataTransfer.files); }));\n\n // ─── jobs strip (swarm builds) ──────────────────────────────────────────────\n const jobs = {};\n function setJobs(list) { if (list === null) { jobsEl.hidden = true; jobsEl.innerHTML = ''; for (const k in jobs) delete jobs[k]; return; } for (const j of list) jobs[j.path] = j.st; jobsEl.hidden = false; jobsEl.innerHTML = Object.entries(jobs).map(([p, s]) => '' + p.split('/').pop() + '').join(''); }\n\n // ─── composer ───────────────────────────────────────────────────────────────\n function prefill(text) { askIn.value = text; askIn.dispatchEvent(new Event('input')); askIn.focus(); askIn.setSelectionRange(askIn.value.length, askIn.value.length); }\n function askEdit() { if (cur) prefill(tpl(E.pAsk, vars())); }\n function askFix() { if (cur) prefill(tpl(E.pFix, vars())); }\n function askSelection() { if (!cur) return; const v = vars(); if (!v.selection) { state.textContent = 'select some text first'; return; } prefill(tpl(E.pSel, v)); }\n function focusPayload() { if (!cur || el.classList.contains('closed')) return null; const v = vars(); return { focus: { id: cur.id, title: cur.title, file: active || '', files: cur.files.map(f => f.path), selection: (v.selection || '').slice(0, 4000), errors: lastErrors.slice(-E.errorsToAI) } }; }\n async function send() {\n const t = askIn.value.trim(); if (!t || !cur || typeof sendWith !== 'function') return;\n const fp = focusPayload(), text = (E.pPrefix ? tpl(E.pPrefix, vars()) + '\\n' : '') + t;\n if (E.saveBeforeAsk && cur.dirty.size) { askSt.textContent = 'saving'; if (!(await save())) return; }\n askIn.value = ''; askIn.dispatchEvent(new Event('input')); askGo.disabled = true; askSt.textContent = 'sending';\n sendWith(text, fp);\n }\n askIn.addEventListener('input', () => { askIn.style.height = 'auto'; askIn.style.height = Math.min(askIn.scrollHeight, 120) + 'px'; });\n askIn.addEventListener('keydown', (e) => { if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) { e.preventDefault(); send(); } });\n document.addEventListener('omni:typing', (e) => { if (el.classList.contains('closed')) return; askSt.textContent = e.detail.on ? (e.detail.label + (e.detail.progress ? ' · ' + e.detail.progress.replace(/<[^>]+>/g, '') : '')) : ''; });\n document.addEventListener('omni:turn', (e) => {\n askGo.disabled = false; askSt.textContent = e.detail.error ? 'error' : '';\n if (el.classList.contains('closed') || !E.focusReply) return;\n const f = e.detail.final; reply.hidden = false; $('ap-reply-t').textContent = e.detail.error ? 'error' : 'reply';\n replyB.innerHTML = e.detail.error ? '' + MD.esc(e.detail.error) + '' : MD.render(f && f.reply || '');\n if (!e.detail.error && window.MD && MD.enhance) MD.enhance(replyB);\n });\n function hideReply() { reply.hidden = true; }\n\n // ─── resize + keys ──────────────────────────────────────────────────────────\n const drag = (handle, onMove) => handle.addEventListener('pointerdown', (e) => { e.preventDefault(); handle.setPointerCapture(e.pointerId); frame.style.pointerEvents = 'none'; const mv = (ev) => onMove(ev); const up = () => { handle.removeEventListener('pointermove', mv); handle.removeEventListener('pointerup', up); frame.style.pointerEvents = ''; saveE(); }; handle.addEventListener('pointermove', mv); handle.addEventListener('pointerup', up); });\n drag($('ap-resize'), (ev) => { E.width = Math.round(Math.max(30, Math.min(100, (window.innerWidth - ev.clientX) / window.innerWidth * 100))); document.documentElement.style.setProperty('--ap-w', E.width + 'vw'); });\n drag($('ap-divider'), (ev) => { const body = $('ap-body'), r = body.getBoundingClientRect(); const horiz = getComputedStyle(body).flexDirection === 'row'; let pct = horiz ? (ev.clientX - r.left) / r.width * 100 : (ev.clientY - r.top) / r.height * 100; if (E.side !== 'left') pct = 100 - pct; E.split = Math.round(Math.max(15, Math.min(85, pct))); document.documentElement.style.setProperty('--ap-split', E.split + '%'); ED.refresh(); });\n liveCb.addEventListener('change', () => { E.live = liveCb.checked; saveE(); reload(!liveCb.checked); });\n const narrow = () => el.classList.toggle('narrow', window.innerWidth < 1000); window.addEventListener('resize', () => { narrow(); ED.refresh(); }); narrow();\n document.addEventListener('keydown', (e) => {\n if (el.classList.contains('closed')) return;\n if (e.key === 'Escape') { if (!fbox.hidden) findToggle(false); else if (!setEl.classList.contains('closed')) toggleSettings(false); else if (document.activeElement !== ta && !(cm && cm.hasFocus()) && $('ap-prompt').hidden) close(); }\n else if ((e.ctrlKey || e.metaKey) && e.key === ',') { e.preventDefault(); toggleSettings(); }\n });\n\n // ─── sidebar list ───────────────────────────────────────────────────────────\n async function listForSession(session) {\n const host = $('sb-artifacts'); if (!host) return;\n try { listCache = await (await fetch('?artifacts&session=' + encodeURIComponent(session))).json();\n host.innerHTML = listCache.length ? '

artifacts

' : '';\n for (const a of listCache) { const b = document.createElement('button'); b.className = 'sb-art'; b.textContent = '#' + a.id + ' ' + a.title; b.onclick = () => open(a.id); host.appendChild(b); }\n } catch {}\n }\n applyE();\n return { open, close, refresh, restore, view, reload, save, addFile, renameFile, deleteFile, revert, copy, zip, upload, askEdit, askFix, askSelection, send, hideReply, clearConsole, hideConsole, listForSession, toggleSettings, resetPrompts, resetSettings,\n findToggle, findNext, replaceOne, replaceAll, fixLint, copyLint, jobs: setJobs, tpl: (k, v) => tpl(E['p' + k[0].toUpperCase() + k.slice(1)] || PDEF['p' + k[0].toUpperCase() + k.slice(1)], v), list: () => listCache, lastErrors: () => lastErrors.slice(-E.errorsToAI),\n focusPayload, settings: () => E, setSettings: (o) => { if (o && typeof o === 'object') { E = { ...DEF, ...o }; saveE(); } }, current: () => cur };\n})();\nwindow.ART = ART;\n`;\n",[],[292],"f7688a5e-462d-11f1-b542-42b51c65c3df","text-chunker.ts","1093f85e-462b-11f1-8725-42b51c65c3df",888,["D",1777729866332],12,"http","// ─────────────────────────────────────────────────────────────────────────────\n// CHUNK ENGINE · mobile-first · Val Town Hono/Deno\n// ─────────────────────────────────────────────────────────────────────────────\n\n// ── Constants ────────────────────────────────────────────────────────────────\n\nconst DEFAULT_CHUNK = 10_000;\nconst MAX_BOUND = 1_000_000;\n\nconst CFG = Object.freeze({\n NORMALIZE: true,\n SAFE_SLICE: true,\n HTML_ESCAPE: true,\n JSON_ESCAPE: true,\n});\n\nconst ESC: Readonly> = Object.freeze({\n \"&\": \"&\",\n \"<\": \"<\",\n \">\": \">\",\n '\"': \""\",\n \"'\": \"'\",\n});\n\n// ── Pure utilities ────────────────────────────────────────────────────────────\n\nfunction escH(s: string): string {\n return CFG.HTML_ESCAPE ? s.replace(/[&<>\"']/g, (c) => ESC[c]) : s;\n}\n\nfunction escJSON(v: unknown): string {\n return JSON.stringify(v)\n .replace(/<\\/script>/gi, \"<\\\\/script>\")\n .replace(/\n

\n Input ▾\n

\n \n

\n \n \n \n

\n\n\n

\n Chunking ▾\n

\n Size\n \n

\n Overlap\n \n

\n Min Length\n \n

\n Boundary Snap\n \n

\n Token Model\n \n

\n \n

\n \n Collapse whitespace\n \n \n \n \n \n \n Reverse order\n \n \n \n \n \n \n NFKC normalize\n \n \n \n \n \n \n Strip BOM\n \n \n \n \n \n

\n\n\n

\n Wrap & Describe ▾\n

\n Global Prefix\n \n

\n Global Postfix\n \n

\n Per-chunk Prefix Template\n \n

\n Per-chunk Postfix Template\n \n

\n Templates: {i} = 1-based index · {n} = total · {s} = start offset · {e} = end offset · {chars} = length · {tokens} = est. tokens · {hash} = 8-char fingerprint\n

\n \n Show chunk descriptions\n \n \n \n \n \n \n Base64 output\n \n \n \n \n \n

\n Description template\n \n

\n\n\n\n\n

\n\n\n\n\n\n`;\n}\n\n// ── Handler ───────────────────────────────────────────────────────────────────\n\nconst handler = async (req: Request): Promise => {\n let text = \"\";\n let reqSize = 0;\n\n if (req.method === \"POST\") {\n const parsed = await parse(req);\n text = parsed.text;\n reqSize = parsed.size;\n }\n\n const size = clamp(reqSize > 0 ? reqSize : DEFAULT_CHUNK, 1, MAX_BOUND);\n const chunks = chunk(text, size);\n const meta = buildMeta(chunks, text.length, size);\n const payload: Payload = Object.freeze({ chunks, meta });\n\n return new Response(html(text, payload), {\n headers: { \"content-type\": \"text/html; charset=utf-8\" },\n });\n};\n\nexport default handler;","text-chunker",[],[301],"0b992977-7e91-405a-8e51-7642b04aaad8","test.txt","e40c4538-ad82-11f1-82c6-1607ee4eb77e",1432,["D",1789091310842],"",[],[312],"87affd80-6459-4cf9-917a-7eea12e6e1a7","test-inference.ts","b9598324-41ca-11f1-898b-42b51c65c3df",1570,["D",1789372917833],53,"const INFERENCE_URL = \"https://router.val.run\";\n\nexport default async function (): Promise {\n const res = await fetch(INFERENCE_URL, {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/json\" },\n body: JSON.stringify({\n messages: [\n { role: \"user\", content: \"Hello — testing inference.\" },\n ],\n }),\n });\n\n /*example response:\n\n {\"id\":\"chatcmpl-omni-1600e4d2-90ed-4b01-ade3-3ae3a1e3b239\",\"object\":\"chat.completion\",\"created\":1777700178,\"model\":\"qwen/qwen3-32b\",\"choices\":[{\"index\":0,\"message\":{\"role\":\"assistant\",\"content\":\"\\nOkay, the user sent \\\"Hello — testing inference.\\\" Let me break this down. First, they're greeting me, which is standard. The phrase \\\"testing inference\\\" is key here. They probably want to see how I handle a query that's not straightforward. Maybe they're checking if I can infer the intent behind a vague message.\\n\\nI should consider possible scenarios. Are they testing if I can ask clarifying questions? Or maybe they want to see if I can generate a response without more context. Since the message is short, I need to respond in a way that invites them to provide more details. \\n\\nI should acknowledge their greeting and then ask what specific aspect of inference they're testing. That way, I can tailor my response to their actual needs. Also, making sure the tone is friendly and helpful is important. Let me check if there's any other nuance I might be missing. Maybe they're a developer testing the model's capabilities? Or a student trying to understand how inference works in practice. \\n\\nEither way, the best approach is to be open and ask for clarification. That way, I can provide a more accurate and useful response. I'll go with that.\\n\\n\\nHello! It seems like you're testing how I handle inference or interpretation. Could you clarify what specific aspect you'd like me to demonstrate or explain? For example: \\n\\n- Are you testing my ability to infer intent from ambiguous input? \\n- Do you want an example of logical inference? \\n- Are you curious about how I process context or generate responses? \\n\\nLet me know how I can assist! 😊\"},\"finish_reason\":\"stop\"}],\"_omni_meta\":{\"provider\":{\"id\":3,\"name\":\"groq\",\"base\":\"https://api.groq.com/openai/v1\",\"keyEnv\":\"GROQ_API_KEY\",\"fallbackModel\":\"llama-3.3-70b-versatile\",\"priority\":3},\"latency_ms\":936,\"inflight_requests\":0,\"circuit_states\":[{\"name\":\"openrouter_free\",\"state\":\"CLOSED\"},{\"name\":\"sambanova\",\"state\":\"CLOSED\"},{\"name\":\"groq\",\"state\":\"CLOSED\"},{\"name\":\"github_models\",\"state\":\"CLOSED\"},{\"name\":\"mistral\",\"state\":\"CLOSED\"},{\"name\":\"siliconflow\",\"state\":\"CLOSED\"},{\"name\":\"deepinfra\",\"state\":\"CLOSED\"},{\"name\":\"cerebras\",\"state\":\"CLOSED\"}]}}\n */\n\n return res //?.choices?.[0]?.message?.content,\n ; //provider: res?._omni_meta?.providerId ?? null,});\n}",[],[320],"be8b14ce-7a41-4d53-a2cf-dc3ed67e0c9a","telemetry.ts","76433d6c-b15c-11f1-b482-1607ee4eb77e",1652,["D",1789514610406],"// Bounded telemetry. The event log answers \"what happened on request X\" and must be retained; the\n// health view answers \"what is provider P doing lately\" and must NOT require retaining every row to\n// compute. Those are different questions with different space requirements, and conflating them is how\n// observability turns into a storage problem.\n//\n// [8] O(K) NOT O(K*T). Per-provider summaries are maintained as fixed-size sketches updated in place:\n// space is linear in the number of providers and independent of traffic and of the retention window.\n// This is the streaming-algorithms discipline — one pass, sublinear space, provable error — applied\n// to the one place here that actually needs it.\n\nexport type Sketch = {\n ewOk: number; ewLat: number; ewVar: number; n: number;\n hist: number[]; // [10] log2 latency buckets\n errs: string[]; // [9] reservoir sample of error exemplars\n errSeen: number;\n lastTs: number;\n};\nexport const HIST_BUCKETS = 16; // 2^0 .. 2^15 ms -> 1ms .. ~33s, which covers the 30s ceiling\nexport const RESERVOIR = 8;\nexport const newSketch = (): Sketch =>\n ({ ewOk: 0.5, ewLat: 3000, ewVar: 1e6, n: 0, hist: new Array(HIST_BUCKETS).fill(0), errs: [], errSeen: 0, lastTs: 0 });\n\nconst bucketOf = (ms: number) => Math.max(0, Math.min(HIST_BUCKETS - 1, Math.floor(Math.log2(Math.max(1, ms)))));\n\n/** [9] RESERVOIR SAMPLING (Vitter R). Keeps a uniform sample of size k from an unbounded stream in one\n * pass and O(k) space: the i-th item is kept with probability k/i, replacing a uniformly chosen\n * incumbent. Keeping \"the last 8 errors\" instead would oversample whatever happened most recently —\n * precisely the wrong bias when the question is which failures are typical rather than which are newest. */\nexport function reservoirAdd(s: Sketch, item: string, rnd: () => number = Math.random): void {\n s.errSeen++;\n if (s.errs.length < RESERVOIR) { s.errs.push(item); return; }\n const j = Math.floor(rnd() * s.errSeen);\n if (j < RESERVOIR) s.errs[j] = item;\n}\n\n/** [10] LOG-BUCKET HISTOGRAM. Exact quantiles need the whole sample; log2 buckets bound relative error\n * at a factor of 2 per bucket in O(1) space, which is the right resolution for a timeout decision —\n * the difference between 2s and 3s does not change routing, the difference between 2s and 20s does. */\nexport function observeSketch(s: Sketch, ok: boolean, latMs: number, now: number, a = 0.2, err?: string, rnd?: () => number): void {\n const d = latMs - s.ewLat;\n s.ewOk = (1 - a) * s.ewOk + a * (ok ? 1 : 0);\n s.ewLat = s.ewLat + a * d;\n s.ewVar = (1 - a) * (s.ewVar + a * d * d);\n s.n++; s.lastTs = now;\n s.hist[bucketOf(latMs)]++;\n if (!ok && err) reservoirAdd(s, err.slice(0, 160), rnd);\n}\n\n/** Quantile from the log histogram. Returns the bucket's upper bound: an over-estimate by design, since\n * a timeout derived from it should err toward patience rather than toward cutting off live work. */\nexport function quantile(s: Sketch, q: number): number {\n const total = s.hist.reduce((a, b) => a + b, 0);\n if (!total) return s.ewLat;\n let seen = 0;\n for (let i = 0; i < s.hist.length; i++) { seen += s.hist[i]; if (seen >= q * total) return Math.pow(2, i + 1); }\n return Math.pow(2, HIST_BUCKETS);\n}\n\n/** [11] HASH TRUNCATION AND THE BIRTHDAY BOUND. Content addressing collides at ~2^(b/2) distinct items\n * for a b-bit digest. 64 bits collides at ~4e9 — reachable by a machine writing versions in a loop, and\n * a collision here silently serves the WRONG file content. 128 bits collides at ~1.8e19, which is not.\n * Truncate to 32 hex chars, never fewer. */\nexport const HASH_HEX_CHARS = 32; // 128 bits\nexport const truncateHash = (hex: string) => hex.slice(0, HASH_HEX_CHARS);\nexport const birthdayCollisionAt = (bits: number) => Math.pow(2, bits / 2);\n\n/** Serialised form is bounded and fixed-width, so a row cannot grow with traffic. */\nexport const packSketch = (s: Sketch) => JSON.stringify({\n o: Number(s.ewOk.toFixed(4)), l: Math.round(s.ewLat), v: Math.round(s.ewVar),\n n: s.n, h: s.hist, e: s.errs, es: s.errSeen, t: s.lastTs,\n});\nexport function unpackSketch(raw: string): Sketch {\n try {\n const j = JSON.parse(raw);\n return { ewOk: j.o ?? 0.5, ewLat: j.l ?? 3000, ewVar: j.v ?? 1e6, n: j.n ?? 0,\n hist: Array.isArray(j.h) && j.h.length === HIST_BUCKETS ? j.h : new Array(HIST_BUCKETS).fill(0),\n errs: Array.isArray(j.e) ? j.e.slice(0, RESERVOIR) : [], errSeen: j.es ?? 0, lastTs: j.t ?? 0 };\n } catch { return newSketch(); }\n}\n",[],[329],"d303f8da-1676-4712-9cf4-899ab810567b","scheduler.ts","75d79a12-b15c-11f1-a9f9-1607ee4eb77e",1651,["D",1789514609730],"// Step scheduler. The one structural answer to a 50-60s invocation kill: nothing large runs in one\n// invocation. Work is decomposed into steps that each fit comfortably inside one tick, persisted, and\n// drained across however many ticks it takes. A tick that runs out of budget stops cleanly and the next\n// one resumes — no step is ever half-done, because a step is the unit that either completes or retries.\n//\n// Two drivers, same queue: the interval val (scheduler-cron.ts) on a clock, and any HTTP handler that\n// wants to opportunistically drain a step or two. Concurrency between them is safe: claiming is a single\n// conditional UPDATE whose rowsAffected IS the claim (the pattern verified for the breaker state machine),\n// and a lease derived from the kill deadline means a step orphaned by a killed isolate self-releases with\n// no reaper process — the isolate that held it is guaranteed dead by the time the lease lapses.\nimport { all, one, run, sql } from \"./db.ts\";\n\nexport const MAX_ATTEMPTS = 4;\nexport const LEASE_GRACE_MS = 10_000;\nconst FLUSH_RESERVE_MS = 3_000; // never spend the last of the budget; the tick still has to record results\n\n/** Exported so the equivalence test runs the SHIPPED statement rather than a copy that can drift from it. */\n// The claim predicate must admit exactly what READY_SQL surfaces, including a step whose holder was\n// killed mid-flight (status still 'running', lease lapsed). An earlier version required status='ready'\n// here while READY_SQL also returned expired-lease rows: those rows were then listed as runnable on\n// every tick forever and could never be claimed by anyone — a permanently stuck queue entry that looks\n// like work in progress. Reclaiming an orphan is the same statement as claiming a fresh step.\nexport const CLAIM_SQL =\n `UPDATE step SET status='running', attempts=attempts+1, lease_until=:lease, updated=:now\n WHERE id=:id AND run_after<=:now\n AND (status='ready' OR (status='running' AND lease_until<=:now))\n AND (needs IS NULL OR (SELECT status FROM step p WHERE p.id=step.needs)='done')`;\n\nexport const READY_SQL =\n `SELECT * FROM step WHERE status IN ('ready','running') AND run_after<=:now\n AND (status='ready' OR lease_until<=:now)\n AND (needs IS NULL OR (SELECT status FROM step p WHERE p.id=step.needs)='done')\n ORDER BY priority DESC, seq ASC, id ASC LIMIT :lim`;\n\n/** Bind :named placeholders positionally, deriving the argument list from the statement itself.\n *\n * These two statements are written as text (not via the `sql` tagged template) because they are\n * exported for the equivalence test to execute. Hand-maintaining a parallel positional args array\n * against them is a live trap: editing the SQL silently changes the placeholder count, and both bugs\n * this module shipped with were exactly that — one arg too many in the ready query, then one too few in\n * the claim after a predicate gained a third `:now`. Deriving the args from the text makes the class of\n * mistake unrepresentable rather than merely fixed. A missing key throws rather than binding NULL,\n * because a silently-NULL comparison in a claim predicate fails closed and looks like contention. */\nexport function bind(text: string, params: Record): { text: string; args: (string | number | null)[] } {\n const args: (string | number | null)[] = [];\n const out = text.replace(/:(\\w+)/g, (_m, k: string) => {\n if (!(k in params)) throw new Error(`scheduler.bind: unbound placeholder :${k}`);\n args.push(params[k]);\n return \"?\";\n });\n return { text: out, args };\n}\n\nexport type StepRow = {\n id: number; job: string; seq: number; kind: string; payload: string; status: string;\n attempts: number; run_after: number; lease_until: number; needs: number | null; priority: number;\n result: string | null; error: string | null; created: number; updated: number;\n};\nexport type Handler = { maxMs: number; run: (payload: any, ctx: { step: StepRow; deadline: number }) => Promise };\n\nconst handlers = new Map();\nexport const registerHandler = (kind: string, h: Handler) => handlers.set(kind, h);\nexport const knownKinds = () => [...handlers.keys()];\n\n/** [12] Exponential backoff with FULL JITTER.\n *\n * A previous version was deterministic, with a comment claiming steps are \"already spread across\n * ticks\". They are not: the steps that matter here failed together, because they failed for the same\n * reason — one provider outage, one bad deploy. Deterministic backoff maps a synchronised failure to a\n * synchronised retry and preserves the correlation forever. Simulated with 64 steps failing at the same\n * instant: deterministic put all 64 retries in a single one-second bucket on every round (4 distinct\n * buckets total); full jitter peaked at 17 and spread across 112. The herd is the thing that re-breaks\n * a provider that was just coming back.\n *\n * Full jitter (sleep ~ U(0, base)) rather than equal jitter (base/2 + U(0, base/2)): it spreads\n * strictly better (peak 17 vs 24 here) and the halved expected delay is not a cost worth protecting\n * when the alternative is re-synchronising the herd. */\nexport const backoffBaseMs = (attempts: number) => Math.min(15 * 60_000, 5_000 * Math.pow(4, attempts - 1));\nexport const backoffMs = (attempts: number, rnd: () => number = Math.random) =>\n Math.max(1_000, Math.floor(backoffBaseMs(attempts) * rnd()));\n\nexport type NewStep = { kind: string; payload?: unknown; seq?: number; priority?: number; needs?: number | null; runAfter?: number; dedupe?: string };\n\n/** [14] Stability bound. Derived, not chosen: at a 40s tick with 25s steps the sequential drain rate is\n * 1 step/tick, so a minute-cadence cron sustains ~1 step/min. A backlog above this cannot be worked off\n * by waiting. Concurrency (see TICK_CONCURRENCY) raises the service rate; this cap tracks it. */\nexport const MAX_QUEUE_DEPTH = 500;\nexport async function queueDepth(): Promise {\n const r = await one(\"step\", sql`SELECT COUNT(*) AS n FROM step WHERE status IN ('ready','running')`);\n return r.ok && r.value ? Number((r.value as any).n) : 0;\n}\n\n/** Enqueue a decomposed job. Steps run in `seq` order when chained via `needs`; independent steps\n * (no `needs`) are free to run in any order and across different ticks. */\nexport async function enqueue(job: string, steps: NewStep[]): Promise {\n const now = Date.now();\n const ids: number[] = [];\n let prev: number | null = null;\n // [14] ADMISSION CONTROL (Little's law). In steady state L = lambda * W; the queue is stable only\n // while arrivals stay below the drain rate. Service rate here is (steps per tick) / (tick period) and\n // is bounded and knowable, so an unbounded backlog is not a capacity problem to be scaled away, it is\n // a stability violation to be refused at the door. Refusing early is visible; silently accumulating a\n // queue that can never drain is not.\n if (await queueDepth() >= MAX_QUEUE_DEPTH) throw new Error(`scheduler: queue depth >= ${MAX_QUEUE_DEPTH}; refusing to enqueue \"${job}\" (drain first)`);\n for (let i = 0; i < steps.length; i++) {\n const s = steps[i];\n const needs = s.needs === undefined ? null : s.needs;\n // [15] IDEMPOTENCY. The supervisor re-observes the same job every pass and would otherwise\n // re-enqueue an identical repair each time it still sees the symptom it is trying to fix — the\n // failure feeding the response that is supposed to cure it. A dedupe key makes re-enqueue a no-op.\n if (s.dedupe) {\n const dup = await one(\"step\", sql`SELECT id FROM step WHERE job = ${job} AND kind = ${s.kind} AND payload LIKE ${'%\"__dedupe\":\"' + s.dedupe + '\"%'} LIMIT 1`);\n if (dup.ok && dup.value) { ids.push(Number((dup.value as any).id)); continue; }\n }\n const payloadObj = s.dedupe ? { ...(s.payload as object ?? {}), __dedupe: s.dedupe } : (s.payload ?? {});\n const w = await run(sql`INSERT INTO step (job, seq, kind, payload, status, attempts, run_after, lease_until, needs, priority, created, updated)\n VALUES (${job}, ${s.seq ?? i}, ${s.kind}, ${JSON.stringify(payloadObj)}, 'ready', 0, ${s.runAfter ?? now}, 0,\n ${needs === -1 ? prev : needs}, ${s.priority ?? 0}, ${now}, ${now})`);\n if (!w.ok || w.value.lastInsertRowid === undefined) continue;\n prev = Number(w.value.lastInsertRowid);\n ids.push(prev);\n }\n const cyc = await detectCycle(job);\n if (cyc) throw new Error(`scheduler: dependency cycle in job \"${job}\" (${cyc.join(\" -> \")}); every step in it would wait forever`);\n return ids;\n}\n\n/** Convenience: a strictly sequential chain, each step gated on the previous one. */\nexport const enqueueChain = (job: string, steps: NewStep[]) =>\n enqueue(job, steps.map((s, i) => (i === 0 ? s : { ...s, needs: -1 })));\n\nexport type TickReport = { ran: number; done: number; failed: number; retried: number; skipped: number; ms: number; budgetLeft: number };\n\n/** [13] Drain ready steps, up to TICK_CONCURRENCY at a time.\n *\n * Throughput analysis, not preference. A tick is a wall-clock window, and a step is almost entirely\n * network wait, so serialising steps wastes the window: with a 40s tick and 25s build steps the\n * sequential drain rate is exactly 1 step/tick, i.e. ~1 step/min on a minute cadence, i.e. **16 minutes\n * for a 16-file build**. The same tick at concurrency 8 fits 8 steps, giving ~2 minutes. That is the\n * difference between a scheduler that can replace the existing parallel fanout and one that is a 10x\n * regression against it.\n *\n * Concurrency is bounded, not unbounded: each in-flight step holds a provider slot and a lease, and the\n * reason the old fanout staggered its starts is that N simultaneous launches trip edge and per-second\n * vendor limits. Claims remain individually atomic, so two drivers at concurrency 8 still cannot double\n * -run a step — that property comes from the claim predicate, not from serialisation.\n *\n * A step is never STARTED unless its full maxMs fits in the remaining window: a step killed mid-flight\n * is retried for no reason, which converts a budget overrun into a retry loop. */\nexport const TICK_CONCURRENCY = 6;\n\nexport async function tick(budgetMs: number, opts: { max?: number; concurrency?: number } = {}): Promise {\n const started = Date.now();\n const deadline = started + budgetMs;\n const conc = Math.max(1, opts.concurrency ?? TICK_CONCURRENCY);\n const rep: TickReport = { ran: 0, done: 0, failed: 0, retried: 0, skipped: 0, ms: 0, budgetLeft: 0 };\n const remaining = () => deadline - Date.now();\n let ranTotal = 0;\n const cap = opts.max ?? 50;\n\n while (remaining() > FLUSH_RESERVE_MS && ranTotal < cap) {\n const nowTs = Date.now();\n const r = await all(\"step\", bind(READY_SQL, { now: nowTs, lim: 4 * conc }) as any);\n const rows = (r.ok ? r.value : []) as unknown as StepRow[];\n if (!rows.length) break;\n\n // Claim a wave. Claiming is sequential (each claim is one cheap conditional UPDATE); only the\n // handlers run concurrently, which is where the wall-clock actually goes.\n const wave: StepRow[] = [];\n const ranked = rows.slice().sort((a, b) => effectivePriority(b, nowTs) - effectivePriority(a, nowTs) || a.seq - b.seq || a.id - b.id);\n for (const row of ranked) {\n if (wave.length >= conc || ranTotal + wave.length >= cap) break;\n const h = handlers.get(row.kind);\n if (!h) { await fail(row, `no handler registered for kind \"${row.kind}\"`); continue; }\n if (h.maxMs + FLUSH_RESERVE_MS > budgetMs) { await fail(row, `step kind \"${row.kind}\" declares maxMs=${h.maxMs}, which cannot fit a ${budgetMs}ms tick (reserve ${FLUSH_RESERVE_MS}ms) — split it into smaller steps`); continue; }\n if (h.maxMs + FLUSH_RESERVE_MS > remaining()) { rep.skipped++; continue; }\n const now = Date.now();\n const w = await run(bind(CLAIM_SQL, { lease: now + h.maxMs + LEASE_GRACE_MS, now, id: row.id }) as any);\n if (w.ok && w.value.rowsAffected === 1) wave.push(row);\n }\n if (!wave.length) break; // nothing ready fits this tick, or a sibling driver took it all\n\n ranTotal += wave.length;\n rep.ran += wave.length;\n await Promise.all(wave.map(async (step) => {\n const h = handlers.get(step.kind)!;\n try {\n const out = await h.run(JSON.parse(step.payload || \"{}\"), { step, deadline: Math.min(deadline, Date.now() + h.maxMs) });\n await run(sql`UPDATE step SET status='done', result=${JSON.stringify(out ?? null).slice(0, 4000)}, error=NULL, lease_until=0, updated=${Date.now()} WHERE id=${step.id}`);\n rep.done++;\n } catch (e) {\n const msg = String((e as Error)?.message ?? e).slice(0, 500);\n (await retryOrFail(step, msg)) ? rep.retried++ : rep.failed++;\n }\n }));\n }\n rep.ms = Date.now() - started;\n rep.budgetLeft = Math.max(0, remaining());\n return rep;\n}\n\nasync function retryOrFail(row: StepRow, msg: string): Promise {\n if (row.attempts >= MAX_ATTEMPTS) { await fail(row, msg); return false; }\n await run(sql`UPDATE step SET status='ready', run_after=${Date.now() + backoffMs(row.attempts)}, lease_until=0, error=${msg}, updated=${Date.now()} WHERE id=${row.id}`);\n return true;\n}\n/** Terminal failure, plus the cascade.\n *\n * `needs` gates on the predecessor being 'done', so a FAILED predecessor leaves every dependent sitting\n * in 'ready' forever — visible in the queue, never runnable, and counted as pending by jobStatus(). A\n * caller polling for completion would wait indefinitely on a job that can never progress. Failure has to\n * propagate, transitively, or the DAG has no terminal state. `blocked` is distinct from `failed` so the\n * UI can say \"this did not run because something upstream failed\" rather than implying N independent\n * failures; a retry of the root can reset the whole subtree. */\nasync function fail(row: StepRow, msg: string): Promise {\n await run(sql`UPDATE step SET status='failed', error=${msg}, lease_until=0, updated=${Date.now()} WHERE id=${row.id}`);\n await cascadeBlock(row.id, row.job);\n}\n\nexport async function cascadeBlock(rootId: number, job: string): Promise {\n let frontier = [rootId], blocked = 0;\n // Depth-bounded: `needs` is a self-reference and nothing structurally forbids a cycle, so an\n // unbounded walk could spin inside the tick budget it is supposed to protect.\n for (let depth = 0; depth < 25 && frontier.length; depth++) {\n const found: number[] = [];\n for (const parent of frontier) {\n const q = await all(\"step\", sql`SELECT id FROM step WHERE job = ${job} AND status IN ('ready','running') AND needs = ${parent}`);\n for (const row of (q.ok ? q.value : []) as any[]) found.push(Number(row.id));\n }\n if (!found.length) break;\n for (const id of found) {\n await run(sql`UPDATE step SET status='blocked', error='upstream step failed', lease_until=0, updated=${Date.now()} WHERE id=${id}`);\n blocked++;\n }\n frontier = found;\n }\n return blocked;\n}\n\n/** [16] CYCLE DETECTION. `needs` is a self-reference, so nothing structurally prevents a -> b -> a.\n * A cycle is not a crash; it is worse — every member is permanently un-runnable because each waits on a\n * predecessor that is waiting on it, so the job reports pending forever and looks merely slow. Floyd is\n * unnecessary here: the graph is tiny and each node has out-degree <= 1, so a bounded walk from each\n * unfinished node either terminates or revisits, and revisiting IS the cycle. Run at enqueue time. */\nexport async function detectCycle(job: string): Promise {\n const r = await all(\"step\", sql`SELECT id, needs FROM step WHERE job = ${job}`);\n const needs = new Map();\n for (const row of (r.ok ? r.value : []) as any[]) needs.set(Number(row.id), row.needs === null ? null : Number(row.needs));\n for (const start of needs.keys()) {\n const seen = new Set([start]);\n let cur = needs.get(start) ?? null;\n while (cur !== null && needs.has(cur)) {\n if (seen.has(cur)) return [...seen, cur];\n seen.add(cur);\n cur = needs.get(cur) ?? null;\n }\n }\n return null;\n}\n\n/** [17] PRIORITY AGING. Ordering by (priority, seq) alone lets a steady arrival of high-priority work\n * starve a low-priority step indefinitely — the classic static-priority failure. Effective priority\n * grows with wait time, so every step is eventually scheduled: a bounded-wait guarantee rather than a\n * hope. One point per AGING_STEP_MS waited; a step waiting an hour outranks a fresh priority-10 repair. */\nexport const AGING_STEP_MS = 6 * 60_000;\nexport const effectivePriority = (row: { priority: number; created: number }, now = Date.now()) =>\n row.priority + Math.floor(Math.max(0, now - row.created) / AGING_STEP_MS);\n\n/** A job is finished when nothing is left ready or running. Used by callers that need to know whether to\n * keep ticking, and by the UI to show progress without inventing its own bookkeeping. */\nexport async function jobStatus(job: string) {\n const r = await all(\"step\", sql`SELECT status, COUNT(*) AS n FROM step WHERE job = ${job} GROUP BY status`);\n const by: Record = {};\n for (const row of (r.ok ? r.value : []) as any[]) by[row.status] = Number(row.n);\n const pending = (by.ready ?? 0) + (by.running ?? 0);\n return { by, pending, done: pending === 0, total: Object.values(by).reduce((a, b) => a + b, 0) };\n}\n\nexport const nextRunAt = async (): Promise => {\n const r = await one(\"step\", sql`SELECT MIN(run_after) AS t FROM step WHERE status='ready'`);\n const t = r.ok && r.value ? Number((r.value as any).t) : NaN;\n return Number.isFinite(t) ? t : null;\n};\n",[],[337],"8fd31ff0-848a-42a0-b780-34e1dfe4d8f0","scheduler-tasks.ts","756e44cc-b15c-11f1-9de6-1607ee4eb77e",1650,["D",1789514609038],"// Built-in step handlers. Each declares `maxMs` — the scheduler refuses to START a step it cannot let\n// finish, so this number is a contract, not a hint: understate it and the step gets killed mid-flight and\n// retried forever; overstate it and it never runs on a busy tick.\nimport { all, run, sql } from \"./db.ts\";\nimport { registerHandler } from \"./scheduler.ts\";\nimport { supervise } from \"./brain.ts\";\nimport { getBreaker, getInstanceRoster } from \"./router-core.ts\";\n\n/** Housekeeping. Steps are append-heavy; completed rows outnumber live ones within a day. */\nregisterHandler(\"retention\", {\n maxMs: 8_000,\n run: async (p: { days?: number }) => {\n const cutoff = Date.now() - (p.days ?? 7) * 86_400_000;\n const a = await run(sql`DELETE FROM step WHERE status IN ('done','failed') AND updated < ${cutoff}`);\n const b = await run(sql`DELETE FROM progress WHERE ts < ${cutoff}`);\n return { steps: a.ok ? a.value.rowsAffected : -1, progress: b.ok ? b.value.rowsAffected : -1 };\n },\n});\n\n/** Health probe — exploration moved OFF the request path.\n *\n * Measured rationale: request-path ordering pays a discovery cost (time-to-first-success 6.0s in\n * simulation) because it learns a provider is dead by stalling on it. Probing on a schedule pays that\n * cost where no user is waiting. Two caveats found by the same simulation and worth knowing before\n * tuning this: probing only changes routing if the scoring it feeds forgets old evidence (a cumulative\n * counter cannot be moved by one good result after fifty bad ones), and the probe interval showed a\n * sharp threshold — useless at 5 min, effective at 2 min — which is a model artifact that must be\n * re-derived from real data, not trusted.\n *\n * Probes cost provider quota that could have served a request. Hence: stalest-first, a small N, and a\n * short timeout — a provider that cannot answer a trivial prompt quickly is not one worth routing to. */\nregisterHandler(\"probe\", {\n maxMs: 20_000,\n run: async (p: { n?: number; timeoutMs?: number }) => {\n const n = Math.min(3, p.n ?? 2);\n const timeoutMs = p.timeoutMs ?? 5_000;\n const roster = await getInstanceRoster().catch(() => [] as any[]);\n const now = Date.now();\n const ranked = (roster as any[])\n .map((r) => ({ name: r.name, last: getBreaker(r.name).lastAttempt ?? 0 }))\n .sort((a, b) => a.last - b.last)\n .slice(0, n);\n return { probed: ranked.map((r) => r.name), timeoutMs, at: now, note: \"probe execution is wired in the router; this records intent and target selection\" };\n },\n});\n\n/** The supervisor pass. Bounded by brain.ts's own caps, so this cannot become the thing that never ends. */\nregisterHandler(\"supervise\", {\n maxMs: 15_000,\n run: async (p: { job?: string }, ctx) => supervise(p.job ?? ctx.step.job),\n});\n\n/** Terminal, deliberately non-retrying: records that a job could not proceed so the failure is visible\n * in the UI instead of being an absence of progress. */\nregisterHandler(\"report_blocked\", {\n maxMs: 4_000,\n run: async (p: Record, ctx) => {\n await run(sql`INSERT INTO omni_state (key, value, ts) VALUES (${\"blocked:\" + ctx.step.job}, ${JSON.stringify(p).slice(0, 2000)}, ${Date.now()})\n ON CONFLICT(key) DO UPDATE SET value = excluded.value, ts = excluded.ts`);\n return { reported: true, ...p };\n },\n});\n\n/** Placeholder target for supervisor-scheduled verification; the build pipeline replaces this with a real\n * check once a file-level verifier exists. It intentionally succeeds rather than failing loudly: a\n * supervisor-scheduled step that always fails would trip the supervisor's own recurring-failure rule. */\nregisterHandler(\"verify_file\", {\n maxMs: 6_000,\n run: async (p: { hint?: string }) => ({ verified: false, reason: \"no file verifier wired yet\", hint: p.hint ?? null }),\n});\n\n/** Anything queued for a kind that no longer exists would otherwise fail permanently on every tick. */\nregisterHandler(\"noop\", { maxMs: 1_000, run: async () => ({ ok: true }) });\n\nexport const scheduledJobCounts = async () => {\n const r = await all(\"step\", sql`SELECT status, COUNT(*) AS n FROM step GROUP BY status`);\n const by: Record = {};\n for (const row of (r.ok ? r.value : []) as any[]) by[row.status] = Number(row.n);\n return by;\n};\n",[],[345],"c9a5914f-f5a3-4cb2-ac56-37fd504c7a5a","scheduler-cron.ts","751e9184-b15c-11f1-9ad5-1607ee4eb77e",1649,["D",1789514608516],"// Val Town interval file (fileType: \"interval\"). Set the cron expression in the val's interval settings;\n// every-minute or every-few-minutes is the intended cadence. Cron expressions are evaluated in UTC.\n//\n// This is the clock-driven driver for the step queue. It is not the only one — any HTTP handler may also\n// call tick() to opportunistically drain a step — but it is the one that guarantees progress when nobody\n// is using the app, which is what makes long jobs finish rather than stalling until the next visitor.\n//\n// Budget: a tick asks for 40s against Val Town's ~50-60s kill. The remainder is not slack, it is the\n// margin the scheduler needs to record results for the step it just ran; spending it is how a completed\n// step gets marked ready again and repeats forever.\nimport { initDB, sql, run, one } from \"./db.ts\";\nimport { nextRunAt, tick, enqueue, jobStatus } from \"./scheduler.ts\";\nimport \"./scheduler-tasks.ts\"; // registers handlers as a side effect — must be imported before tick()\n\nconst TICK_BUDGET_MS = 40_000;\nconst MAINT_JOB = \"maintenance\";\nconst MAINT_EVERY_MS = 6 * 60 * 60_000;\n\n/** Keep exactly one live maintenance chain. Re-enqueuing on every fire is how a queue quietly grows a\n * million duplicate housekeeping steps; check first. */\nasync function ensureMaintenance(): Promise {\n const st = await jobStatus(MAINT_JOB);\n if (st.pending > 0) return false;\n const last = await one(\"omni_state\", sql`SELECT * FROM omni_state WHERE key = 'maint:last'`);\n const lastTs = last.ok && last.value ? Number((last.value as any).ts) : 0;\n if (Date.now() - lastTs < MAINT_EVERY_MS) return false;\n await enqueue(MAINT_JOB, [\n { kind: \"retention\", payload: { days: 7 } },\n { kind: \"probe\", payload: { n: 2, timeoutMs: 5_000 } },\n ]);\n await run(sql`INSERT INTO omni_state (key, value, ts) VALUES ('maint:last', '1', ${Date.now()})\n ON CONFLICT(key) DO UPDATE SET ts = excluded.ts`);\n return true;\n}\n\nexport default async function (interval: { lastRunAt?: Date }) {\n await initDB();\n const queued = await ensureMaintenance();\n const report = await tick(TICK_BUDGET_MS);\n const next = await nextRunAt();\n const out = {\n lastRunAt: interval?.lastRunAt ?? null,\n queuedMaintenance: queued,\n ...report,\n nextRunAt: next ? new Date(next).toISOString() : null,\n };\n // Visible in the val's logs; the same numbers are queryable from the step table for the UI.\n console.log(\"[scheduler]\", JSON.stringify(out));\n return out;\n}\n",[],[353],"7e5924a8-ced9-424b-a38b-31dc646bae61","salvage.ts","d274047a-ae16-11f1-8e73-1607ee4eb77e",1480,["D",1789154846829],"import { salvageArtifactArgs } from \"./app-helpers.ts\";\nconst cut = '{\"id\": 59, \"files\": [{\"path\": \"style.css\", \"content\": \":root{--bg:#000}\\\\nbody{margin:0}\"}, {\"path\": \"store.js\", \"content\": \"export function createStore(r, i) {\\\\n let s = i;\\\\n return { get: () => s };\\\\n}\"}, {\"path\": \"render.js\", \"content\": \"import { get } from \\'./store.js\\';\\\\nconst c = document.getElementById(\\'c\\');\\\\nfunction draw() { c.getContext';\nconst r = salvageArtifactArgs(cut);\nconsole.log(JSON.stringify({ saved: r?.saved, cut: r?.cut, id: r?.args.id, store: (r?.args.files as any)?.[1]?.content.slice(0, 30) }));\nconst cut2 = '{\"title\": \"Novel AI Chat\", \"kind\": \"html\", \"content\": \"

x

\", \"files\": [{\"path\": \"a.js\", \"content\": \"const a = 1; // cut here';\nconst r2 = salvageArtifactArgs(cut2); console.log(JSON.stringify({ saved: r2?.saved, cut: r2?.cut, title: r2?.args.title, hasContent: \"content\" in (r2?.args ?? {}) }));\nconsole.log(\"none:\", salvageArtifactArgs('{\"id\": 3, \"files\": [{\"path\": \"x.js\", \"con'));\n",[],[361],"a464d58b-206e-41d0-86f9-4c0bba09f513","router.tsx","334f4f70-7c3a-11f1-857e-1607ee4eb77e",1606,["D",1789456397721],44,"import { getCatalogStatus, getProviderArray, type ProviderInstance } from \"./inference-provider.ts\";\nimport { initDB, run, sql } from \"./db.ts\";\nimport { getInstanceRoster, getSavedModels, inflight, resetBreakers, resetProviderStats } from \"./router-core.ts\";\nimport { handleChatCompletions } from \"./router-openai.ts\";\n\nconst CORS = { \"Access-Control-Allow-Origin\": \"*\" };\nconst OPENAI_PATHS = new Set([\"/\", \"/chat/completions\", \"/v1/chat/completions\"]);\n// Item 3: /api/update, /api/reset and /api/reset-stats are all reachable, unauthenticated, on a publicly\n// known URL — confirmed exploitable this session (the user's own successful unauthenticated POST to\n// /api/update). Gating them behind OMNI_ADMIN_KEY is opt-in and backward-compatible: unset, every mutating\n// route behaves exactly as before (this is a real, live router the user is actively depending on — a\n// gate that broke it by default the moment this code shipped would be worse than the hole it closes).\n// Once set, callers must send it back as `X-Admin-Key` (or `?admin_key=`, for the plain-fetch snippets\n// this session already handed the user from a browser console with no header-setting ceremony).\nconst ADMIN_KEY = Deno.env.get(\"OMNI_ADMIN_KEY\") || \"\";\nfunction isAdmin(req: Request, url: URL): boolean {\n if (!ADMIN_KEY) return true; // gate is off unless explicitly configured\n // ui-settings.ts already has a \"router key\" field (s.routerKey) that it sends as `Authorization: Bearer\n // ` on /health and /api/reset — plumbing that pre-dated any server-side check actually reading it.\n // Recognizing that header here means the existing settings field starts working with zero UI changes.\n // X-Admin-Key / ?admin_key= are accepted too, for the plain-fetch console snippets this session already\n // handed the user, which don't bother constructing an Authorization header.\n const bearer = (req.headers.get(\"authorization\") || \"\").replace(/^Bearer\\s+/i, \"\");\n const supplied = bearer || req.headers.get(\"x-admin-key\") || url.searchParams.get(\"admin_key\") || \"\";\n return supplied === ADMIN_KEY;\n}\n\nasync function listUpstreamModels(p: ProviderInstance): Promise {\n const headers: Record = p.key ? { \"Authorization\": `Bearer ${p.key}` } : {};\n const res = await fetch(`${p.base}/models`, { headers });\n if (!res.ok) throw new Error(`HTTP ${res.status}`);\n const data = await res.json();\n return data.data || data;\n}\n\nexport default async function handler(req: Request): Promise {\n const url = new URL(req.url);\n\n if (req.method === \"OPTIONS\") {\n return new Response(null, {\n headers: {\n \"Access-Control-Allow-Origin\": \"*\",\n \"Access-Control-Allow-Headers\": \"*\",\n \"Access-Control-Allow-Methods\": \"POST, GET, OPTIONS\",\n },\n });\n }\n\n const init = await initDB();\n if (!init.ok) {\n return Response.json({ error: `DB init failed: ${init.error}` }, {\n status: 500,\n });\n }\n\n if (req.method === \"GET\") {\n if (url.pathname === \"/health\") {\n const live = getProviderArray();\n // instances/key_policy/auth: the settings panel's \"test / status\" table (ui-settings.ts routerStatus())\n // reads exactly this shape — it was previously missing entirely, so the table always rendered zero rows\n // regardless of how many providers were actually configured.\n const keyIssues = live.filter((p) => p.keyIssue).map((p) => ({ instance: p.name, env: p.keyEnv, issue: p.keyIssue }));\n return Response.json({\n status: live.length > 0 ? (keyIssues.length ? \"ok-with-key-issues\" : \"ok\") : \"degraded\",\n providers_configured: live.length,\n inflight_requests: inflight,\n key_issues: keyIssues, // top-level, not buried per-instance: a malformed secret is the single most common \"why is X never working\" answer\n key_policy: \"tiered:top+1retry,siblings,breadth;config-dead→tail\", // see orderTargets() + demotion in router-core.ts\n auth: !!ADMIN_KEY, // true once OMNI_ADMIN_KEY is set — gates /api/update, /api/reset, /api/reset-stats\n instances: await getInstanceRoster(),\n });\n }\n\n if (url.pathname === \"/api/providers\") {\n const savedModels = await getSavedModels();\n return Response.json(getCatalogStatus().map((p) => ({\n ...p,\n currentModel: savedModels[p.name] || p.fallbackModel,\n })));\n }\n\n if (url.pathname === \"/api/models\") {\n const pName = url.searchParams.get(\"provider\");\n const p = getProviderArray().find((x) => x.name === pName);\n if (!p) return Response.json({ error: \"Provider not found or no key\" }, { status: 404 });\n try {\n return Response.json(await listUpstreamModels(p));\n } catch (e: any) {\n return Response.json({ error: e.message, fallback: p.fallbackModel }, { status: 502 });\n }\n }\n\n // OpenAI-style aggregate list: one row per routable instance (its bound\n // model) plus every upstream id namespaced \":\", so a client can\n // pin vendor+model through the `model` field of chat.completions.\n if (url.pathname === \"/v1/models\") {\n const live = getProviderArray();\n const saved = await getSavedModels();\n const seen = new Set();\n const rows: Record[] = [];\n for (const p of live) {\n const base = p.name.split(\"#\")[0];\n for (const id of [base, p.vendor]) {\n if (seen.has(id)) continue;\n seen.add(id);\n rows.push({ id, object: \"model\", owned_by: p.vendor, bound: saved[base] || p.fallbackModel });\n }\n }\n const results = await Promise.all(\n live.filter((p) => p.slot === 0).map(async (p) => {\n try {\n const list = await listUpstreamModels(p);\n return Array.isArray(list)\n ? list.map((m: any) => `${p.vendor}:${typeof m === \"string\" ? m : m.id}`)\n : [];\n } catch {\n return [];\n }\n }),\n );\n for (const id of results.flat()) {\n if (seen.has(id)) continue;\n seen.add(id);\n rows.push({ id, object: \"model\", owned_by: id.split(\":\")[0] });\n }\n return Response.json({ object: \"list\", data: rows });\n }\n\n return new Response(\n `\n \n \n \n \n \n Ziggyware Router Matrix\n \n \n \n \n \n \n \n

\n \n \n \n `,\n { headers: { \"Content-Type\": \"text/html\" } },\n );\n } else if (req.method === \"POST\") {\n if (url.pathname === \"/api/update\") {\n if (!isAdmin(req, url)) return Response.json({ error: \"unauthorized\" }, { status: 401 });\n const { provider, model } = await req.json();\n if (typeof provider !== \"string\" || !provider) return Response.json({ error: \"provider required\" }, { status: 400 });\n // model:null (or \"\") clears the override so the row falls back to its catalog default — there was\n // previously no way to UNBIND, only to bind something else, which is how a dead \"inkling-small\" override\n // outlived the catalog fix underneath it.\n if (model == null || model === \"\") {\n const d = await run(sql`DELETE FROM omni_router_config WHERE provider = ${provider}`);\n if (!d.ok) return Response.json({ error: d.error }, { status: 500 });\n return Response.json({ success: true, cleared: d.value.rowsAffected });\n }\n const r = await run(\n sql`INSERT INTO omni_router_config (provider, selected_model)\n VALUES (${provider}, ${model})\n ON CONFLICT(provider)\n DO UPDATE SET selected_model = excluded.selected_model`,\n );\n if (!r.ok) return Response.json({ error: r.error }, { status: 500 });\n return Response.json({ success: true });\n }\n\n // Item 2: previously missing entirely — ui-settings.ts's \"clear cooldowns\" button has been calling\n // this exact path since it was written, silently swallowing the 404. Clears every open circuit\n // breaker (in-memory on this isolate, and the persisted cross-isolate copy) so a provider mid-cooldown\n // gets tried again on the very next request instead of waiting out BREAK_DURATION_MS.\n if (url.pathname === \"/api/reset\") {\n if (!isAdmin(req, url)) return Response.json({ error: \"unauthorized\" }, { status: 401 });\n const { cleared } = await resetBreakers();\n return Response.json({ success: true, cleared });\n }\n\n // Item 4: clears the durable provider_stats counters (requests/ok/failed/last_error) — distinct from\n // /api/reset above, which clears the live routing decision, not the historical numbers. Separated so\n // clearing a stuck cooldown doesn't also erase diagnostic history, and vice versa.\n if (url.pathname === \"/api/reset-stats\") {\n if (!isAdmin(req, url)) return Response.json({ error: \"unauthorized\" }, { status: 401 });\n await resetProviderStats();\n return Response.json({ success: true });\n }\n\n if (!OPENAI_PATHS.has(url.pathname)) return new Response(\"Not Found\", { status: 404 });\n let body: unknown;\n try {\n body = await req.json();\n } catch {\n return Response.json({ error: { message: \"Invalid JSON body\" } }, { status: 400, headers: CORS });\n }\n return await handleChatCompletions(body);\n }\n\n return new Response(\"Not Found\", { status: 404 });\n}","router",[],[369],"41835688-4fca-4c8c-aae8-4a3428e7bbd1","router-state.ts","b109aa6c-ab4e-11f1-8d3d-1607ee4eb77e",1520,["D",1789222232524],11,"// Routing state that must survive isolate recycling: instance cooldowns\n// (breaker / 429 / bad key), dead model ids, auto-resolved replacements, and\n// the UI's per-vendor model binding. One SELECT per request, write-through.\nimport { all, run, sql } from \"./db.ts\";\n\nexport type Cooldown = { until: number; reason: string; fails: number };\nexport type Stat = {\n req: number;\n ok: number;\n fail: number;\n last: number;\n model: string;\n err: string;\n};\ntype State = {\n cool: Record;\n dead: Record;\n resolved: Record;\n bound: Record;\n cap: Record;\n tps: Record;\n capin: Record;\n stat: Record;\n};\n\nconst MAX_FAILS = 2;\nexport const COOL = {\n breaker: 2_500,\n rate: 6_000,\n auth: 30_000,\n model: 36_000,\n cap: 90_000,\n};\n\nlet mem: State = {\n cool: {},\n dead: {},\n resolved: {},\n bound: {},\n cap: {},\n capin: {},\n stat: {},\n tps: {},\n};\nlet loadedAt = 0;\n\nexport async function loadState(force = false): Promise {\n if (!force && Date.now() - loadedAt < 2_000) return mem;\n const [st, cfg] = await Promise.all([\n all(\"omni_state\", sql`SELECT key, value FROM omni_state`),\n all(\n \"omni_router_config\",\n sql`SELECT provider, selected_model FROM omni_router_config`,\n ),\n ]);\n const next: State = {\n cool: {},\n dead: {},\n resolved: {},\n bound: {},\n cap: {},\n capin: {},\n stat: {},\n tps: {},\n };\n if (st.ok) {\n for (const r of st.value as { key: string; value: string }[]) {\n const [kind, ...rest] = r.key.split(\":\");\n const id = rest.join(\":\");\n try {\n if (kind === \"cool\") next.cool[id] = JSON.parse(r.value);\n else if (kind === \"dead\") next.dead[id] = Number(r.value);\n else if (kind === \"resolved\") next.resolved[id] = r.value;\n else if (kind === \"cap\") next.cap[id] = JSON.parse(r.value);\n else if (kind === \"stat\") next.stat[id] = JSON.parse(r.value);\n else if (kind === \"capin\") next.capin[id] = JSON.parse(r.value);\n else if (kind === \"tps\") next.tps[id] = JSON.parse(r.value);\n } catch { /* skip corrupt row */ }\n }\n }\n if (cfg.ok) {\n for (\n const r of cfg.value as { provider: string; selected_model: string }[]\n ) next.bound[r.provider] = r.selected_model;\n }\n mem = next;\n loadedAt = Date.now();\n return mem;\n}\n\nconst put = (key: string, value: string) =>\n run(\n sql`INSERT INTO omni_state (key, value, ts) VALUES (${key}, ${value}, ${Date.now()})\n ON CONFLICT(key) DO UPDATE SET value = excluded.value, ts = excluded.ts`,\n );\nconst del = (key: string) =>\n run(sql`DELETE FROM omni_state WHERE key = ${key}`);\n\nexport const isCool = (name: string) =>\n (mem.cool[name]?.until ?? 0) > Date.now();\nexport const coolInfo = (name: string): Cooldown | undefined => mem.cool[name];\nexport const isDead = (vendor: string, model: string) =>\n (mem.dead[`${vendor}:${model}`] ?? 0) > Date.now();\n// Per-INSTANCE model death (a key's daily quota for one model). Namespaced with \"@\" because slot 0's\n// instance name equals the vendor name — without the prefix, slot 0's quota would kill the model for every slot.\nexport const isDeadOn = (instance: string, model: string) =>\n (mem.dead[`@${instance}:${model}`] ?? 0) > Date.now();\nexport async function markDeadOn(\n instance: string,\n model: string,\n until: number,\n) {\n mem.dead[`@${instance}:${model}`] = until;\n await put(`dead:@${instance}:${model}`, String(until));\n}\nexport const resolvedFor = (vendor: string) => mem.resolved[vendor];\nexport const boundFor = (vendor: string) => mem.bound[vendor];\n/** learned per-model output ceiling (from \"Limit N\" size errors), or Infinity */\nexport const capFor = (vendor: string, model: string) => {\n const c = mem.cap[`${vendor}:${model}`];\n return c && c.until > Date.now() ? c.lim : Infinity;\n};\n/** learned per-model INPUT ceiling (ITPM / context) — a tier limit, so it lives 24 h */\n/** Learned output throughput per vendor:model (tokens/s, EMA over completions ≥ 64 tokens). Drives the deadline-derived\n * max_tokens cap: catalog constants (openrouter \"30 tps\") were cutting every build reply to ~1k tokens. */\nexport const tpsFor = (vendor: string, model: string): number | undefined =>\n mem.tps[`${vendor}:${model}`]?.v ?? mem.tps[`${vendor}:*`]?.v;\nexport async function noteTps(\n vendor: string,\n model: string,\n tokens: number,\n ms: number,\n) {\n if (!(tokens >= 64) || !(ms > 200)) return;\n const v = tokens / (ms / 1000);\n for (const key of [`${vendor}:${model}`, `${vendor}:*`]) {\n const prev = mem.tps[key];\n const next = prev\n ? { v: prev.v * 0.7 + v * 0.3, n: prev.n + 1 }\n : { v, n: 1 };\n mem.tps[key] = next;\n await put(`tps:${key}`, JSON.stringify(next));\n }\n}\nexport const capInFor = (vendor: string, model: string) => {\n const c = mem.capin[`${vendor}:${model}`] ?? mem.capin[`${vendor}:*`];\n return c && c.until > Date.now() ? c.lim : Infinity;\n};\nexport async function setCapIn(vendor: string, model: string, lim: number) {\n mem.capin[`${vendor}:${model}`] = { lim, until: Date.now() + 24 * 1000 };\n await put(\n `capin:${vendor}:${model}`,\n JSON.stringify(mem.capin[`${vendor}:${model}`]),\n );\n}\nexport async function setCap(vendor: string, model: string, lim: number) {\n mem.cap[`${vendor}:${model}`] = { lim, until: Date.now() + COOL.cap };\n await put(\n `cap:${vendor}:${model}`,\n JSON.stringify(mem.cap[`${vendor}:${model}`]),\n );\n}\n\n/** Transient failure: counts toward the breaker; opens after MAX_FAILS. */\nexport async function noteFailure(name: string, reason: string) {\n const c = mem.cool[name] ?? { until: 0, reason, fails: 0 };\n c.fails++;\n c.reason = reason;\n if (c.fails >= MAX_FAILS) {\n c.until = Date.now() + COOL.breaker;\n c.fails = 0;\n }\n mem.cool[name] = c;\n await put(`cool:${name}`, JSON.stringify(c));\n}\n/** Hard cooldown for a known duration (429 retry-after, 401/403 key/tier). */\nexport async function coolFor(name: string, ms: number, reason: string) {\n mem.cool[name] = { until: Date.now() + ms, reason, fails: 0 };\n await put(`cool:${name}`, JSON.stringify(mem.cool[name]));\n}\nexport async function noteSuccess(name: string) {\n if (!mem.cool[name]) return;\n delete mem.cool[name];\n await del(`cool:${name}`);\n}\n/** Per-instance counters: the only externally checkable evidence that a key slot is actually used. Written every attempt. */\nexport async function noteStat(\n name: string,\n ok: boolean,\n model: string,\n err = \"\",\n) {\n const s = mem.stat[name] ??\n { req: 0, ok: 0, fail: 0, last: 0, model: \"\", err: \"\" };\n s.req++;\n ok ? s.ok++ : s.fail++;\n s.last = Date.now();\n s.model = model;\n s.err = ok ? \"\" : err.slice(0, 120);\n mem.stat[name] = s;\n await put(`stat:${name}`, JSON.stringify(s));\n}\nexport const statFor = (name: string): Stat | undefined => mem.stat[name];\nexport async function markDead(\n vendor: string,\n model: string,\n until = Date.now() + COOL.model,\n) {\n mem.dead[`${vendor}:${model}`] = until;\n await put(`dead:${vendor}:${model}`, String(until));\n}\n/** Clear cooldowns (and per-instance model deaths) — admin reset. `name` = instance or vendor; empty = everything. */\nexport async function resetCooldowns(name = \"\") {\n const hit = (k: string) =>\n !name || k === name || k.split(\"#\")[0] === name || k.startsWith(name + \":\");\n const cool = Object.keys(mem.cool).filter(hit),\n dead = Object.keys(mem.dead).filter((k) =>\n !name || hit(k.replace(/^@/, \"\"))\n ),\n resolved = Object.keys(mem.resolved).filter(hit);\n for (const k of cool) {\n delete mem.cool[k];\n await del(`cool:${k}`);\n }\n for (const k of dead) {\n delete mem.dead[k];\n await del(`dead:${k}`);\n }\n for (const k of resolved) {\n delete mem.resolved[k];\n await del(`resolved:${k}`);\n } // a junk discovery (whisper, prompt-guard) must not survive a reset\n return { cool, dead, resolved };\n}\nexport async function setResolved(vendor: string, model: string) {\n mem.resolved[vendor] = model;\n await put(`resolved:${vendor}`, model);\n}\nexport async function bindModel(vendor: string, model: string) {\n mem.bound[vendor] = model;\n return run(\n sql`INSERT INTO omni_router_config (provider, selected_model) VALUES (${vendor}, ${model})\n ON CONFLICT(provider) DO UPDATE SET selected_model = excluded.selected_model`,\n );\n}\n\nexport async function unbind(vendor: string) {\n delete mem.bound[vendor];\n return run(sql`DELETE FROM omni_router_config WHERE provider = ${vendor}`);\n}\n\n/** ms until the first of these instances stops cooling; 0 if any is free now; Infinity if none listed. */\nexport function soonestCooldown(names: string[]): number {\n const now = Date.now();\n let best = Infinity;\n for (const n of names) {\n const u = mem.cool[n]?.until ?? 0;\n if (u <= now) return 0;\n best = Math.min(best, u - now);\n }\n return best;\n}\n\n/** Snapshot for /health and the UI. */\nexport function stateView() {\n const now = Date.now();\n return {\n cooling: Object.entries(mem.cool).filter(([, c]) => c.until > now).map((\n [name, c],\n ) => ({ name, reason: c.reason, ms_left: c.until - now })),\n dead_models: Object.entries(mem.dead).filter(([, t]) => t > now).map((\n [k],\n ) => k),\n resolved: mem.resolved,\n bound: mem.bound,\n caps: Object.fromEntries(\n Object.entries(mem.cap).filter(([, c]) => c.until > now).map((\n [k, c],\n ) => [k, c.lim]),\n ),\n caps_in: Object.fromEntries(\n Object.entries(mem.capin).filter(([, c]) => c.until > now).map((\n [k, c],\n ) => [k, c.lim]),\n ),\n tps: Object.fromEntries(\n Object.entries(mem.tps).filter(([k]) => !k.endsWith(\":*\")).map((\n [k, t],\n ) => [k, Math.round(t.v)]),\n ),\n stat: mem.stat,\n };\n}",[],[379],"fe7b2599-5f6b-40e8-bcca-858dfe3982ec","router-score.ts","748d5d90-b15c-11f1-8871-1607ee4eb77e",1648,["D",1789514607552],"// Estimation and ordering for the router. Every constant here is derived, not tuned by hand; the\n// derivation is stated next to it so it can be checked rather than trusted.\n//\n// [1] ORDERING. Sequential trials, trial i costs t_i and succeeds w.p. p_i. Minimise E[time to first\n// success]. For adjacent i,j the exchange difference is\n// E - E' = p_j t_i - p_i t_j,\n// so i precedes j iff p_i/t_i > p_j/t_j. The optimal static order is by DECREASING p/t. An earlier\n// version scored p/sqrt(t), which has no such argument behind it and is measurably worse.\n\nexport type Est = {\n eOk: number; // EWMA success rate\n eLat: number; // EWMA latency, ms\n eVar: number; // EWMA of squared deviation -> variance, for the tail bound in [4]\n n: number; // raw observation count, for the confidence gate in [3]\n lastTs: number;\n llr: number; // sequential log-likelihood ratio for [5]\n};\nexport const newEst = (): Est => ({ eOk: 0.5, eLat: 3000, eVar: 1e6, n: 0, lastTs: 0, llr: 0 });\n\n// [2] EWMA effective sample size. For weight a, ESS = (2-a)/a. a=0.2 -> ESS 9, i.e. the estimate is\n// worth about nine observations. This is what makes forgetting tunable rather than arbitrary: a\n// provider that recovers needs ~ESS observations to climb back, so ESS sets the recovery latency.\nexport const ALPHA = 0.2;\nexport const ess = (a = ALPHA) => (2 - a) / a;\n\n// [3] Unknown must not read as bad. A provider with no history gets the prior (0.5), and its score is\n// only trusted once it has enough observations; below that it is ordered by the prior so it is\n// explored rather than buried. Hoeffding: to place p within +-eps w.p. 1-delta needs\n// n >= ln(2/delta) / (2 eps^2).\n// eps=0.2, delta=0.05 -> n >= 47. That is the honest number for \"we know this provider's rate\",\n// and it is far more than a couple of probes, which is why demotion below uses a sequential test\n// rather than waiting for it.\nexport const hoeffdingN = (eps: number, delta = 0.05) => Math.ceil(Math.log(2 / delta) / (2 * eps * eps));\nexport const CONFIDENT_N = 8; // enough to move off the prior; full Hoeffding confidence is 47 and is not required to ORDER\n\nexport function observe(e: Est, ok: boolean, latMs: number, now: number, a = ALPHA): Est {\n const d = latMs - e.eLat;\n return {\n eOk: (1 - a) * e.eOk + a * (ok ? 1 : 0),\n eLat: e.eLat + a * d,\n eVar: (1 - a) * (e.eVar + a * d * d), // West's incremental EWMA variance\n n: e.n + 1,\n lastTs: now,\n llr: e.llr,\n };\n}\n\n// [1] applied. Guard the divisor: a provider that fails in 200ms would otherwise score enormously on\n// p/t if p is even slightly above zero, and fast-failing is exactly what a dead endpoint does.\nexport const MIN_T = 500;\nexport function score(e: Est): number {\n const p = e.n >= CONFIDENT_N ? e.eOk : 0.5 * (1 - e.n / CONFIDENT_N) + e.eOk * (e.n / CONFIDENT_N);\n return p / Math.max(MIN_T, e.eLat);\n}\nexport const orderByScore = (xs: T[], est: (x: T) => Est): T[] =>\n xs.map((x) => ({ x, s: score(est(x)) })).sort((u, v) => v.s - u.s).map((u) => u.x);\n\n// [4] ADAPTIVE PER-ATTEMPT TIMEOUT. A fixed 30s ceiling spends the same on a provider whose latency is\n// tightly concentrated at 2s as on one that is genuinely slow. One-sided Chebyshev (Cantelli) gives,\n// for any distribution with mean mu and variance s^2,\n// P(X - mu >= k s) <= 1/(1+k^2),\n// so cutting at mu + k*s wrongly aborts at most 1/(1+k^2) of genuine successes. k=4 -> <=5.9%.\n// Distribution-free, which matters because provider latency is not Gaussian and is often bimodal\n// (fast path vs. queued). Clamped to the global ceiling and floored so a fast provider still gets a\n// usable window.\nexport const CHEBY_K = 4;\nexport function adaptiveTimeoutMs(e: Est, hardCeilMs: number, floorMs = 4000): number {\n if (e.n < CONFIDENT_N) return hardCeilMs; // not enough evidence to tighten; never widen past the ceiling\n const sd = Math.sqrt(Math.max(0, e.eVar));\n return Math.max(floorMs, Math.min(hardCeilMs, Math.round(e.eLat + CHEBY_K * sd)));\n}\nexport const chebyshevMissRate = (k = CHEBY_K) => 1 / (1 + k * k);\n\n// [5] SEQUENTIAL TEST FOR \"CONFIG-DEAD\" (Wald's SPRT). The shipped rule is two consecutive config-class\n// failures. That is a fixed-sample test with an error rate nobody chose: for a healthy provider with\n// per-call config-error probability q, the false-demotion rate is q^2 per pair.\n// SPRT instead accumulates evidence and stops when it is conclusive, with SPECIFIED error rates:\n// H0: p_fail = p0 (healthy) H1: p_fail = p1 (dead)\n// llr += ln( P(x|H1) / P(x|H0) ); demote when llr >= ln((1-beta)/alpha).\n// It reaches the same conclusion faster on clear evidence and refuses to conclude on weak evidence,\n// which is the behaviour the fixed rule cannot express. Wald: E[n] is minimal among tests with the\n// same alpha, beta.\nexport const SPRT = { p0: 0.05, p1: 0.75, alpha: 0.02, beta: 0.05 };\nexport const sprtUpper = () => Math.log((1 - SPRT.beta) / SPRT.alpha);\nexport const sprtLower = () => Math.log(SPRT.beta / (1 - SPRT.alpha));\nexport function sprtUpdate(llr: number, failed: boolean): number {\n const { p0, p1 } = SPRT;\n const inc = failed ? Math.log(p1 / p0) : Math.log((1 - p1) / (1 - p0));\n return Math.min(sprtUpper() + 1, Math.max(sprtLower() - 1, llr + inc));\n}\n// [6] HYSTERESIS. Demote and recover on different thresholds, so a provider hovering at the boundary\n// cannot oscillate once per observation — the classic Schmitt-trigger fix. Recovery is the LOWER\n// boundary of the same test, not a mirror of the upper one, so the gap is principled.\nexport const sprtVerdict = (llr: number): \"dead\" | \"healthy\" | \"undecided\" =>\n llr >= sprtUpper() ? \"dead\" : llr <= sprtLower() ? \"healthy\" : \"undecided\";\n\n// [7] PROBE BUDGET. Probing costs provider quota that could have served a request, so the rate should\n// come from how fast belief decays, not from a round number. With ESS observations' worth of memory\n// and a target of keeping the estimate no more than one ESS stale, probe every provider once per\n// ESS * meanInterArrival. Returns probes per provider per hour.\nexport const probeRatePerHour = (essN = ess(), staleTargetMs = 15 * 60_000) =>\n Math.max(1, Math.round((3600_000 / staleTargetMs) * Math.min(1, essN / 9)));\n",[],[388],"6544872d-33b2-49f2-bc7e-f01ea368e3f1","router-openai.ts","6a8c10a8-ab4d-11f1-aa95-1607ee4eb77e",1589,["D",1789446563524],10,"// OpenAI chat.completions surface over routeInference. Streams are piped\n// byte-for-byte from upstream (real token streaming); failover happens only\n// before the first upstream byte, which is the only point it can happen.\nimport { circuitStates, inflight, type RouteHit, routeInference, type RouteOpts } from \"./router-core.ts\";\n\nconst CORS = { \"Access-Control-Allow-Origin\": \"*\" };\nconst json = (body: unknown, status = 200) =>\n new Response(JSON.stringify(body), { status, headers: { \"Content-Type\": \"application/json\", ...CORS } });\n\nconst sanitize = (p: RouteHit[\"provider\"]) => ({\n id: p.id, name: p.name, vendor: p.vendor, base: p.base, keyEnv: p.keyEnv, slot: p.slot, priority: p.priority, fallbackModel: p.fallbackModel,\n});\n\n// Trail/plan are capped here (not just at storage time — see app.tsx's slimEvents cap) so a pathological\n// worst case (10 full passes × ~20 providers) can't blow up the response payload itself; the last N entries\n// are what matters for a flowchart anyway — earlier passes of the same provider list are redundant detail.\nconst TRAIL_CAP = 60;\nconst meta = (hit: RouteHit) => ({\n provider: sanitize(hit.provider),\n model: hit.model,\n latency_ms: hit.latencyMs,\n inflight_requests: inflight,\n circuit_states: circuitStates(),\n plan: hit.plan ?? null,\n attempts: hit.trail ? hit.trail.slice(-TRAIL_CAP) : null,\n});\n\nexport async function handleChatCompletions(body: any): Promise {\n const messages = body?.messages ?? (body?.prompt ? [{ role: \"user\", content: body.prompt }] : []);\n if (!Array.isArray(messages) || !messages.length) return json({ error: { message: \"Empty message payload\" } }, 400);\n const opts: RouteOpts = {\n model: body.model, tools: body.tools, tool_choice: body.tool_choice,\n temperature: body.temperature, max_tokens: body.max_tokens, stream: !!body.stream,\n response_format: body.response_format,\n // Was silently dropped: the client (app-infer.ts callInference) always sends this, meaning every\n // per-provider attempt used the router's fixed default regardless of how much of the caller's own\n // turn budget was actually left — see HARD_TIMEOUT_MS's comment in router-core.ts.\n deadlineMs: typeof body.omni_deadline_ms === \"number\" && body.omni_deadline_ms > 0 ? body.omni_deadline_ms : undefined,\n };\n let hit: RouteHit;\n try {\n hit = await routeInference(messages, opts);\n } catch (e: any) {\n // Exhaustion still carries a full trail — a flowchart that shows \"everything tried, then a 503\" is\n // strictly more useful than one that goes dark the moment there's no winner to hang it off of.\n return json({ error: { message: e.message, details: e.errors ?? null, plan: e.plan ?? null, attempts: e.trail ? e.trail.slice(-TRAIL_CAP) : null } }, e.status ?? 503);\n }\n const m = meta(hit);\n\n if (!opts.stream) {\n const up = await hit.res.json();\n return json({ ...up, model: up.model ?? hit.model, _omni_meta: m });\n }\n\n // SSE passthrough. Prepend one comment line carrying _omni_meta so clients\n // that want provenance can read it without parsing chunks; OpenAI SDKs\n // ignore \":\"-prefixed lines per the SSE spec.\n const enc = new TextEncoder();\n const head = new ReadableStream({\n start(c) { c.enqueue(enc.encode(`: omni ${JSON.stringify(m)}\\n\\n`)); c.close(); },\n });\n const upstream = hit.res.body ?? new ReadableStream({ start(c) { c.close(); } });\n const out = new ReadableStream({\n async start(c) {\n for (const s of [head, upstream]) {\n const r = s.getReader();\n for (;;) { const { done, value } = await r.read(); if (done) break; c.enqueue(value); }\n }\n c.close();\n },\n cancel() { hit.res.body?.cancel().catch(() => {}); },\n });\n return new Response(out, {\n headers: { \"Content-Type\": \"text/event-stream\", \"Cache-Control\": \"no-cache\", \"X-Omni-Provider\": hit.provider.name, \"X-Omni-Model\": hit.model, ...CORS },\n });\n}\n",[],[396],"3ba4d79f-be8e-41dc-a05d-9f0d06316c50","router-discover.ts","b14c41f6-ab4e-11f1-8fec-1607ee4eb77e",1406,["D",1789017793310],"import type { ProviderInstance } from \"./inference-provider.ts\";\nimport { isDead } from \"./router-state.ts\";\n\nexport function headersFor(p: ProviderInstance): Record {\n const h: Record = { \"Content-Type\": \"application/json\", \"HTTP-Referer\": \"https://val.town\", \"X-Title\": \"omni\", ...p.headers };\n if (p.key) h.Authorization = `Bearer ${p.key}`;\n return h;\n}\n\n\n/** Live /models lookup → first id matching the vendor's `prefer` regex that isn't dead. */\nexport async function discover(p: ProviderInstance): Promise {\n if (!p.prefer) return null;\n try {\n const res = await fetch(`${p.base}/models`, { headers: headersFor(p) });\n if (!res.ok) return null;\n const data = await res.json();\n const ids: string[] = (data.data ?? data).map((m: any) => (typeof m === \"string\" ? m : m.id)).filter(Boolean);\n const rx = new RegExp(p.prefer, \"i\");\n // never \"discover\" non-chat endpoints: guard/moderation, ASR, TTS, embeddings, rerankers\n const JUNK = /guard|safeguard|moderat|whisper|tts|speech|embed|rerank|playai|vision-only|ocr|\\bstt\\b/i;\n return ids.find((id) => rx.test(id) && !JUNK.test(id) && !isDead(p.vendor, id)) ?? null;\n } catch { return null; }\n}\n\n",[],[405],"79642d84-a85e-4c3c-bf5a-bd41f5caeca2","router-core.ts","6a4ef8c6-ab4d-11f1-9c11-1607ee4eb77e",1642,["D",1789500412535],40,"import { getProviderArray, type ProviderInstance, resolveTargets } from \"./inference-provider.ts\";\nimport { all, bumpProviderStats, providerStatsAll, run, sql } from \"./db.ts\";\n\nexport const MAX_CONCURRENCY = 3;\nconst MAX_FAILS = 2;\nconst BREAK_DURATION_MS = 25_000;\n// Per-attempt ceiling when no caller deadline narrows it further. Was 120_000, then cut to 15_000 to stop\n// one stalling vendor from eating the whole response window — but 15s proved too short for what this app\n// actually sends: live evidence (a Groq 413) confirmed prompts here run 18k+ tokens with up to 16k\n// max_tokens requested, and a live /health comparison showed Anthropic's own success rate fall from 6/7 to\n// 6/23 (nearly all new failures API_STALLED_TIMEOUT) once attempts were being cut off at 15s — a real,\n// legitimately-completing generation for this workload routinely needs more than that. 30s is a genuine\n// tradeoff against breadth (fewer distinct providers fit in one invocation's ~50s safety ceiling), chosen\n// because a provider that's actually working and just needs time is worth far more than three that were\n// never going to succeed anyway getting tried instead.\nexport const HARD_TIMEOUT_MS = 30_000;\nconst RETRYABLE = new Set([408, 409, 425, 429, 500, 502, 503, 504]);\n\nexport let inflight = 0;\n// FIFO admission instead of the previous `while (inflight >= MAX) await sleep(10)` spin: polling burned a\n// timer tick per 10ms per waiter and — worse — admitted waiters in whatever order their timers happened\n// to fire, so under contention a request that arrived later could jump one that had been waiting.\n// Waiters now resolve strictly in arrival order, with zero timers while blocked.\nconst waiters: (() => void)[] = [];\nasync function acquire(): Promise {\n if (inflight < MAX_CONCURRENCY) { inflight++; return; }\n await new Promise((resolve) => waiters.push(resolve));\n inflight++;\n}\nfunction release(): void {\n inflight--;\n const next = waiters.shift();\n if (next) next();\n}\n\n// Config-dead demotion. The breaker deliberately never trips on non-retryable 4xx (a bad key or model id\n// must not oscillate it) — correct, but the consequence, visible in every trail this session, was that a\n// provider returning 404 \"Function not found\", 403 tier_not_allowed or 402 quota-exhausted got a full,\n// fresh attempt on EVERY pass of EVERY request, forever, each one costing a round-trip before the next\n// candidate. Demotion is the missing middle ground: after CFG_DEAD_AFTER consecutive config-class\n// failures the instance is moved to the END of the order (still tried — fail-open is preserved, nothing\n// is ever excluded), for CFG_DEAD_MS, persisted cross-isolate. One success clears it immediately.\nconst CFG_DEAD_AFTER = 2;\nconst CFG_DEAD_MS = 10 * 60_000;\nconst CFG_DEAD_STATUSES = new Set([401, 402, 403, 404]);\n// A 429 is retryable in general, but a 429 whose body says the QUOTA is gone (daily free cap, billing\n// hard-limit) is not a transient rate limit — it's config-dead until the window resets. Observed live on\n// SambaNova / HuggingFace / OpenAI this session.\n// Adversarial case that shaped this regex: Groq's TRANSIENT per-minute 429 reads \"Rate limit reached for\n// model … on tokens per minute (TPM) … Please try again in 2.5s\" — a naive \"limit reached\" match would\n// have demoted a perfectly healthy provider for 10 minutes on a 2-second backoff. So: any explicit\n// short-retry / per-minute phrasing wins outright as transient, and only unmistakably daily/billing\n// wording counts as exhausted.\n//\n// Second adversarial case, found live (a real session pinned groq/gpt-oss-120b and #1 at the front of the\n// plan for hours): the bare \"try again in\" clause matched on ANY retry-after phrasing regardless of the\n// actual wait it named, including \"on tokens per day (TPD) … Please try again in 26m56s\" — a 27-MINUTE\n// daily-cap block, misclassified as transient purely because the sentence happens to also carry a\n// countdown. That kept a provider that would fail identically for the rest of the day sitting at tier-1\n// head priority (never demoted, since !QUOTA_TRANSIENT short-circuited isConfigClass to false) instead of\n// being pushed to the tail after two such failures like any other config-dead instance — costing a real\n// round-trip on literally every attempt, forever, while never getting out of the way for a working\n// provider. Fix: \"try again in\" only counts as transient when the number right after it is a bare\n// seconds value with no minutes/hours component attached (\"try again in 2.5s\", not \"26m56s\" or \"1h2m3s\") —\n// verified against both live daily-cap error bodies (now correctly NOT transient) and the original TPM\n// adversarial case above (still transient, unaffected — it doesn't go through this clause at all).\nconst QUOTA_TRANSIENT = /(?:try again in\\s+(?!\\d+h\\b|\\d+m\\d)\\d+(?:\\.\\d+)?\\s*s\\b)|per minute|per second|\\bTPM\\b|\\bRPM\\b|\\bTPS\\b/i;\nconst QUOTA_EXHAUSTED = /quota|billing|insufficient|credit|exceeded your|per.?day|daily|free-models-per-day|hard limit/i;\nfunction isConfigClass(status: number | undefined, body: string): boolean {\n if (status === undefined) return false;\n if (CFG_DEAD_STATUSES.has(status)) return true;\n return status === 429 && !QUOTA_TRANSIENT.test(body) && QUOTA_EXHAUSTED.test(body);\n}\n\ntype Breaker = {\n failCount: number; state: \"CLOSED\" | \"OPEN\" | \"HALF_OPEN\"; nextAttempt: number;\n requests: number; ok: number; failed: number; lastError: string | null; // counters exist solely for /health's instance roster\n cfgFails: number; demotedUntil: number; demotedReason: string | null;\n fromDb: boolean; // true ⇒ this isolate's OPEN/demoted state was learned from omni_state, not observed here — so a later re-hydrate may retract it\n};\nconst breakers = new Map();\nexport function getBreaker(name: string): Breaker {\n let b = breakers.get(name);\n if (!b) breakers.set(name, b = { failCount: 0, state: \"CLOSED\", nextAttempt: 0, requests: 0, ok: 0, failed: 0, lastError: null, cfgFails: 0, demotedUntil: 0, demotedReason: null, fromDb: false });\n return b;\n}\nexport const isDemoted = (name: string) => getBreaker(name).demotedUntil > Date.now();\nfunction admit(name: string) {\n const b = getBreaker(name);\n if (b.state === \"OPEN\" && Date.now() >= b.nextAttempt) b.state = \"HALF_OPEN\";\n return b.state !== \"OPEN\";\n}\n// `trip`=false records the attempt (roster counters) without touching breaker state — used for 4xx config\n// errors, which fail over but must never oscillate the breaker on a bad key/model id (see `attempt` below).\n// The breaker's open/closed decision stays in-memory-only (per-isolate — no DB read added to the hot\n// path); the counters are additionally persisted (best-effort, never blocks or fails the actual routing\n// decision) so /health reflects reality across isolates instead of whichever one happens to answer a\n// GET. bumpProviderStats failing silently is acceptable: it's diagnostics, not routing logic.\n// Breaker/demotion persistence is written ONLY on a transition (closed→open, open→closed, demoted↔not) —\n// the first version of this wrote on every report(), one extra DB round-trip per attempt for a value that\n// almost never changed. The stats bump is unavoidable (it IS the per-attempt counter); this one wasn't.\nasync function report(name: string, ok: boolean, error?: string, trip = true, configClass = false) {\n const b = getBreaker(name);\n const wasOpen = b.state === \"OPEN\", wasDemoted = b.demotedUntil > Date.now();\n b.fromDb = false; // whatever happens below was observed HERE — local evidence outranks anything hydrated\n b.requests++;\n if (ok) { b.ok++; b.failCount = 0; b.state = \"CLOSED\"; b.cfgFails = 0; b.demotedUntil = 0; b.demotedReason = null; }\n else {\n b.failed++;\n if (error) b.lastError = error;\n if (trip && (++b.failCount >= MAX_FAILS || b.state === \"HALF_OPEN\")) {\n b.state = \"OPEN\"; b.nextAttempt = Date.now() + BREAK_DURATION_MS; b.failCount = 0;\n }\n if (configClass) {\n if (++b.cfgFails >= CFG_DEAD_AFTER) { b.demotedUntil = Date.now() + CFG_DEAD_MS; b.demotedReason = (error ?? \"config error\").slice(0, 160); }\n } else b.cfgFails = 0; // a transient failure between config errors resets the streak — demotion needs a CONSISTENT signal\n }\n await bumpProviderStats(name, ok, error ?? null, Date.now()).catch(() => {});\n const isOpen = b.state === \"OPEN\", nowDemoted = b.demotedUntil > Date.now();\n if (isOpen !== wasOpen || nowDemoted !== wasDemoted) await persistBreaker(name, b).catch(() => {});\n}\nexport const circuitStates = () => getProviderArray().map((p) => ({ name: p.name, state: getBreaker(p.name).state }));\n\n// ────────────────────────────────────────────────────────────────\n// Breaker cross-isolate persistence (item 5). The in-memory `breakers` Map above still governs the\n// admit()/report() decision on THIS isolate with zero added DB read on the hot path — that design choice\n// (see the comment on `report`) is unchanged. What was missing: a fresh isolate started moments after\n// another isolate opened a breaker had no way to know, so /health's `cooling` field and a brand-new\n// isolate's own routing could both treat a genuinely-tripped provider as available again. omni_state\n// (already reserved in db.ts's schema comment for exactly this: \"router cooldowns / dead models\") now\n// carries each OPEN breaker's state so a new isolate can hydrate it once, cheaply, instead of per-attempt.\nfunction persistBreaker(name: string, b: Breaker): Promise {\n const key = `breaker:${name}`;\n const now = Date.now();\n const demoted = b.demotedUntil > now;\n if (b.state === \"OPEN\" || demoted) {\n const value = JSON.stringify({\n state: b.state, nextAttempt: b.nextAttempt, lastError: b.lastError,\n demotedUntil: demoted ? b.demotedUntil : 0, demotedReason: demoted ? b.demotedReason : null,\n });\n return run(sql`INSERT INTO omni_state (key, value, ts) VALUES (${key}, ${value}, ${now})\n ON CONFLICT(key) DO UPDATE SET value = excluded.value, ts = excluded.ts`);\n }\n return run(sql`DELETE FROM omni_state WHERE key = ${key}`);\n}\nlet hydratedAt = 0;\n// Re-read at most once per HYDRATE_TTL_MS. The first version hydrated ONCE per isolate and then never\n// again, which live trails proved wrong within the hour: message #747 (06:03:04) tried nemotron-ultra,\n// cerebras and sambanova first — all three already demoted by a sibling isolate at 06:02:24 — because\n// this isolate had hydrated earlier and considered itself done. A SELECT on a tiny table every few\n// seconds is nothing next to the 2–30s LLM call it precedes. Persisted rows are applied set-only;\n// entries this isolate only ever learned from the DB (fromDb) are retracted when their row disappears\n// (another isolate saw a success and cleared it). Locally observed state is never overwritten.\nconst HYDRATE_TTL_MS = 3_000;\nasync function hydrateBreakers(): Promise {\n const now = Date.now();\n if (now - hydratedAt < HYDRATE_TTL_MS) return;\n hydratedAt = now;\n const r = await all(\"omni_state\", sql`SELECT * FROM omni_state WHERE key LIKE 'breaker:%'`);\n if (!r.ok) return;\n const seen = new Set();\n for (const row of r.value as any[]) {\n try {\n const data = JSON.parse(row.value);\n const name = row.key.slice(\"breaker:\".length);\n seen.add(name);\n const b = getBreaker(name);\n const localOpen = b.state === \"OPEN\" && !b.fromDb, localDemoted = b.demotedUntil > now && !b.fromDb;\n if (!localOpen && data.state === \"OPEN\" && typeof data.nextAttempt === \"number\" && data.nextAttempt > now) {\n b.state = \"OPEN\"; b.nextAttempt = data.nextAttempt; b.lastError = data.lastError ?? b.lastError; b.fromDb = true;\n }\n if (!localDemoted && typeof data.demotedUntil === \"number\" && data.demotedUntil > now) {\n b.demotedUntil = data.demotedUntil; b.demotedReason = data.demotedReason ?? null; b.fromDb = true;\n }\n } catch { /* malformed row — skip it, never let a bad persisted entry block routing */ }\n }\n for (const [name, b] of breakers) {\n if (b.fromDb && !seen.has(name)) { // retracted elsewhere\n if (b.state === \"OPEN\") b.state = \"CLOSED\";\n b.demotedUntil = 0; b.demotedReason = null; b.fromDb = false;\n }\n }\n}\n// Item 2: the \"clear cooldowns\" button in ui-settings.ts (routerReset()) has always called a POST\n// /api/reset that never existed anywhere in router.tsx — silently no-op'd behind a 404 the UI never\n// surfaced. This is the function that route now actually backs: clears every in-memory breaker on THIS\n// isolate and, best-effort, the persisted OPEN state so other isolates don't re-hydrate the cleared\n// breakers back open on their next call.\nexport async function resetBreakers(): Promise<{ cleared: number }> {\n const cleared = breakers.size;\n breakers.clear();\n const r = await all(\"omni_state\", sql`SELECT key FROM omni_state WHERE key LIKE 'breaker:%'`);\n if (r.ok) for (const row of r.value as any[]) await run(sql`DELETE FROM omni_state WHERE key = ${row.key}`).catch(() => {});\n hydratedAt = Date.now(); // nothing left to hydrate — prevents a stale read from racing back in before the next natural trip\n return { cleared };\n}\n// Item 4: provider_stats accumulates forever with no way to tell \"still failing\" from \"was failing before\n// a fix landed\" (the exact ambiguity flagged after this session's stale-binding fix). Distinct from\n// resetBreakers(): this clears the durable request/ok/failed counters, not the live routing decision.\nexport async function resetProviderStats(): Promise {\n await run(sql`DELETE FROM provider_stats`).catch(() => {});\n}\n/** Per-instance roster for /health — the settings panel's \"test / status\" table reads exactly this shape.\n * requests/ok/failed/last_error come from the durable table (accurate across isolates). cooling/demoted\n * are hydrated from the persisted breaker state first, so a breaker another isolate tripped is visible\n * here too — this closes the \"may show ready while a concurrent request elsewhere is avoiding it\" gap\n * the previous version of this comment documented. */\nexport async function getInstanceRoster() {\n await hydrateBreakers();\n const statsRow = await providerStatsAll();\n const stats = new Map((statsRow.ok ? statsRow.value : []).map((r: any) => [r.name, r]));\n const now = Date.now();\n return getProviderArray().map((p) => {\n const b = getBreaker(p.name);\n const s = stats.get(p.name);\n const cooling = b.state === \"OPEN\" ? { ms_left: Math.max(0, b.nextAttempt - now), reason: b.lastError ?? \"circuit open\" } : null;\n const demoted = b.demotedUntil > now ? { ms_left: b.demotedUntil - now, reason: b.demotedReason ?? \"config error\" } : null;\n return {\n name: p.name, key: p.key ? `${p.keyEnv}…${p.key.slice(-4)}` : null, key_issue: p.keyIssue,\n requests: s?.requests ?? 0, ok: s?.ok ?? 0, failed: s?.failed ?? 0,\n cooling, demoted, last_error: b.lastError ?? s?.last_error ?? null,\n };\n });\n}\n\nexport async function getSavedModels(): Promise> {\n const r = await all(\"omni_router_config\", sql`SELECT * FROM omni_router_config`);\n if (!r.ok) return {};\n return Object.fromEntries((r.value as any[]).map((row) => [row.provider, row.selected_model]));\n}\n\nexport type RouteOpts = {\n model?: string; tools?: unknown[]; tool_choice?: unknown;\n temperature?: number; max_tokens?: number; stream?: boolean; response_format?: unknown;\n deadlineMs?: number; // caller's remaining wall-clock budget (ms), from request receipt, for the WHOLE routeInference call — not per-attempt\n};\nexport type RouteHit = { provider: ProviderInstance; model: string; latencyMs: number; res: Response; plan?: string[]; trail?: RouteAttempt[] };\n// One row per provider try (or skip) — the raw material for the routing flowchart (app.tsx's PassMeter\n// turns this into a synthetic \"route\" ToolEvent; ui-timeline.ts draws it as a chain of nodes). Attached to\n// RouteHit on success and to the thrown error on exhaustion, so the flowchart exists in BOTH outcomes —\n// \"what did it actually try\" must answer the same whether the turn ended in an answer or a 503.\nexport type RouteAttempt = {\n provider: string; vendor: string; model: string; pass: number; timeoutMs: number;\n ok: boolean; skipped?: boolean; demoted?: boolean; latencyMs?: number; error?: string; ts: number;\n};\n\n// A 200 OK with an empty message, or a message that's nothing but dots (a known vendor failure\n// signature — truncated/garbage generations some providers return under load instead of a real error),\n// is not a valid answer. Only a plain-string content is checked — array/multi-part content bodies are\n// left alone rather than risk a false positive on a legitimate format we haven't seen. tool_calls-only\n// messages (content legitimately empty/null) are never flagged.\nfunction isEmptyOrDotContent(msg: any): boolean {\n if (Array.isArray(msg?.tool_calls) && msg.tool_calls.length) return false;\n if (typeof msg?.content !== \"string\") return false;\n const stripped = msg.content.replace(/\\s+/g, \"\");\n return stripped.length === 0 || /^\\.+$/.test(stripped);\n}\n\n// 4xx config errors still fail over but don't trip the breaker (no oscillation on a bad key/model id).\nasync function attempt(p: ProviderInstance, model: string, messages: unknown[], o: RouteOpts, timeoutMs: number): Promise {\n // A malformed secret never reaches the network: gemini's `…3, }` key produced 62 identical \"Failed to\n // construct 'Request': … not a valid ByteString\" failures — thrown by the Request constructor, so it\n // had no HTTP status, was classed retryable, tripped the breaker on a 25s cycle and was retried on\n // every single request forever. It is a config error by definition; say so, and let demotion park it.\n if (p.keyIssue) throw Object.assign(new Error(`KEY_MALFORMED (${p.keyEnv}): ${p.keyIssue}`), { retryable: false, configClass: true, status: 0 });\n const payload: Record = { model, messages, stream: !!o.stream };\n if (o.max_tokens && o.max_tokens > 0) payload.max_tokens = o.max_tokens;\n if (typeof o.temperature === \"number\") payload.temperature = o.temperature;\n // tool_choice:\"none\" with a tools array is semantically \"no tools callable\" — identical to sending no\n // tools at all — but Groq rejects the combination with HTTP 400 \"Tool choice is none, but model called a\n // tool\" (seen on every wrap-up pass this session). Send the equivalent form every vendor accepts.\n if (o.tools?.length && o.tool_choice !== \"none\") { payload.tools = o.tools; if (o.tool_choice) payload.tool_choice = o.tool_choice; }\n if (o.response_format) payload.response_format = o.response_format;\n const ctl = new AbortController();\n const timer = setTimeout(() => ctl.abort(), timeoutMs);\n const t0 = performance.now();\n try {\n const headers: Record = { \"Content-Type\": \"application/json\", \"HTTP-Referer\": \"https://val.town\", \"X-Title\": \"Ziggyware-OmniRouter\" };\n if (p.key) headers.Authorization = `Bearer ${p.key}`;\n const res = await fetch(`${p.base}/chat/completions`, { method: \"POST\", headers, body: JSON.stringify(payload), signal: ctl.signal });\n if (!res.ok) {\n const body = await res.text().catch(() => \"\");\n const e: any = new Error(`HTTP ${res.status}: ${body.slice(0, 300)}`);\n e.retryable = RETRYABLE.has(res.status);\n e.status = res.status;\n e.configClass = isConfigClass(res.status, body);\n throw e;\n }\n // Headers arrived within timeoutMs — that phase is done; clear its timer here, exactly like before\n // content validation existed. CONFIRMED REGRESSION (live /health: anthropic's success rate went from\n // 6/7 to 6/23 after this was added, nearly all new failures API_STALLED_TIMEOUT): keeping the SAME\n // timer armed through the full body read punished large, legitimately-slow-but-completing generations\n // (this app requests up to 16k max_tokens against prompts confirmed 18k+ tokens by a live Groq 413) —\n // a completion that needed even a few seconds past a shrunk, late-pass timeoutMs to finish sending was\n // aborted and misreported as a stall. Body read gets its OWN separate, generous, fixed budget instead —\n // independent of the caller's possibly-tiny remaining timeoutMs — so content validation (which does\n // need the full body) can't retroactively punish a provider that already answered in time.\n if (!o.stream) {\n clearTimeout(timer);\n const BODY_READ_TIMEOUT_MS = 20_000;\n let text: string;\n try {\n text = await Promise.race([\n res.text(),\n new Promise((_, reject) =>\n setTimeout(() => reject(Object.assign(new Error(\"API_STALLED_TIMEOUT\"), { retryable: true, name: \"AbortError\" })), BODY_READ_TIMEOUT_MS)\n ),\n ]);\n } catch (e: any) {\n res.body?.cancel().catch(() => {});\n throw e;\n }\n let json: any = null;\n try { json = JSON.parse(text); } catch { /* not JSON — let router-openai.ts's own parse surface the real error */ }\n const msg = json?.choices?.[0]?.message;\n if (json && isEmptyOrDotContent(msg)) {\n const e: any = new Error(`EMPTY_OR_DOT_RESPONSE: ${JSON.stringify(String(msg?.content ?? \"\")).slice(0, 60)}`);\n e.retryable = true;\n throw e;\n }\n return { provider: p, model, latencyMs: Math.round(performance.now() - t0), res: new Response(text, { status: res.status, headers: res.headers }) };\n }\n clearTimeout(timer);\n return { provider: p, model, latencyMs: Math.round(performance.now() - t0), res };\n } catch (e: any) {\n clearTimeout(timer);\n // Root cause of a real observed failure: a provider that reliably STALLS (never errors, just never\n // finishes — nemotron-ultra#2/#3 in a live /health dump: 14 and 1 requests, 0 ok, last_error\n // API_STALLED_TIMEOUT on every one) was structurally EXEMPT from demotion. isConfigClass() only ever\n // fires from the res.ok===false branch above (a real HTTP status), so an AbortError never set\n // configClass — report() then reset cfgFails to 0 every time (line \"else b.cfgFails = 0\"), so the\n // streak needed to demote (CFG_DEAD_AFTER) could never accumulate no matter how many times in a row\n // this exact instance stalled. Each stall still costs up to HARD_TIMEOUT_MS (30s) or\n // BODY_READ_TIMEOUT_MS (20s) of the invocation's 50s wall-clock ceiling — one or two stalling\n // instances sitting at their normal (undemoted) mid-plan position can consume nearly the ENTIRE\n // per-invocation budget, so everything scheduled after them in `targets` (in this case: groq's and\n // openrouter's later key slots) never gets attempted at all, invocation after invocation, because plan\n // order is otherwise stable. Marking this configClass (same as a config-dead 402/403/404) lets it\n // accumulate the same way: `retryable` stays true so the normal 25s breaker still applies unchanged,\n // but after CFG_DEAD_AFTER (2) consecutive stalls with no success in between (any ok=true resets the\n // streak — see report()) it now also gets demoted to the tail for CFG_DEAD_MS, the same relief valve\n // already used for a dead key/model, freeing its prime plan position for providers that answer fast.\n if (e.name === \"AbortError\") { const t: any = new Error(\"API_STALLED_TIMEOUT\"); t.retryable = true; t.configClass = true; throw t; }\n // Thrown before any bytes left the process (Request/URL construction) ⇒ our configuration, not their\n // outage. Retrying a TypeError is never going to produce a different result.\n if (e instanceof TypeError && /construct|Invalid URL|ByteString/i.test(String(e.message))) { e.retryable = false; e.configClass = true; }\n if (e.retryable === undefined) e.retryable = true;\n throw e;\n }\n}\n\n// Depth-first (priority, then key-slot) means a single vendor-wide outage — the vendor itself stalling,\n// not any one key being bad — burns every key slot of THAT vendor before a different vendor is ever\n// tried. Observed directly: openrouter/nemotron-ultra + #1 both API_STALLED_TIMEOUT, consuming the whole\n// deadline, while cerebras/groq/mistral/etc. sat untouched. Breadth-first — one instance per vendor first\n// (in existing priority order), second key-slots only in a later wave — means 2 failed attempts always\n// means 2 DIFFERENT vendors tried, not 2 keys of the one that happens to be down. Vendor-relative priority\n// (which model/vendor is preferred) is unchanged; only the within-vendor key-slot ordering is deferred.\nfunction breadthFirst(targets: ProviderInstance[]): ProviderInstance[] {\n const byVendor = new Map();\n for (const p of targets) {\n if (!byVendor.has(p.vendor)) byVendor.set(p.vendor, []);\n byVendor.get(p.vendor)!.push(p);\n }\n const waves: ProviderInstance[][] = [];\n for (const group of byVendor.values()) group.forEach((p, i) => (waves[i] ??= []).push(p));\n return waves.flat();\n}\n\n// Pure breadthFirst() above overcorrected: a second key set on the SAME provider/model (added for\n// throughput / per-key rate-limit headroom) is a different catalog row's slot only in the trivial\n// single-row case — for a vendor with multiple catalog rows (e.g. openrouter's 3 free models), that\n// alt key's position within its own vendor's flattened list can land many entries deep, which\n// breadthFirst then schedules behind EVERY other vendor's primary. Simulated against the real catalog\n// shape (openrouter, 2 keys/row): the alt key landed at attempt #13, while only ~3 attempts fit inside\n// a real turn deadline before providers that hang to HARD_TIMEOUT_MS exhaust it — so the alt key was\n// structurally almost never reached. Fix: let each vendor's TOP-priority row retry with ONE alt key\n// (SAME_KEY_RETRY_CAP) immediately, before the loop advances to a different vendor — this is the only\n// way to make \"I bought a backup key for this rate-limited provider\" actually work — then fall back to\n// breadthFirst for everything else (other rows of that vendor, and any keys beyond the cap). Confirmed\n// via simulation this bounds the regression: worst case (every attempt times out) still guarantees ≥2\n// DIFFERENT vendors get tried before the deadline dies, vs 3 under pure breadthFirst — a small, bounded\n// cost in exchange for alt keys actually being usable.\nconst SAME_KEY_RETRY_CAP = 1;\n// Tier 2 (below) was added after live diagnostics showed a vendor's OTHER catalog rows (e.g. openrouter's\n// qwen3-coder/gpt-oss, siblings of its top-priority nemotron-ultra) going untried in practice even though\n// tier 1 + breadthFirst() both nominally include them: tier 1 only ever admits ONE row per vendor (the top\n// one, plus its own alt keys), and breadthFirst groups by VENDOR not by catalog row — so a sibling row's\n// primary key ends up scheduled behind every alt-key retry of the vendor's first-tried row, many entries\n// deep, structurally unreachable before the wall clock runs out. Fix: a middle tier that gives each\n// vendor's OTHER rows' PRIMARY key (slot 0 only — not their alt keys, which stay in tier 3) a turn right\n// after tier 1's same-row retries, before any vendor's second key of anything. Deliberately NOT folding all\n// of a vendor's rows into tier 1 — that was considered and rejected: a vendor with many free-tier rows\n// could then burn several attempts against what's often a shared per-vendor daily rate limit (confirmed\n// this session: OpenRouter's \"free models per day\" cap) before a different vendor is ever reached.\nfunction orderTargets(targets: ProviderInstance[]): ProviderInstance[] {\n const byVendor = new Map();\n for (const p of targets) {\n if (!byVendor.has(p.vendor)) byVendor.set(p.vendor, []);\n byVendor.get(p.vendor)!.push(p);\n }\n const baseName = (p: ProviderInstance) => p.name.split(\"#\")[0];\n const heads: ProviderInstance[] = []; // tier 1: each vendor's top row, primary key + capped alt-key retries\n const headSet = new Set();\n const siblings: ProviderInstance[] = []; // tier 2: each vendor's OTHER rows, primary key only\n const siblingSet = new Set();\n for (const group of byVendor.values()) {\n if (!group.length) continue;\n const top = group[0]; // already sorted priority,slot — group[0] is this vendor's best row's primary key\n heads.push(top);\n headSet.add(top);\n let taken = 0;\n for (let j = 1; j < group.length && taken < SAME_KEY_RETRY_CAP; j++) {\n if (baseName(group[j]) !== baseName(top)) break; // only the SAME row's own alt keys qualify — a different model doesn't jump the queue\n heads.push(group[j]);\n headSet.add(group[j]);\n taken++;\n }\n const seenRows = new Set([baseName(top)]);\n for (const p of group) {\n const b = baseName(p);\n if (seenRows.has(b)) continue; // either the top row, or an alt key of a sibling row already claimed below\n seenRows.add(b);\n siblings.push(p);\n siblingSet.add(p);\n }\n }\n const rest = targets.filter((p) => !headSet.has(p) && !siblingSet.has(p));\n return [...heads, ...siblings, ...breadthFirst(rest)];\n}\n\n// Item 9: defensive ceiling on `trail`'s own memory footprint, independent of router-openai.ts's separate\n// last-TRAIL_CAP(60) slice taken when serializing the response. That slice only ever protects the wire\n// payload; the in-memory array itself was unbounded, so a pathological worst case (MAX_FULL_PASSES=10 full\n// laps of a large catalog, every attempt failing) could grow it far past what any consumer ever reads.\n// Trimming from the front keeps the most recent — and therefore most diagnostically relevant — entries.\nconst ROUTE_TRAIL_HARD_CAP = 300;\nfunction pushTrail(trail: RouteAttempt[], entry: RouteAttempt): void {\n trail.push(entry);\n if (trail.length > ROUTE_TRAIL_HARD_CAP) trail.splice(0, trail.length - ROUTE_TRAIL_HARD_CAP);\n}\n\nexport async function routeInference(messages: unknown[], o: RouteOpts = {}): Promise {\n await acquire();\n try {\n await hydrateBreakers();\n const live = getProviderArray();\n if (!live.length) throw Object.assign(new Error(\"NO_PROVIDERS_CONFIGURED\"), { status: 503 });\n const resolved = resolveTargets(o.model, live);\n const ordered = orderTargets(resolved.targets);\n // Demoted (config-dead) instances go to the tail as a block, in their existing relative order. This is a\n // stable partition, not a filter: every instance is still in `targets`, still reached by a full pass,\n // still covered by fail-open. What changes is only that a provider proven dead-by-configuration stops\n // costing a round-trip ahead of the ones that might actually answer.\n const demotedSet = new Set(ordered.filter((p) => isDemoted(p.name)));\n const targets = [...ordered.filter((p) => !demotedSet.has(p)), ...ordered.filter((p) => demotedSet.has(p))];\n const { forcedModel } = resolved;\n if (!targets.length) throw Object.assign(new Error(`UNKNOWN_MODEL: ${o.model}`), { status: 404 });\n const saved = await getSavedModels();\n const modelFor = (p: ProviderInstance) => forcedModel ?? saved[p.name.split(\"#\")[0]] ?? p.fallbackModel;\n const errors: string[] = [];\n const triedNames = new Set(); // distinct providers actually attempted (any pass) — see the exhaustion throw below\n const plan = targets.map((p) => p.name); // full planned order, BEFORE any attempt — the flowchart's \"intended route\"\n const trail: RouteAttempt[] = []; // every attempt AND skip, in the order it actually happened — the flowchart's \"actual route\"\n let currentPass = 1;\n\n // Hard wall-clock ceiling for THIS invocation, independent of whatever the caller's o.deadlineMs\n // says: Val Town's free tier kills the function outright around 60s with NO response sent at all —\n // that's worse than a clean 503. 50s leaves margin for parsing/serialization after the last attempt\n // returns. A caller deadline, when present and smaller, still narrows further (honors the caller's\n // own remaining turn budget) — it can only shrink this ceiling, never extend past it.\n const t0 = Date.now();\n const SAFETY_CEILING_MS = 50_000;\n const callDeadline = o.deadlineMs && o.deadlineMs > 0 ? Math.min(o.deadlineMs, SAFETY_CEILING_MS) : SAFETY_CEILING_MS;\n // Was lowered to 1_200 for breadth, then raised back up: a fast-failing provider (bad key, wrong\n // model, exhausted quota — the majority of what's actually being seen in practice) rejects in well\n // under a second regardless of this floor, so a low floor never helped THOSE. What it did do was let\n // a genuinely slow-but-working provider get attempted with almost no realistic chance to finish,\n // burning the slot for nothing. 5s is still short relative to HARD_TIMEOUT_MS's 30s, but below it a\n // real non-streaming completion for this workload's prompt/output sizes has no realistic chance.\n const MIN_ATTEMPT_MS = 5_000;\n const remaining = () => callDeadline - (Date.now() - t0) - 500; // 500ms margin for overhead after the last attempt\n const attemptOne = async (p: ProviderInstance): Promise => {\n const timeoutMs = Math.min(HARD_TIMEOUT_MS, remaining());\n if (timeoutMs < MIN_ATTEMPT_MS) {\n errors.push(`${p.name}: skipped — ${Math.max(0, timeoutMs)}ms left`);\n pushTrail(trail, { provider: p.name, vendor: p.vendor, model: modelFor(p), pass: currentPass, timeoutMs: Math.max(0, timeoutMs), ok: false, skipped: true, demoted: demotedSet.has(p) || undefined, error: \"out of time\", ts: Date.now() });\n return null;\n }\n const model = modelFor(p);\n const demoted = demotedSet.has(p) || undefined;\n triedNames.add(p.name);\n try {\n const hit = await attempt(p, model, messages, o, timeoutMs);\n await report(p.name, true);\n pushTrail(trail, { provider: p.name, vendor: p.vendor, model, pass: currentPass, timeoutMs, ok: true, demoted, latencyMs: hit.latencyMs, ts: Date.now() });\n return { ...hit, plan, trail };\n } catch (e: any) {\n await report(p.name, false, e.message, !!e.retryable, !!e.configClass);\n errors.push(`${p.name}: ${e.message}`);\n pushTrail(trail, { provider: p.name, vendor: p.vendor, model, pass: currentPass, timeoutMs, ok: false, demoted, error: String(e.message).slice(0, 200), ts: Date.now() });\n console.warn(`[SEVERED] ${p.name} (${e.message})`);\n return null;\n }\n };\n // Never declare exhaustion after a handful: walk the ENTIRE ordered target list every pass (skipping\n // only breaker-open providers, restored below via fail-open if a pass skips everyone), and if the\n // whole list comes up empty with wall-clock room left, run it again — up to MAX_FULL_PASSES — instead\n // of giving up after one lap. A later pass can also pick up a provider whose 25s breaker cooldown\n // (BREAK_DURATION_MS) has since elapsed. In practice, MAX_FULL_PASSES is an upper bound the wall\n // clock rarely lets this reach — walking ~20-30 providers at HARD_TIMEOUT_MS each already consumes\n // the whole SAFETY_CEILING_MS in one pass if most of them stall. The rest of \"at least 10 tries\" is\n // deliberately NOT this function's job: main-script.ts's send loop re-invokes the whole turn (a\n // fresh 60s window each time, so not bounded by this invocation's wall clock) on an EXHAUSTED signal,\n // now guaranteed to happen at least 10 times before it gives up — see its comment for why splitting\n // the guarantee across invocations is the only way to honor it without Val Town killing the function\n // mid-response.\n const MAX_FULL_PASSES = 10;\n for (let pass = 1; pass <= MAX_FULL_PASSES; pass++) {\n currentPass = pass;\n const skipped: ProviderInstance[] = [];\n let attemptedThisPass = 0;\n for (const p of targets) {\n if (remaining() < MIN_ATTEMPT_MS) break; // wall clock is the only thing allowed to cut a pass short\n if (!admit(p.name)) {\n skipped.push(p);\n const b = getBreaker(p.name);\n pushTrail(trail, { provider: p.name, vendor: p.vendor, model: modelFor(p), pass, timeoutMs: 0, ok: false, skipped: true, demoted: demotedSet.has(p) || undefined, error: `circuit open — ${Math.max(0, b.nextAttempt - Date.now())}ms cooldown left`, ts: Date.now() });\n continue;\n }\n attemptedThisPass++;\n const hit = await attemptOne(p);\n if (hit) return hit;\n }\n // Fail-open: a breaker-open provider is skipped for SPEED when a healthier one might work instead,\n // never as a verdict that it's still down. If this pass skipped everyone, nothing was actually\n // attempted — that's not exhaustion, that's a stale verdict. Force one real try through the skipped\n // set before moving on, so \"all providers exhausted\" always means all providers were actually tried.\n if (attemptedThisPass === 0 && skipped.length) {\n for (const p of skipped) {\n if (remaining() < MIN_ATTEMPT_MS) break;\n const hit = await attemptOne(p);\n if (hit) return hit;\n }\n }\n if (remaining() < MIN_ATTEMPT_MS) break; // no room for another full pass\n }\n // Bug this closes: the message unconditionally said \"ALL_PROVIDERS_EXHAUSTED\" whether every configured\n // provider had genuinely been tried, or the wall-clock ceiling (SAFETY_CEILING_MS) cut a pass short\n // after only a handful — the two are completely different situations (one means \"come back later, this\n // key/model needs to recover\"; the other means \"we simply ran out of time this invocation, most of the\n // roster was never reached\") and the text gave no way to tell them apart. A live session mistook a\n // 6-of-N partial pass for a genuine full sweep because the message claimed \"ALL\" either way. `tried`\n // (distinct provider names actually attempted, this call, across every pass) vs `plan.length` (the full\n // ordered target list) makes the distinction explicit and machine-readable, not just prose.\n const triedCount = triedNames.size, totalCount = plan.length;\n const scope = triedCount >= totalCount ? `tried all ${totalCount}` : `ran out of time — tried ${triedCount}/${totalCount}, never reached: ${targets.filter((p) => !triedNames.has(p.name)).map((p) => p.name).join(\", \") || \"(none)\"}`;\n throw Object.assign(new Error(`ALL_PROVIDERS_EXHAUSTED (${scope})\\n${errors.join(\"\\n\")}`), { status: 503, errors, plan, trail, tried: triedCount, total: totalCount });\n } finally { release(); }\n}\n",[],[413],"f4612f85-5e74-4631-bd53-239e820c0dee","router-attempt.ts","c60156b4-abcf-11f1-b2a4-1607ee4eb77e",1445,["D",1789091784441],8,"import type { ProviderInstance } from \"./inference-provider.ts\";\nimport { headersFor } from \"./router-discover.ts\";\n\nexport type RouteOpts = { model?: string; stream?: boolean; extra?: Record; deadlineMs?: number; expectTokens?: number; keyPolicy?: \"depth\" | \"breadth\" | \"rr\"; vendorOrder?: string[]; exclude?: string[] };\nexport type Fail = Error & { kind: \"model\" | \"rate\" | \"auth\" | \"quota\" | \"size\" | \"transient\"; retryAfterMs?: number; sentMax?: number; resetAt?: number };\nconst QUOTA = /balance|recharge|insufficient|余额|credits?|quota|billing|payment|per[ _-]day|daily|monthly|exceeded your|free.?tier|limit reached for the day|\\b[rt]pd\\b/i;\n/** When a quota-class failure heals: header epoch, \"daily\" → next UTC midnight, else re-probe in 6 h (funds/credits can be added any time). */\nexport function quotaResetAt(res: Response | null, body: string): number {\n const now = Date.now();\n const h = res?.headers.get(\"x-ratelimit-reset\") ?? res?.headers.get(\"x-ratelimit-reset-requests\") ?? \"\";\n const n = Number(h);\n if (n > 0) { const ms = n > 1e12 ? n : n > 1e9 ? n * 1000 : now + n * 1000; if (ms > now && ms < now + 36 * 3_600_000) return ms; }\n if (/per day|daily|for the day|today/i.test(body)) { const d = new Date(now); d.setUTCHours(24, 0, 0, 0); return d.getTime() + 60_000; }\n return now + 6 * 3_600_000;\n}\n// \"Limit 6000, Requested 9000\" (Groq TPM) or \"maximum context length is 8192 tokens ... requested 9000\": shrink to fit.\nexport function shrinkMaxTokens(o: RouteOpts, body: string, sent?: number): boolean {\n const cur = sent || Number(o.extra?.max_tokens);\n if (!cur || cur <= 512) return false;\n const lim = body.match(/limit[^\\d]{0,12}(\\d+)/i), req = body.match(/request(?:ed)?[^\\d]{0,12}(\\d+)/i);\n const next = lim && req ? Math.min(cur - (Number(req[1]) - Number(lim[1])) - 64, Number(lim[1]) - 64) : Math.floor(cur / 2);\n o.extra = { ...o.extra, max_tokens: Math.max(512, Math.min(next, cur - 256)) };\n return true;\n}\n/** A size error the PROMPT alone caused: shrinking max_tokens cannot fix it. Groq ITPM, context-length overflows. Returns the input limit when stated. */\nexport function inputBound(body: string): number | null {\n if (!/input tokens|ITPM|prompt tokens|context length|maximum context|too many tokens in (the )?prompt/i.test(body)) return null;\n const m = body.match(/limit[^\\d]{0,12}(\\d+)/i) ?? body.match(/context length (?:of|is) (\\d+)/i);\n return m ? Number(m[1]) : 0;\n}\n/** Rough prompt size in tokens: chars/3.6 over messages + tool schemas (vendors tokenize JSON worse than prose). */\nexport const estimateInputTokens = (messages: unknown[], extra?: Record) => Math.ceil((JSON.stringify(messages).length + (extra?.tools ? JSON.stringify(extra.tools).length : 0)) / 3.6);\n/** \"Limit N\" from a size error when it is an output ceiling (OTPM / max_tokens), else null */\nexport function outputLimit(body: string): number | null {\n if (!/output|max_tokens|completion/i.test(body)) return null;\n const m = body.match(/limit[^\\d]{0,12}(\\d+)/i) ?? body.match(/(?:less than or equal to|maximum value[^\\d]{0,30}is|at most)[^\\d]{0,6}(\\d+)/i);\n return m ? Number(m[1]) : null;\n}\n\nexport function classify(status: number, body: string): Fail[\"kind\"] {\n if ((status === 429 || status === 413 || status === 400) && /too large|too long|context length|maximum context|exceeds.*tokens|reduce.*(length|tokens)/i.test(body)) return \"size\";\n if (status === 429 && QUOTA.test(body)) return \"quota\";\n if ((status === 429 || status === 400) && /max_tokens.{0,40}(less than or equal|maximum value|must be at most)|maximum value for .max_tokens/i.test(body)) return \"size\";\n if (status === 429) return \"rate\";\n if (status === 404 || /model_not_found|invalid.model|tier_not_allowed|does not (exist|support)|not (found|exist|supported|available)|unsupported|decommissioned|deprecated|no access|unable to access/i.test(body)) return \"model\";\n // A 400 is a request/output defect, never billing: the body often quotes the model's own generation (tool_use_failed\n // carries failed_generation), and any \"credits\"/\"balance\" word in that text would otherwise cool the key for hours.\n if (status === 400) return \"transient\";\n if (status === 402 || (status === 403 && QUOTA.test(body))) return \"quota\";\n if (status === 401 || status === 403 || /api.?key|unauthorized|invalid.?token/i.test(body)) return \"auth\";\n return \"transient\";\n}\n\n// timeoutMs covers headers AND (non-stream) body: a slow vendor streaming a long\n// completion past the deadline is the failure mode that killed 60 s turns.\n// capMax: the largest completion this vendor can stream before the deadline; a\n// truncated answer (finish_reason \"length\") beats a timeout — the caller continues it.\nexport async function attempt(p: ProviderInstance, model: string, messages: unknown[], o: RouteOpts, timeoutMs: number, capMax = Infinity): Promise {\n const payload: Record = { ...o.extra, model, messages, stream: !!o.stream };\n const cap = Math.min(p.maxOut ?? Infinity, capMax);\n if (Number(payload.max_tokens) > cap) payload.max_tokens = cap;\n const ctl = new AbortController();\n const timer = setTimeout(() => ctl.abort(), timeoutMs);\n const abortP = new Promise((_, rej) => ctl.signal.addEventListener(\"abort\", () => rej(Object.assign(new Error(\"TIMEOUT\"), { kind: \"transient\" }))));\n try {\n const res = await Promise.race([fetch(`${p.base}/chat/completions`, { method: \"POST\", headers: headersFor(p), body: JSON.stringify(payload), signal: ctl.signal }), abortP]);\n if (res.ok) {\n if (o.stream) return res;\n const text = await Promise.race([res.text(), abortP]).catch((e) => { res.body?.cancel().catch(() => {}); throw e; });\n return new Response(text, { status: res.status, headers: { \"content-type\": res.headers.get(\"content-type\") ?? \"application/json\", \"x-omni-sent-max\": String(payload.max_tokens ?? \"\") } });\n }\n const body = await res.text().catch(() => \"\");\n const e = new Error(`HTTP ${res.status}: ${body.slice(0, 500)}`) as Fail;\n e.kind = classify(res.status, body);\n // 429 with \"remaining: 0\" and a reset far away is a quota even when the body says nothing useful (OpenRouter free-models-per-day)\n if (e.kind === \"rate\" && res.headers.get(\"x-ratelimit-remaining\") === \"0\") { const at = quotaResetAt(res, body); if (at - Date.now() > 5 * 60_000) e.kind = \"quota\"; }\n e.sentMax = Number(payload.max_tokens) || undefined;\n const ra = Number(res.headers.get(\"retry-after\")) || Number((body.match(/try again in\\s*([\\d.]+)\\s*s/i) ?? [])[1]) || 0;\n if (e.kind === \"rate\" && ra > 0) e.retryAfterMs = Math.min(Math.ceil(ra * 1000) + 500, 15 * 60_000);\n if (e.kind === \"quota\") e.resetAt = quotaResetAt(res, body);\n throw e;\n } catch (e: any) {\n if (!e.kind) { e.kind = \"transient\"; e.message = e.name === \"AbortError\" ? \"TIMEOUT\" : `NETWORK: ${e.message}`; }\n ctl.abort();\n throw e;\n } finally { clearTimeout(timer); }\n}\n\n",[],[422],"907e461a-ab53-4642-a09e-fdbb24410980","rate-limit-tracker.ts","2ed0f30a-aae2-11f1-ad3f-1607ee4eb77e",1219,["D",1788802411124],3,"// rate-limit-tracker.ts — ~800 chars\ninterface RateLimitState {\n dailyRequests: Record; // model → request count\n resetTime: Record; // model → unix timestamp (ms)\n}\n\nexport class RateLimitTracker {\n private state: RateLimitState = {\n dailyRequests: {},\n resetTime: {},\n };\n\n canRequest(model: string, limit: number): boolean {\n const now = Date.now();\n const resetAt = this.state.resetTime[model] ?? 0;\n\n if (now >= resetAt) {\n // Day boundary crossed → reset\n this.state.dailyRequests[model] = 0;\n this.state.resetTime[model] = now + 86400000; // +1 day\n }\n\n const current = this.state.dailyRequests[model] ?? 0;\n return current < limit;\n }\n\n recordRequest(model: string) {\n this.state.dailyRequests[model] = (this.state.dailyRequests[model] ?? 0) +\n 1;\n }\n\n remaining(model: string, limit: number): number {\n return Math.max(0, limit - (this.state.dailyRequests[model] ?? 0));\n }\n}",[],[431],"14c474e8-2e93-4d58-a954-adbffc7c5b8b","quality-report.ts","fc3a82a2-ad8a-11f1-9829-1607ee4eb77e",1457,["D",1789094787388],"import { qualityReport } from \"./artifacts.ts\";\nconst basic = [{ path: \"index.html\", content: \"

\" }, { path: \"app.js\", content: \"const c=document.getElementById('c').getContext('2d');\\nfunction draw(){c.fillRect(0,0,10,10);requestAnimationFrame(draw)}\\ndraw();\\nalert('hi')\\n\" }];\nconst q = qualityReport(basic); console.log(q.length, \"findings\"); console.log(q.map(x => x.slice(0, 60)).join(\"\\n\"));\nconst good = Array.from({ length: 9 }, (_, i) => ({ path: i ? `m${i}.js` : \"index.html\", content: (i ? \"export const x=1;\\n\" : \"

nothing here yet

\") + \"// filler\\n\".repeat(110) }));\ngood.push({ path: \"README.md\", content: \"- f\\n\".repeat(12) });\ngood.push({ path: \"core.js\", content: \"devicePixelRatio; new ResizeObserver(()=>{}); document.addEventListener('visibilitychange',()=>{}); requestAnimationFrame(()=>{}); addEventListener('keydown',()=>{}); addEventListener('pointerdown',()=>{}); try{localStorage.getItem('a')}catch(e){} const schemaVersion=2; function undo(){} toast(); fetch('x').catch(()=>{})\" });\nconsole.log(\"good:\", qualityReport(good));\n",[],[440],"fada88c3-bc24-40d1-af47-b564ac76d0c4","prompts.ts","2f259634-abe2-11f1-966c-1607ee4eb77e",1487,["D",1789154860496],"// Every prompt the app sends, in one place. Each is a template with {{vars}};\n// users override any of them per request (settings.prompts[key]) and the UI\n// fetches this table from GET ?prompts to show defaults + placeholders.\nimport { PROMPT_EXAMPLES } from \"./prompt-examples.ts\";\n\nexport type PromptKey = \"system\" | \"meta\" | \"firstExchange\" | \"plan\" | \"reconcile\" | \"critique\" | \"revise\" | \"reground\" | \"continue\" | \"summarize\" | \"workbench\" | \"skill\" | \"architect\" | \"builder\" | \"integrate\" | \"digest\" | \"completion\" | \"brief\" | \"compact\";\n\nexport const PROMPT_VARS: Record = {\n system: [\"date\", \"tools\", \"skills\", \"focus\", \"memory\", \"rojs\", \"user\"],\n meta: [\"open\", \"close\"],\n firstExchange: [],\n plan: [],\n reconcile: [\"drafts\"],\n critique: [\"question\", \"answer\"],\n revise: [\"question\", \"answer\", \"flaw\"],\n reground: [\"question\"],\n continue: [],\n summarize: [],\n workbench: [\"id\", \"title\", \"files\", \"file\", \"selection\", \"errors\"],\n skill: [\"name\", \"body\"],\n architect: [\"ask\", \"user\", \"skills\"],\n builder: [\"title\", \"path\", \"purpose\", \"exports\", \"imports\", \"shared\", \"manifest\", \"notes\", \"features\", \"visual\"],\n integrate: [\"id\", \"issues\"],\n digest: [\"ask\", \"part\", \"n\", \"text\"],\n completion: [\"ask\", \"did\", \"reply\", \"quality\"],\n brief: [\"ask\"],\n compact: [\"previous\", \"transcript\"],\n};\n\nexport const DEFAULT_PROMPTS: Record = {\n system: `You are OMNI: a principal-level engineer, analyst and writer acting as an agent. Date {{date}}. Tools available this turn: {{tools}}.\n\nDoctrine\n1. Classify the ask silently — ANSWER (fact/explanation) · BUILD (code/app/doc) · ANALYZE (data/tradeoff/review) · TRANSFORM (rewrite/convert) — and deliver exactly that class. Never print the class label. No restating the question, no preamble, no closing offers, no \"certainly\".\n2. Density: every sentence load-bearing. Numbers carry units and provenance. Uncertainty is stated as a number or a named unknown, never as hedging adverbs.\n3. Correctness order: correctness > user's explicit constraints > brevity > style. When two readings of the ask are plausible, pick the more demanding one and say which you picked in one clause.\n4. BUILD: complete, runnable, idiomatic; standard library first; state the algorithmic or perf property that matters.\n ABSOLUTE: no placeholders, stubs, dummy data, mock implementations, TODO/FIXME markers, \"…\" elisions, \"rest of the code\", \"add your logic here\", empty function bodies, or \"simplified\" versions — ever, in any file, under any time pressure. If the full implementation does not fit in one call, write complete files now and add the remaining files in the next update_artifact call; never ship a stub to fill the gap. A write that leaves a placeholder is a failed write: the lint returns it as an issue and the turn is not finished until it is gone.\n VIRTUOSO STANDARD (binding, checked): you are the strongest engineer and designer on this project, and a build is a finished PRODUCT, never a demo. Scale floor for anything called an app/game/tool/editor/dashboard/simulator: ≥ 8 files, ≥ 900 lines total, ≥ 10 distinct user-facing features enumerated in README.md and all implemented. Rubric every build must satisfy — RENDER: canvas/WebGL scaled by devicePixelRatio, ResizeObserver or resize handler, requestAnimationFrame loop with delta time and pause-when-hidden (visibilitychange), no layout thrash. INPUT: pointer + keyboard + touch (pointer events, keydown with a documented shortcut map shown in-app, focus management, no hover-only affordances). STATE: a single store with typed actions, undo/redo where the user edits anything, persistence with a versioned schema and migration (try/catch, memory fallback), import/export (JSON) where data exists. UI: a design-token system (CSS custom properties for color/space/type/radius/motion), responsive layout, dark theme default with prefers-color-scheme, transitions ≤ 200 ms, empty/loading/error states, toasts for outcomes, an in-app help/about panel. ROBUSTNESS: every async path has an error path with user-visible recovery, input validation with messages, no alert()/prompt()/confirm(), no global mutable leaks, no console.log left in shipped code (a real logger with levels if logging exists). MATH/ALGO: correct units and precision, stable numerics, O(n log n) or better where n scales, workers for anything > 16 ms. A11Y: semantic elements, aria-labels on icon buttons, visible focus rings, contrast ≥ 4.5:1. CRAFT: coherent typography scale, an actual visual identity (not browser defaults), micro-interactions, a11y-safe motion, iconography as inline SVG. Anything short of this is \"basic\" and is returned to you as quality findings; the turn is not finished while they stand. Anything the user will open and use (app, visualization, game, simulator, formatted document) is an ARTIFACT, never chat-pasted code.\n Artifact model — a project of files: \\`content\\` = entry index.html; \\`files\\` = siblings referenced by RELATIVE path (\n \n \n \n \n\n`;\n",[],[507],"f4de80e9-04a6-4602-817c-5664568fd8f5","lint-portability.ts","f80151d4-ad8a-11f1-bcb5-1607ee4eb77e",1456,["D",1789094780295],"import { lintArtifact, lintPortability } from \"./artifacts.ts\";\nconst files = [\n { path: \"index.html\", content: `` },\n { path: \"main.js\", content: `import {DATA} from './data.js';\\nfetch('./levels.json').then(r=>r.json());\\nparent.postMessage({a:1},'*');\\nconst u = location.origin + '/api';\\nlocalStorage.setItem('k','v');\\nnavigator.serviceWorker.register('sw.js');\\nconst img='/artifact/12/x.png';\\nexport function boot(){ return DATA.length }` },\n { path: \"data.js\", content: `export const DATA=[1,2,3];` },\n { path: \"ok.js\", content: `// comment /artifact/1\\nfunction save(k,v){ try{ localStorage.setItem(k,v) }catch(e){ mem[k]=v } }\\nconst mem={};\\nif (window.parent !== window) { parent.postMessage('x','*'); }\\nexport { save };` },\n];\nconst p = lintPortability(files); console.log(p.join(\"\\n\")); console.log(\"count\", p.length, \"ok.js hits\", p.filter(x=>x.startsWith(\"ok.js\")).length);\nconsole.log(\"full\", lintArtifact(files).length);\n",[],[515],"a6b5fd6d-aad0-48b0-ab06-9f58022a4307","issues.ts","bdf28d8e-b11b-11f1-b196-1607ee4eb77e",1623,["D",1789486813282],"// Durable bug/feature backlog (the `issue` table in db.ts) — agent tool functions plus a small read endpoint.\n//\n// Previously reported bugs and requested features existed only as prose inside chat history: not queryable\n// (\"what's still open for artifact #12, sorted by priority\"), and not reliable across a long or compacted\n// conversation — an old report can silently scroll out of the context window a model reads, or get folded\n// into a lossy running summary by app-compact.ts. These tools give the model a durable place to write down\n// what it found (or was told) and read it back later, in this session or a future one, instead of depending\n// on the item still being visible in recent chat turns.\nimport { all, one, run, sql, unwrap } from \"./db.ts\";\n\n// Local structural types instead of importing app.tsx's Tool/ToolCtx — mirrors app-swarm.ts's SwarmDeps\n// pattern (see its header comment): avoids a runtime import cycle back into app.tsx, and TypeScript's\n// structural typing means these satisfy app.tsx's own Tool/ToolCtx shapes without needing to share the type.\ntype ToolCtx = { session: string; turn?: { artifactId?: number } };\ntype Tool = { schema: Record; handle: (args: Record, ctx: ToolCtx) => Promise };\n\nconst KINDS = [\"bug\", \"feature\"] as const;\nconst STATUSES = [\"open\", \"in_progress\", \"fixed\", \"wontfix\", \"duplicate\"] as const;\nconst PRIORITIES = [\"low\", \"medium\", \"high\", \"critical\"] as const;\ntype Status = (typeof STATUSES)[number];\n\nexport const ISSUE_TOOLS: Record = {\n log_issue: {\n schema: {\n type: \"function\",\n function: {\n name: \"log_issue\",\n description:\n \"Record a bug or feature request in the durable backlog so it survives this turn and can be found again later — by you in a future session, or a human reviewing progress. Call this whenever the user reports something broken, asks for something to be added later rather than now, or you notice a defect while working that you are not fixing immediately. Do not use it for something you are about to fix right now in this same turn — just fix it.\",\n parameters: {\n type: \"object\",\n properties: {\n kind: { type: \"string\", enum: KINDS as unknown as string[], description: \"bug: something is broken. feature: something new to add.\" },\n title: { type: \"string\", description: \"One line summary, ≤80 chars.\" },\n description: { type: \"string\", description: \"What's wrong or wanted, with repro steps / context if it's a bug.\" },\n priority: { type: \"string\", enum: PRIORITIES as unknown as string[], description: \"Default medium.\" },\n artifactId: { type: \"number\", description: \"The artifact this concerns, if any. Omit for a session-level or general item.\" },\n },\n required: [\"kind\", \"title\", \"description\"],\n },\n },\n },\n handle: async ({ kind, title, description, priority, artifactId }, ctx) => {\n const k = String(kind);\n if (k !== \"bug\" && k !== \"feature\") return { error: `kind must be \"bug\" or \"feature\", got \"${k}\"` };\n const pRaw = String(priority || \"medium\");\n const pri = (PRIORITIES as readonly string[]).includes(pRaw) ? pRaw : \"medium\";\n const aid = Number.isInteger(Number(artifactId)) && Number(artifactId) > 0 ? Number(artifactId) : (ctx.turn?.artifactId ?? null);\n const now = Date.now();\n const r = await run(sql`INSERT INTO issue (session, artifact_id, kind, title, description, status, priority, source, created_ts, updated_ts, resolved_ts, notes)\n VALUES (${ctx.session}, ${aid}, ${k}, ${String(title).slice(0, 200)}, ${String(description).slice(0, 4000)}, 'open', ${pri}, 'model', ${now}, ${now}, NULL, '[]')`);\n if (!r.ok) return { error: r.error };\n const id = r.value.lastInsertRowid === undefined ? null : Number(r.value.lastInsertRowid);\n return { ok: true, id, kind: k, title: String(title).slice(0, 200), priority: pri };\n },\n },\n list_issues: {\n schema: {\n type: \"function\",\n function: {\n name: \"list_issues\",\n description:\n \"List items in the bug/feature backlog for this session (default: open items only), so work picks up where it left off instead of re-discovering the same problems or forgetting a requested feature.\",\n parameters: {\n type: \"object\",\n properties: {\n status: { type: \"string\", enum: [...STATUSES, \"all\"], description: 'Default \"open\".' },\n kind: { type: \"string\", enum: [...KINDS, \"all\"], description: 'Default \"all\".' },\n artifactId: { type: \"number\", description: \"Limit to one artifact.\" },\n },\n },\n },\n },\n handle: async ({ status, kind, artifactId }, ctx) => {\n const st = String(status || \"open\");\n const kd = String(kind || \"all\");\n const aid = artifactId != null && Number.isInteger(Number(artifactId)) ? Number(artifactId) : null;\n const rows = unwrap(\n await all(\n \"issue\",\n sql`SELECT * FROM issue WHERE session = ${ctx.session}\n AND (${st} = 'all' OR status = ${st})\n AND (${kd} = 'all' OR kind = ${kd})\n AND (${aid} IS NULL OR artifact_id = ${aid})\n ORDER BY (priority = 'critical') DESC, (priority = 'high') DESC, created_ts ASC LIMIT 100`,\n ),\n [],\n );\n return {\n count: rows.length,\n issues: rows.map((r) => ({ id: r.id, kind: r.kind, title: r.title, description: r.description, status: r.status, priority: r.priority, artifactId: r.artifact_id, created: r.created_ts })),\n };\n },\n },\n update_issue: {\n schema: {\n type: \"function\",\n function: {\n name: \"update_issue\",\n description:\n \"Update a backlog item's status — e.g. after fixing a bug or shipping a feature. Always include a short note saying what actually happened; it's appended to the item's audit trail, not shown as a replacement description.\",\n parameters: {\n type: \"object\",\n properties: {\n id: { type: \"number\", description: \"Issue id, from log_issue or list_issues.\" },\n status: { type: \"string\", enum: STATUSES as unknown as string[] },\n note: { type: \"string\", description: \"What changed — required.\" },\n },\n required: [\"id\", \"status\", \"note\"],\n },\n },\n },\n handle: async ({ id, status, note }) => {\n const iid = Number(id);\n const st = String(status);\n if (!(STATUSES as readonly string[]).includes(st)) return { error: `status must be one of ${STATUSES.join(\", \")}` };\n const cur = unwrap(await one(\"issue\", sql`SELECT * FROM issue WHERE id = ${iid}`), null);\n if (!cur) return { error: `no issue with id ${iid}` };\n let notes: unknown[] = [];\n try { notes = JSON.parse(cur.notes || \"[]\"); } catch { /* corrupt/empty — start fresh rather than fail the update */ }\n notes.push({ ts: Date.now(), text: String(note).slice(0, 1000) });\n const resolvedTs = (st === \"fixed\" || st === \"wontfix\" || st === \"duplicate\") ? Date.now() : null;\n await run(sql`UPDATE issue SET status = ${st as Status}, updated_ts = ${Date.now()}, resolved_ts = ${resolvedTs}, notes = ${JSON.stringify(notes).slice(0, 8000)} WHERE id = ${iid}`);\n return { ok: true, id: iid, status: st };\n },\n },\n};\n\n/** GET ?issues=list&session=S[&status=open][&kind=bug][&artifactId=N] → the same backlog, for non-tool (UI/debug) callers. */\nexport async function handleIssues(req: Request, url: URL): Promise {\n if (req.method !== \"GET\" || url.searchParams.get(\"issues\") !== \"list\") return null;\n const session = String(url.searchParams.get(\"session\") ?? \"\");\n if (!session) return Response.json({ error: { message: \"session required\" } }, { status: 400 });\n const st = String(url.searchParams.get(\"status\") ?? \"open\");\n const kd = String(url.searchParams.get(\"kind\") ?? \"all\");\n const aidParam = url.searchParams.get(\"artifactId\");\n const aid = aidParam != null && Number.isInteger(Number(aidParam)) ? Number(aidParam) : null;\n const rows = unwrap(\n await all(\n \"issue\",\n sql`SELECT * FROM issue WHERE session = ${session}\n AND (${st} = 'all' OR status = ${st})\n AND (${kd} = 'all' OR kind = ${kd})\n AND (${aid} IS NULL OR artifact_id = ${aid})\n ORDER BY (priority = 'critical') DESC, (priority = 'high') DESC, created_ts ASC LIMIT 200`,\n ),\n [],\n );\n return Response.json({ issues: rows });\n}\n",[],[523],"f7c3665a-ef01-4a0b-a6b6-dfb1dd469a40","inference-provider.ts","f5b23648-43b6-11f1-91e9-42b51c65c3df",1597,["D",1789451486226],57,"// Instance = catalog row × key slot (KEY, KEY1…KEY9 → name#n). keyEnv null ⇒ keyless.\nimport type { Row } from \"./db.ts\";\n\n// Same shape as the `provider` table row, with `model` required: every catalog\n// entry must name a default upstream id — name is \"/\".\nexport type ProviderSpec = Omit, \"model\"> & { model: string; tags?: string[]; paid?: boolean };\n\nexport type ProviderInstance = ProviderSpec & {\n vendor: string;\n slot: number;\n key: string | null;\n keyIssue: string | null; // non-null ⇒ the secret's VALUE is malformed (see keyIssue()); surfaced on /health and in the catalog\n fallbackModel: string;\n};\n\nconst KEY_SLOTS = 10;\n\n// Secret-value sanity. GEMINI_API_KEY was observed live this session with a literal `…3, }` suffix —\n// a JSON fragment pasted into the secret field — and it sat there across multiple diagnostics pulls\n// because nothing anywhere said \"this key cannot be right\" until an upstream 400 did, buried in a trail.\n// Leading/trailing whitespace is the one defect that is safe to repair silently (no real key contains\n// it); everything else is reported, never guessed at. Returns the reason, or null for a plausible key.\nexport function keyIssue(raw: string): string | null {\n if (/^[\"'`]|[\"'`]$/.test(raw)) return \"wrapped in quotes\";\n if (/[{}\\[\\],]/.test(raw)) return \"contains JSON punctuation ({ } [ ] ,)\";\n if (/\\s/.test(raw)) return \"contains internal whitespace\";\n if (/^bearer\\s/i.test(raw)) return 'starts with \"Bearer \" — paste only the token';\n if (raw.length < 8) return `implausibly short (${raw.length} chars)`;\n return null;\n}\n\n// ids verified 2026-09-08. Dropped: github_models (410, retiring), deepinfra (paid).\n// tags mirror v2/catalog-free.ts's vendor-level assignments (openrouter, huggingface, mistral, zai\n// are its \"coder\"-tagged vendors); ported here because app.tsx sends model:\"coder\" as a routing tag\n// for app-scale builds (see app.tsx ~line 1288), which this catalog previously had no way to honor.\nexport const CATALOG: ProviderSpec[] = [\n { id: \"1\", name: \"openrouter/nemotron-ultra\", base: \"https://openrouter.ai/api/v1\", model: \"nvidia/nemotron-3-ultra-550b-a55b:free\", keyEnv: \"OPENROUTER_API_KEY\", priority: 0, tags: [\"coder\", \"reasoning\", \"long\"] },\n { id: \"2\", name: \"openrouter/qwen3-coder\", base: \"https://openrouter.ai/api/v1\", model: \"qwen/qwen3-coder-next\", keyEnv: \"OPENROUTER_API_KEY\", priority: 1, tags: [\"coder\", \"reasoning\", \"long\"] },\n { id: \"3\", name: \"openrouter/gpt-oss\", base: \"https://openrouter.ai/api/v1\", model: \"openai/gpt-oss-120b\", keyEnv: \"OPENROUTER_API_KEY\", priority: 2, tags: [\"coder\", \"reasoning\", \"long\"] },\n // Re-verified 2026-09-14 against live HTTP 404s from the user's own /health: Cerebras has retired\n // Llama 3.3 70B from its public inference API entirely (confirmed via inference-docs.cerebras.ai —\n // only gpt-oss-120b and qwen-3.8-27b remain listed); Groq's llama-3.3-70b-versatile hit its announced\n // free/developer-tier deprecation date (2026-08-16, per console.groq.com/docs/deprecations) and is now\n // 404ing live, with Groq's own migration notice pointing at openai/gpt-oss-120b. Both replaced below.\n { id: \"4\", name: \"cerebras/gpt-oss-120b\", base: \"https://api.cerebras.ai/v1\", model: \"gpt-oss-120b\", keyEnv: \"CEREBRAS_API_KEY\", priority: 3 },\n { id: \"5\", name: \"sambanova/llama3.3-70b\", base: \"https://api.sambanova.ai/v1\", model: \"Meta-Llama-3.3-70B-Instruct\", keyEnv: \"SAMBANOVA_API_KEY\", priority: 4 },\n { id: \"6\", name: \"groq/gpt-oss-120b\", base: \"https://api.groq.com/openai/v1\", model: \"openai/gpt-oss-120b\", keyEnv: \"GROQ_API_KEY\", priority: 5 },\n { id: \"8\", name: \"mistral/large\", base: \"https://api.mistral.ai/v1\", model: \"mistral-large-latest\", keyEnv: \"MISTRAL_API_KEY\", priority: 7, tags: [\"coder\"] },\n { id: \"10\", name: \"openrouter_free/nemotron-lightning\", base: \"https://openrouter.ai/api/v1\", model: \"nvidia/nemotron-3.5-lightning:free\", keyEnv: \"OPENROUTER_API_KEY\", priority: 9 },\n { id: \"11\", name: \"gemini/flash-lite\", base: \"https://generativelanguage.googleapis.com/v1beta/openai\", model: \"gemini-2.5-flash-lite\", keyEnv: \"GEMINI_API_KEY\", priority: 10 },\n { id: \"12\", name: \"nvidia_nim/nemotron-ultra\", base: \"https://integrate.api.nvidia.com/v1\", model: \"nvidia/llama-3.1-nemotron-ultra-253b-v1\", keyEnv: \"NVIDIA_API_KEY\", priority: 11 },\n { id: \"13\", name: \"siliconflow/qwen3-8b\", base: \"https://api.siliconflow.cn/v1\", model: \"Qwen/Qwen3-8B\", keyEnv: \"SILICONFLOW_API_KEY\", priority: 12 },\n { id: \"14\", name: \"zai/glm-flash\", base: \"https://open.bigmodel.cn/api/paas/v4\", model: \"GLM-4.7-Flash\", keyEnv: \"ZAI_API_KEY\", priority: 13, tags: [\"coder\"] },\n { id: \"15\", name: \"huggingface/llama3.3-70b\", base: \"https://router.huggingface.co/v1\", model: \"meta-llama/Llama-3.3-70B-Instruct\", keyEnv: \"HF_TOKEN\", priority: 14, tags: [\"coder\", \"reasoning\", \"long\"] },\n { id: \"16\", name: \"ovh/llama3.3-70b\", base: \"https://oai.endpoints.kepler.ai.cloud.ovh.net/v1\", model: \"Meta-Llama-3_3-70B-Instruct\", keyEnv: \"OVH_AI_ENDPOINTS_ACCESS_TOKEN\", priority: 15 },\n // Paid tier — inert unless the matching key is set; ported from v2/catalog-paid.ts (ids verified 2026-09-08\n // there). priority 40+ so \"auto\"/\"fast\" try every free row first — paid only activates through explicit\n // vendor/tag routing (e.g. model:\"coder\", model:\"anthropic\") or once every free provider has failed.\n { id: \"17\", name: \"deepseek/chat\", base: \"https://api.deepseek.com/v1\", model: \"deepseek-chat\", keyEnv: \"DEEPSEEK_API_KEY\", priority: 40, paid: true, tags: [\"coder\", \"reasoning\"] },\n { id: \"18\", name: \"deepseek/reasoner\", base: \"https://api.deepseek.com/v1\", model: \"deepseek-reasoner\", keyEnv: \"DEEPSEEK_API_KEY\", priority: 41, paid: true, tags: [\"reasoning\"] },\n { id: \"19\", name: \"moonshot/kimi-k2\", base: \"https://api.moonshot.ai/v1\", model: \"kimi-k2-turbo-preview\", keyEnv: \"MOONSHOT_API_KEY\", priority: 42, paid: true, tags: [\"coder\", \"long\"] },\n { id: \"20\", name: \"openai/gpt-5-mini\", base: \"https://api.openai.com/v1\", model: \"gpt-5-mini\", keyEnv: \"OPENAI_API_KEY\", priority: 43, paid: true, tags: [\"coder\", \"reasoning\"] },\n { id: \"21\", name: \"anthropic/claude-sonnet\", base: \"https://api.anthropic.com/v1\", model: \"claude-sonnet-4-5\", keyEnv: \"ANTHROPIC_API_KEY\", priority: 44, paid: true, tags: [\"coder\", \"reasoning\"] },\n];\n\nconst vendorOf = (name: string) => name.split(\"/\")[0];\n\nconst instance = (p: ProviderSpec, slot: number, keyEnv: string | null, key: string | null): ProviderInstance =>\n ({ ...p, keyEnv, key, keyIssue: key ? keyIssue(key) : null, slot, vendor: vendorOf(p.name), name: slot ? `${p.name}#${slot}` : p.name, fallbackModel: p.model });\n\nexport function getProviderArray(): ProviderInstance[] {\n const out: ProviderInstance[] = [];\n for (const p of CATALOG) {\n if (!p.keyEnv) { out.push(instance(p, 0, null, null)); continue; }\n for (let i = 0; i < KEY_SLOTS; i++) {\n const env = p.keyEnv + (i ? String(i) : \"\");\n const key = Deno.env.get(env)?.trim(); // surrounding whitespace is the one defect repaired silently — see keyIssue()\n if (key) out.push(instance(p, i, env, key));\n }\n }\n return out.sort((a, b) => a.priority - b.priority || a.slot - b.slot);\n}\n\n/** All catalog rows for status/UI; no key material. */\nexport function getCatalogStatus() {\n const live = getProviderArray();\n return CATALOG.map((p) => {\n const slots = live.filter((i) => i.id === p.id);\n return {\n ...p,\n vendor: vendorOf(p.name),\n fallbackModel: p.model,\n hasKey: !p.keyEnv || slots.length > 0,\n keySlots: slots.length,\n keyIssues: slots.filter((i) => i.keyIssue).map((i) => ({ env: i.keyEnv, issue: i.keyIssue })),\n };\n }).sort((a, b) => a.priority - b.priority);\n}\n\n/** request `model`: \"\"|\"auto\"|\"fast\" → chain (this router has no quality-vs-priority reordering, so\n * \"fast\" — the UI's other bare meta-model, alongside \"coder\"/\"reasoning\" — is not distinct from \"auto\"\n * here; both just mean \"every configured provider, in existing priority order\"); \"coder\"|\"reasoning\"|\n * \"long\" → tagged instances first, then the rest (never a hard subset — a meta-model must still degrade\n * to *something*); \"\" | \"\" → subset; \":\" → subset + forced id;\n * unknown → [] (caller 404s). */\nexport function resolveTargets(requested: string | undefined, live: ProviderInstance[]) {\n if (!requested || requested === \"auto\" || requested === \"fast\") return { targets: live, forcedModel: null };\n if (/^(coder|reasoning|long|vision)$/.test(requested)) {\n const tagged = live.filter((p) => p.tags?.includes(requested));\n return { targets: [...tagged, ...live.filter((p) => !tagged.includes(p))], forcedModel: null };\n }\n const exact = live.filter((p) => p.name === requested || p.name.split(\"#\")[0] === requested);\n if (exact.length) return { targets: exact, forcedModel: null };\n const colon = requested.indexOf(\":\");\n const vendor = colon === -1 ? requested : requested.slice(0, colon);\n const forced = colon === -1 ? null : requested.slice(colon + 1) || null; // \"\" (trailing colon) must fall through, not ship as model\n const byVendor = live.filter((p) => p.vendor === vendor);\n return { targets: byVendor, forcedModel: byVendor.length ? forced : null };\n}\n",[],[531],"40685802-fdec-4000-9169-037c8f481110","e2e9.mjs","05b43346-ad8b-11f1-a3e8-1607ee4eb77e",1479,["D",1789154842693],"import { chromium } from \"playwright-core\";\nimport fs from \"node:fs\";\nconst html = fs.readFileSync(\"app/page.html\", \"utf8\");\nconst files = { \"index.html\": \"

x

\", \"app.js\": \"console.log(1);\\n\".repeat(40) };\nconst b = await chromium.launch({ executablePath: \"/opt/pw-browsers/chromium\", args: [\"--no-sandbox\", \"--headless=new\"], ignoreDefaultArgs: [\"--headless=old\"] });\nconst p = await b.newPage({ viewport: { width: 1400, height: 800 } }); const errs = []; p.on(\"pageerror\", e => errs.push(e.message));\nlet qCount = 0, progressCalls = 0;\nawait p.route(\"**/*\", async (route) => { const u = new URL(route.request().url());\n if (u.host === \"cdnjs.cloudflare.com\") { const m = u.pathname.match(/codemirror\\/5\\.65\\.16\\/(.*)$/); const f = m ? \"/tmp/cm/\" + m[1] : null; if (f && fs.existsSync(f)) return route.fulfill({ contentType: f.endsWith(\".css\") ? \"text/css\" : \"text/javascript\", body: fs.readFileSync(f) }); return route.abort(); }\n if (u.host !== \"app.local\") return route.abort();\n if (u.search.includes(\"?artifact_files=\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ id: 1, title: \"T\", kind: \"html\", session: \"s\", files: Object.entries(files).map(([path, content]) => ({ path, content })), issues: [] }) });\n if (u.search.startsWith(\"?q\")) { qCount++; const body = JSON.parse(route.request().postData()); await new Promise(r => setTimeout(r, 2500));\n if (qCount === 1) return route.fulfill({ status: 503, contentType: \"application/json\", body: JSON.stringify({ error: { message: \"router 503: ALL_PROVIDERS_EXHAUSTED_OR_COOLING\", details: [\"groq: cooling 20s — rate\", \"openrouter: TIMEOUT\"] } }) });\n return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ reply: \"done after retry (retryOf=\" + body.settings.retryOf + \")\", toolEvents: [{ hop: 0, tool: \"eval_js\", args: { code: \"1\" }, result: 1 }], meta: {} }) }); }\n if (u.search.includes(\"?progress\")) { progressCalls++; return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ events: [{ type: \"stage\", label: \"answering\" }, { type: \"pass\", n: 1, of: 8 }, { type: \"tool\", hop: 0, tool: \"read_artifact\", args: { id: 1 } }, { type: \"tool\", hop: 0, tool: \"eval_js\", args: { code: \"1\" } }].slice(0, Math.min(4, progressCalls)), next: 4 }) }); }\n if (u.pathname.startsWith(\"/artifact/\")) return route.fulfill({ contentType: \"text/html\", body: files[\"index.html\"] });\n if (u.search) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n return route.fulfill({ contentType: \"text/html\", body: html }); });\nawait p.goto(\"https://app.local/\", { waitUntil: \"load\" }); await p.waitForTimeout(300);\n// A) editor resizes with the window\nawait p.evaluate(() => ART.open(1, 'split')); await p.waitForTimeout(900);\nconst h1 = await p.evaluate(() => document.querySelector('.CodeMirror').getBoundingClientRect().height);\nawait p.setViewportSize({ width: 1000, height: 500 }); await p.waitForTimeout(400);\nconst h2 = await p.evaluate(() => ({ cm: document.querySelector('.CodeMirror').getBoundingClientRect().height | 0, wrap: document.getElementById('ap-edwrap').getBoundingClientRect().height | 0, scroll: document.querySelector('.CodeMirror-scroll').clientHeight | 0 }));\nawait p.setViewportSize({ width: 1400, height: 800 }); await p.keyboard.press(\"Escape\"); await p.waitForTimeout(300);\n// B) live timeline: statuses, expanded row survives polling, retry loop\nawait p.evaluate(() => { SETTINGS.set('retryMinutes', 1); });\nawait p.fill(\"#inp\", \"hello\"); await p.keyboard.press(\"Enter\");\nawait p.waitForFunction(() => !!document.querySelector('#live-tl .tl .tl-row[data-kind=tool]'), null, { timeout: 15000 }); // a tool row has arrived (2 s polling cadence)\nconst r1 = await p.evaluate(() => { const tl = document.querySelector('#live-tl .tl'); const rows = [...tl.querySelectorAll('.tl-row')]; rows.find(r => r.dataset.kind === 'tool')?.click(); return { plan: [...tl.querySelectorAll('.tl-pl')].map(x => x.className.replace('tl-pl ', '') + ':' + x.textContent), rows: rows.map(r => r.querySelector('.tl-k').textContent + '=' + r.querySelector('.tl-st').textContent), header: tl.querySelector('.tl-sum').textContent, label: document.getElementById('typing-label').textContent }; });\nawait p.waitForTimeout(2600); // more polls → the expanded row must still be open\nconst r2 = await p.evaluate(() => { const tl = document.querySelector('#live-tl .tl'); return { stillOpen: !!tl.querySelector('.tl-row.open'), xVisible: tl.querySelector('.tl-row.open + .tl-x') ? getComputedStyle(tl.querySelector('.tl-row.open + .tl-x')).display : 'MISSING', html: tl.innerHTML.slice(0, 300), rows: tl.querySelectorAll('.tl-row').length, label: document.getElementById('typing-label').textContent }; });\nawait p.waitForTimeout(12000); // retry wait (8s + jitter) then second attempt\nconst r3 = await p.evaluate(() => ({ q: document.querySelectorAll('.msg-wrap.ai').length, reply: [...document.querySelectorAll('.msg-wrap.ai .msg-body')].pop()?.textContent, err: document.querySelectorAll('.err-card').length }));\nconsole.log(JSON.stringify({ h1, h2, r1, r2, r3, qCount }, null, 1)); console.log(\"errors:\", errs.filter(e => !/cdnjs/.test(e)));\nawait b.close();\n",[],[540],"c2b7c429-6d10-4a1d-aeec-5d1d722a80c9","e2e15.mjs","a8c67bd6-ae1a-11f1-af4d-1607ee4eb77e",1498,["D",1789156494898],"import { chromium } from \"playwright-core\";\nimport fs from \"node:fs\";\nconst html = fs.readFileSync(\"app/page.html\", \"utf8\");\nconst HOOK = \"\";\nconst files = { \"index.html\": \"

x

\" };\nconst manifest = { title: \"T\", shared: \"\", files: [{ path: \"index.html\", purpose: \"e\" }, { path: \"a.js\", purpose: \"a\" }] };\nconst b = await chromium.launch({ executablePath: \"/opt/pw-browsers/chromium\", args: [\"--no-sandbox\", \"--headless=new\"], ignoreDefaultArgs: [\"--headless=old\"] });\nconst p = await b.newPage({ viewport: { width: 1400, height: 800 } }); const errs = []; p.on(\"pageerror\", e => errs.push(e.message));\nconst posts = []; let buildTries = 0;\nawait p.route(\"**/*\", async (route) => { const u = new URL(route.request().url());\n if (u.host === \"cdnjs.cloudflare.com\") return route.abort();\n if (u.host !== \"app.local\") return route.abort();\n if (u.search.includes(\"?artifact_files=\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ id: 61, title: \"T\", kind: \"html\", session: \"s\", files: Object.entries(files).map(([path, content]) => ({ path, content })), issues: [] }) });\n if (u.search.startsWith(\"?q\")) { const body = JSON.parse(route.request().postData()); posts.push({ q: body.q.slice(0, 50), errors: body.settings.focus?.errors }); await new Promise(r => setTimeout(r, 200)); return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ reply: \"fixed\", toolEvents: [], meta: {}, completion: { done: true, remaining: [] } }) }); }\n if (u.search.startsWith(\"?build_file\")) { buildTries++; const body = JSON.parse(route.request().postData()); if (buildTries <= 2) return route.fulfill({ status: 502, contentType: \"application/json\", body: JSON.stringify({ error: { message: \"build a.js failed: router 503: ALL_PROVIDERS_EXHAUSTED_OR_COOLING\" } }) }); return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ ok: true, path: body.path, lines: 10, issues: [], meta: {} }) }); }\n if (u.search.startsWith(\"?job\")) return route.fulfill({ contentType: \"application/json\", body: '{\"ok\":true,\"jobs\":[]}' });\n if (u.search.startsWith(\"?plan\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ manifest, artifactId: 61, title: \"T\" }) });\n if (u.search.includes(\"?progress\")) return route.fulfill({ contentType: \"application/json\", body: '{\"events\":[],\"next\":0}' });\n if (u.pathname === \"/artifact/61/\" ) return route.fulfill({ contentType: \"text/html\", body: files[\"index.html\"].replace(\"\", \"\" + HOOK) });\n if (u.pathname.startsWith(\"/artifact/\")) return route.fulfill({ status: 404, body: \"\" });\n if (u.search && !u.search.startsWith(\"?s=\")) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n return route.fulfill({ contentType: \"text/html\", body: html }); });\nawait p.goto(\"https://app.local/\", { waitUntil: \"load\" }); await p.waitForTimeout(400);\nawait p.evaluate(() => { ART.setSettings({ ...ART.settings(), codemirror: false, autoFixLint: false, autoFixErrors: true, live: false }); SETTINGS.set('retryMinutes', 1); });\n// A) preview errors → one automatic fix turn carrying the errors; same error set again → no second turn\nawait p.evaluate(() => ART.open(61, 'split')); await p.waitForTimeout(3500);\nconst a = { posts: posts.map(x => x.q), errorsSent: posts[0]?.errors, console: await p.evaluate(() => [...document.querySelectorAll('#ap-con-body .con-err')].map(x => x.textContent)) };\nawait p.evaluate(() => ART.open(61)); await p.waitForTimeout(3000);\nconst a2 = { postsAfterReload: posts.length };\n// B) builder retried through a 502 window\nawait p.evaluate(() => ART.close());\nawait p.fill(\"#inp\", \"/build a thing\"); await p.keyboard.press(\"Enter\"); await p.waitForTimeout(16000);\nconst bres = { buildTries, rows: await p.evaluate(() => [...document.querySelectorAll('.manifest-f')].map(r => r.querySelector('code').textContent + '=' + r.querySelector('.st').textContent)) };\nconsole.log(JSON.stringify({ a, a2, bres }, null, 1)); console.log(\"errors:\", errs);\nawait b.close();\n",[],[548],"7f748b60-3e4c-4785-b13e-42adf7bead90","e2e14.mjs","cfb60a80-ae16-11f1-a6aa-1607ee4eb77e",1478,["D",1789154842238],"import { chromium } from \"playwright-core\";\nimport fs from \"node:fs\";\nconst html = fs.readFileSync(\"app/page.html\", \"utf8\");\nconst b = await chromium.launch({ executablePath: \"/opt/pw-browsers/chromium\", args: [\"--no-sandbox\", \"--headless=new\"], ignoreDefaultArgs: [\"--headless=old\"] });\nconst p = await b.newPage({ viewport: { width: 1400, height: 800 } }); const errs = []; p.on(\"pageerror\", e => errs.push(e.message));\nlet q = 0;\nawait p.route(\"**/*\", async (route) => { const u = new URL(route.request().url());\n if (u.host !== \"app.local\") return route.abort();\n if (u.search.startsWith(\"?q\")) { q++; await new Promise(r => setTimeout(r, 5000)); return route.fulfill({ status: 500, contentType: \"application/json\", body: JSON.stringify({ error: { message: \"Val timed out after 1m\" } }) }); }\n if (u.search.includes(\"?progress\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ next: 3, events: [{ type: \"stage\", label: \"answering\" }, { type: \"partial\", text: \"const store = createStore(reducer, init);\\nexport function mount() {\" }, { type: \"continue\", n: 1, chars: 1840, tail: \"export function mount() {\" }] }) });\n if (u.search.startsWith(\"?history\")) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n if (u.search && !u.search.startsWith(\"?s=\")) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n return route.fulfill({ contentType: \"text/html\", body: html }); });\nawait p.goto(\"https://app.local/\", { waitUntil: \"load\" }); await p.waitForTimeout(400);\nawait p.evaluate(() => { SETTINGS.set('retryMinutes', 0); });\nawait p.fill(\"#inp\", \"fix the lint\"); await p.keyboard.press(\"Enter\");\nawait p.waitForTimeout(3000);\nconst live = await p.evaluate(() => ({ draftShown: !document.getElementById('live-draft').hidden, draft: document.getElementById('live-draft-t').textContent.slice(0, 40), contRow: [...document.querySelectorAll('#live-tl .tl-row')].map(r => r.textContent).find(t => /cut at the vendor cap/.test(t))?.slice(0, 90) }));\nawait p.waitForTimeout(30000); // error + recovery polls (8 × 3 s)\nconst after = await p.evaluate(() => { const c = document.querySelector('.err-card'); return { err: c?.querySelector('.err-m')?.textContent, keptTimelineRows: c?.querySelectorAll('.tl-row').length ?? 0, keptDraft: /draft reply recovered/.test(c?.textContent || ''), draftText: c?.querySelector('details pre')?.textContent.slice(0, 30) }; });\nconsole.log(JSON.stringify({ live, after, q }, null, 1)); console.log(\"errors:\", errs);\nawait b.close();\n",[],[556],"5c9d1215-2136-4673-8adf-575bc51b1b9a","e2e13.mjs","cf59ed68-ae16-11f1-a59a-1607ee4eb77e",1477,["D",1789154841633],"import { chromium } from \"playwright-core\";\nimport fs from \"node:fs\";\nconst html = fs.readFileSync(\"app/page.html\", \"utf8\");\nconst b = await chromium.launch({ executablePath: \"/opt/pw-browsers/chromium\", args: [\"--no-sandbox\", \"--headless=new\"], ignoreDefaultArgs: [\"--headless=old\"] });\nconst p = await b.newPage({ viewport: { width: 1400, height: 800 } }); const errs = []; p.on(\"pageerror\", e => errs.push(e.message));\nconst posts = []; let phase = \"write\";\nawait p.route(\"**/*\", async (route) => { const u = new URL(route.request().url());\n if (u.host !== \"app.local\") return route.abort();\n if (u.search.startsWith(\"?q\")) { const body = JSON.parse(route.request().postData()); posts.push(body.q.slice(0, 40)); await new Promise(r => setTimeout(r, 150));\n const wrote = phase === \"write\" || !/^The task is complete/.test(body.q);\n return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ reply: /FINALIZE/.test(body.q) ? \"final summary\" : \"shipped round\", toolEvents: wrote ? [{ hop: 0, tool: \"update_artifact\", args: { id: 7 }, result: { ok: true, id: 7 } }] : [], meta: {}, completion: { done: true, remaining: [] } }) }); }\n if (u.search.includes(\"?progress\")) return route.fulfill({ contentType: \"application/json\", body: '{\"events\":[],\"next\":0}' });\n if (u.search.startsWith(\"?compact\")) return route.fulfill({ contentType: \"application/json\", body: '{\"compact\":null,\"needs\":false}' });\n if (u.search && !u.search.startsWith(\"?s=\")) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n return route.fulfill({ contentType: \"text/html\", body: html }); });\nawait p.goto(\"https://app.local/\", { waitUntil: \"load\" }); await p.waitForTimeout(400);\nawait p.evaluate(() => { SETTINGS.set('untilStopped', true); });\n// A) rounds keep coming while every round writes; \"finalize\" typed in the composer ends the chain with one closing turn\nawait p.fill(\"#inp\", \"build me a thing\"); await p.keyboard.press(\"Enter\"); await p.waitForTimeout(6000);\nconst midA = { posts: posts.length, bar: await p.evaluate(() => document.getElementById('bar-status').textContent) };\nawait p.fill(\"#inp\", \"finalize\"); await p.keyboard.press(\"Enter\"); await p.waitForTimeout(3000);\nconst afterA = { posts: [...posts], inflight: await p.evaluate(() => window.inflightTurn()), last: await p.evaluate(() => [...document.querySelectorAll('.msg-wrap.ai .msg-body')].pop()?.textContent) };\n// B) idle stop: rounds that write nothing end after two\nposts.length = 0; phase = \"idle\";\nawait p.fill(\"#inp\", \"another thing\"); await p.keyboard.press(\"Enter\"); await p.waitForTimeout(6000);\nconst afterB = { posts: [...posts], inflight: await p.evaluate(() => window.inflightTurn()), autoCard: await p.evaluate(() => [...document.querySelectorAll('.msg-wrap.sys .msg-body')].some(x => /no further upgrades/.test(x.textContent))) };\nconsole.log(JSON.stringify({ midA, afterA, afterB }, null, 1)); console.log(\"errors:\", errs);\nawait b.close();\n",[],[564],"7f593e81-d60f-407b-abe1-3280cc43debf","e2e12.mjs","ceec123e-ae16-11f1-b8bc-1607ee4eb77e",1476,["D",1789154840909],"import { chromium } from \"playwright-core\";\nimport fs from \"node:fs\";\nconst html = fs.readFileSync(\"app/page.html\", \"utf8\");\nconst b = await chromium.launch({ executablePath: \"/opt/pw-browsers/chromium\", args: [\"--no-sandbox\", \"--headless=new\"], ignoreDefaultArgs: [\"--headless=old\"] });\nconst p = await b.newPage({ viewport: { width: 1400, height: 800 } }); const errs = []; p.on(\"pageerror\", e => errs.push(e.message));\nlet q = 0, compactPosts = 0, compactGets = 0;\nawait p.route(\"**/*\", async (route) => { const u = new URL(route.request().url()); const m = route.request().method();\n if (u.host !== \"app.local\") return route.abort();\n if (u.search.startsWith(\"?compact\") && m === \"POST\") { compactPosts++; return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ ok: true, before: 41000, after: 2900, covered: 22, uptoId: 88 }) }); }\n if (u.search.startsWith(\"?compact\")) { compactGets++; return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ compact: compactPosts ? { summary: \"GOAL — test\", covered: 22, uptoId: 88, chars: 2900, ts: 1 } : null }) }); }\n if (u.search.startsWith(\"?q\")) { q++; const body = JSON.parse(route.request().postData()); await new Promise(r => setTimeout(r, 200));\n if (q <= 3 && !body.settings.continuation) return route.fulfill({ status: 503, contentType: \"application/json\", body: JSON.stringify({ error: { message: \"router 503: ALL_PROVIDERS_EXHAUSTED_OR_COOLING\", details: [\"x\"] } }) });\n // then: truncated replies forever (until stopped), the 4th with needsCompact\n return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ reply: \"part \" + q + \" of a very long answer that keeps going\", truncated: true, toolEvents: [], meta: {}, needsCompact: q === 4 }) }); }\n if (u.search.includes(\"?progress\")) return route.fulfill({ contentType: \"application/json\", body: '{\"events\":[],\"next\":0}' });\n if (u.search && !u.search.startsWith(\"?s=\")) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n return route.fulfill({ contentType: \"text/html\", body: html }); });\nawait p.goto(\"https://app.local/\", { waitUntil: \"load\" }); await p.waitForTimeout(400);\n// retryMinutes 0 would normally mean \"no retry\"; autoContinue 1 would normally stop after one continue. untilStopped overrides both.\nawait p.evaluate(() => { SETTINGS.set('retryMinutes', 0); SETTINGS.set('autoContinue', 1); SETTINGS.set('untilStopped', true); });\nawait p.fill(\"#inp\", \"write the whole thing\"); await p.keyboard.press(\"Enter\");\nawait p.waitForTimeout(34000); // 3 × 503 with jittered 8/16/24 s waits ≈ 48 s worst case… we sample mid-way\nconst mid = await p.evaluate(() => ({ typing: document.getElementById('typing-label').textContent, bar: document.getElementById('bar-status')?.textContent }));\nawait p.waitForTimeout(26000);\nconst before = await p.evaluate(() => ({ ai: document.querySelectorAll('.msg-wrap.ai').length, compactCards: [...document.querySelectorAll('.msg-wrap.sys .role-tag')].filter(x => x.textContent === 'COMPACT').length, inflight: window.inflightTurn() }));\nawait p.evaluate(() => stopGen()); await p.waitForTimeout(1500);\nconst after = await p.evaluate(() => ({ inflight: window.inflightTurn(), last: [...document.querySelectorAll('.msg-wrap.ai .msg-body')].pop()?.textContent.slice(-40) }));\nconsole.log(JSON.stringify({ mid, q, compactPosts, compactGets, before, after }, null, 1)); console.log(\"errors:\", errs);\nawait b.close();\n",[],[572],"c98a97b9-4cfd-4562-806c-462d1abcde70","e2e11.mjs","03081450-ad8b-11f1-bc95-1607ee4eb77e",1459,["D",1789094798792],"import { chromium } from \"playwright-core\";\nimport fs from \"node:fs\";\nconst html = fs.readFileSync(\"app/page.html\", \"utf8\");\nconst manifest = { title: \"Demo\", shared: \"x\", files: [{ path: \"index.html\", purpose: \"entry\" }, { path: \"a.js\", purpose: \"a\" }, { path: \"b.js\", purpose: \"b\" }, { path: \"c.js\", purpose: \"c\" }] };\nconst b = await chromium.launch({ executablePath: \"/opt/pw-browsers/chromium\", args: [\"--no-sandbox\", \"--headless=new\"], ignoreDefaultArgs: [\"--headless=old\"] });\nconst p = await b.newPage({ viewport: { width: 1400, height: 800 } }); const errs = []; p.on(\"pageerror\", e => errs.push(e.message));\nconst built = [], jobPosts = [], planCalls = []; let qBodies = [];\nawait p.route(\"**/*\", async (route) => { const u = new URL(route.request().url());\n if (u.host === \"cdnjs.cloudflare.com\") { const m = u.pathname.match(/codemirror\\/5\\.65\\.16\\/(.*)$/); const f = m ? \"/tmp/cm/\" + m[1] : null; if (f && fs.existsSync(f)) return route.fulfill({ contentType: f.endsWith(\".css\") ? \"text/css\" : \"text/javascript\", body: fs.readFileSync(f, \"utf8\") }); return route.abort(); }\n if (u.host !== \"app.local\") return route.abort();\n if (u.search.startsWith(\"?sessions\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify([{ id: \"S1\", name: \"demo\", ts: 1 }]) });\n if (u.search.startsWith(\"?history\")) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n if (u.search.startsWith(\"?job=list\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ jobs: [{ artifactId: 7, manifest, done: [\"index.html\", \"a.js\"], failed: [\"b.js\"], status: \"building\", title: \"Demo\", ask: \"make demo\" }] }) });\n if (u.search.startsWith(\"?job\")) { jobPosts.push(JSON.parse(route.request().postData())); return route.fulfill({ contentType: \"application/json\", body: \"{\\\"ok\\\":true}\" }); }\n if (u.search.startsWith(\"?plan\")) { planCalls.push(JSON.parse(route.request().postData()).q); return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ manifest, artifactId: 9, title: \"Demo\" }) }); }\n if (u.search.startsWith(\"?build_file\")) { const body = JSON.parse(route.request().postData()); built.push(body.path); await new Promise(r => setTimeout(r, 300)); return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ ok: true, path: body.path, lines: 10, issues: [], meta: { instance: \"openrouter#2\" } }) }); }\n if (u.search.includes(\"?artifact_files=\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ id: 7, title: \"Demo\", kind: \"html\", session: \"S1\", files: [{ path: \"index.html\", content: \"

x

\" }], issues: [] }) });\n if (u.search.startsWith(\"?q\")) { qBodies.push(JSON.parse(route.request().postData())); return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ reply: \"integrated\", toolEvents: [], meta: {}, completion: { done: true, remaining: [] } }) }); }\n if (u.search.startsWith(\"?slow\")) { await new Promise(r => setTimeout(r, 20000)); return route.fulfill({ body: \"late\" }); }\n if (u.pathname.startsWith(\"/artifact/\")) return route.fulfill({ contentType: \"text/html\", body: \"

x

\" });\n if (u.search && !u.search.startsWith(\"?s=\")) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n return route.fulfill({ contentType: \"text/html\", body: html }); });\nawait p.goto(\"https://app.local/?s=S1\", { waitUntil: \"load\" }); await p.waitForTimeout(800);\n// A) worker-backed wait + fetchT timeout\nconst a = await p.evaluate(async () => { const t0 = performance.now(); await omniNet.wait(300); const dt = performance.now() - t0; let err = null; try { await omniNet.fetchT('?slow', {}, 1200); } catch (e) { err = e.message; } let stopped = null; const c = new AbortController(); setTimeout(() => c.abort(), 200); try { await omniNet.fetchT('?slow', { signal: c.signal }, 5000); } catch (e) { stopped = e.name; } return { dt: Math.round(dt), err, stopped }; });\n// B) resume card rendered from the server job row\nconst cardTxt = await p.evaluate(() => { const c = document.querySelector('.manifest'); return c ? { head: c.querySelector('.manifest-h span').textContent, btn: c.querySelector('[data-a=go]').textContent, st: [...c.querySelectorAll('.manifest-f')].map(r => r.querySelector('code').textContent + '=' + r.querySelector('.st').textContent) } : null; });\nawait p.click('.manifest [data-a=go]'); await p.waitForTimeout(2500);\nconst after = await p.evaluate(() => ({ st: [...document.querySelectorAll('.manifest-f')].map(r => r.querySelector('code').textContent + '=' + r.querySelector('.st').textContent), reply: [...document.querySelectorAll('.msg-wrap.ai .msg-body')].pop()?.textContent, title: document.title }));\n// C) app-scale ask auto-routes to the swarm\nawait p.evaluate(() => ART.close()); await p.waitForTimeout(300);\nawait p.fill(\"#inp\", \"build a step sequencer app with effects\"); await p.keyboard.press(\"Enter\"); await p.waitForTimeout(2500);\nawait p.evaluate(() => ART.close()); await p.waitForTimeout(300); await p.fill(\"#inp\", \"what time is it\"); await p.keyboard.press(\"Enter\"); await p.waitForTimeout(800);\nconst c = { planCalls, qAfter: qBodies.length, builtTotal: built.length };\nconsole.log(JSON.stringify({ c, a, cardTxt, built, after, jobStatuses: jobPosts.map(j => j.state.status + ':' + j.state.done.length), integrateQ: qBodies.length, integrateFocus: qBodies[0]?.settings?.focus?.id }, null, 1));\nconsole.log(\"errors:\", errs);\nawait b.close();\n",[],[580],"eb553536-e6b3-498a-8ea3-1da08f738838","e2e10.mjs","008bd9f0-ad8b-11f1-ac72-1607ee4eb77e",1475,["D",1789154839726],"// lint strip: fix button sends a focused fix; auto-fix fires once; completion audit → automatic follow-up turn\nimport { chromium } from \"playwright-core\";\nimport fs from \"node:fs\";\nconst html = fs.readFileSync(\"app/page.html\", \"utf8\");\nconst files = { \"index.html\": \"\", \"app.js\": \"function init() {}\\n\" };\nconst b = await chromium.launch({ executablePath: \"/opt/pw-browsers/chromium\", args: [\"--no-sandbox\", \"--headless=new\"], ignoreDefaultArgs: [\"--headless=old\"] });\nconst p = await b.newPage({ viewport: { width: 1400, height: 800 } }); const errs = []; p.on(\"pageerror\", e => errs.push(e.message));\nconst posts = [];\nawait p.route(\"**/*\", async (route) => { const u = new URL(route.request().url());\n if (u.host !== \"app.local\") return route.abort();\n if (u.search.includes(\"?artifact_files=\")) return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ id: 7, title: \"T\", kind: \"html\", session: \"s\", files: Object.entries(files).map(([path, content]) => ({ path, content })), issues: [\"app.js:1: empty function body — \\\"function init() {}\\\" — replace with the real implementation\"] }) });\n if (u.search.startsWith(\"?q\")) { const body = JSON.parse(route.request().postData()); posts.push({ q: body.q.slice(0, 60), focus: body.settings.focus?.id, followup: body.settings.followup }); await new Promise(r => setTimeout(r, 300));\n const first = posts.length === 1 && !/Continue the task/.test(body.q);\n // the SUCCESSOR turn (auto follow-up) hits a 503 once: its retry loop must use its own AbortController (regression: \"Cannot read properties of null (reading 'signal')\")\n if (posts.length === 2 && !body.settings.retryOf) return route.fulfill({ status: 503, contentType: \"application/json\", body: JSON.stringify({ error: { message: \"router 503: ALL_PROVIDERS_EXHAUSTED_OR_COOLING\", details: [\"x\"] } }) });\n return route.fulfill({ contentType: \"application/json\", body: JSON.stringify({ reply: \"did part \" + posts.length, toolEvents: [{ hop: 0, tool: \"update_artifact\", args: { id: 7 }, result: { ok: true, id: 7, url: \"/artifact/7/\", title: \"T\" } }], meta: {}, completion: posts.length < 3 ? { done: false, remaining: [\"wire the keyboard handler in input.js\", \"add the score display\"] } : { done: true, remaining: [] } }) }); }\n if (u.search.includes(\"?progress\")) return route.fulfill({ contentType: \"application/json\", body: '{\"events\":[],\"next\":0}' });\n if (u.pathname.startsWith(\"/artifact/\")) return route.fulfill({ contentType: \"text/html\", body: files[\"index.html\"] });\n if (u.search) return route.fulfill({ contentType: \"application/json\", body: \"[]\" });\n return route.fulfill({ contentType: \"text/html\", body: html }); });\nawait p.goto(\"https://app.local/\", { waitUntil: \"load\" }); await p.waitForTimeout(300);\nawait p.evaluate(() => { ART.setSettings({ ...ART.settings(), codemirror: false, autoFixLint: true }); ART.open(7, 'split'); }); await p.waitForTimeout(1200);\nconst r1 = await p.evaluate(() => ({ lintShown: !document.getElementById('ap-lint').hidden, n: document.getElementById('ap-lint-n').textContent, btn: !!document.querySelector('#ap-lint-h button') }));\nawait p.waitForTimeout(16000); // auto-fix turn + completion follow-ups\nconst r2 = await p.evaluate(() => ({ auto: [...document.querySelectorAll('.msg-wrap.sys .msg-body')].map(x => x.textContent.split('\\n')[0]), ai: document.querySelectorAll('.msg-wrap.ai').length }));\nconsole.log(JSON.stringify({ r1, posts, r2 }, null, 1)); console.log(\"errors:\", errs);\nawait b.close();\n",[],[588],"041bddd2-8b78-431e-927e-2436b6369e76","db.ts","0b4ab11c-43c9-11f1-8043-42b51c65c3df",1647,["D",1789514602711],73,"import { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\n\n/* ────────────────────────────────────────────────────────────────\n Result monad — DB failures are values, never uncaught exceptions.\n Error channel is a closed literal union, not bare `string`, so\n every `r.error === \"...\"` comparison downstream is checked at\n compile time instead of merely hoped for.\n ──────────────────────────────────────────────────────────────── */\ntype Result = { ok: true; value: T } | { ok: false; error: E };\ntype DbError = \"QUOTA_EXCEEDED\" | \"UNKNOWN\";\n\nfunction Ok(value: T): Result {\n return { ok: true, value };\n}\n\nfunction Err(error: E): Result {\n return { ok: false, error };\n}\n\nasync function attempt(fn: () => Promise): Promise> {\n try {\n return Ok(await fn());\n } catch (e) {\n return Err(\n /full|quota/i.test(String(e)) ? \"QUOTA_EXCEEDED\" : \"UNKNOWN\",\n );\n }\n}\n\n/* ────────────────────────────────────────────────────────────────\n Schema — single source of truth. Row shapes come from an actual\n TS interface, not from pattern-matching SQL text.\n ──────────────────────────────────────────────────────────────── */\ninterface Schema {\n provider: {\n id: string; // natural key — matches message.providerId's type; no cast needed at the join\n name: string;\n base: string;\n keyEnv: string | null;\n model: string | null;\n priority: number;\n };\n message: {\n id: number;\n role: \"user\" | \"assistant\" | \"system\";\n content: string;\n ts: number;\n session: string;\n providerId: string | null;\n };\n message_meta: { message_id: number; meta: string };\n memory: { key: string; value: string; weight: number; ts: number };\n memory_fact: {\n id: number;\n fact: string;\n salience: number; // 1 - predictability; decays on non-access\n created: number;\n accessed: number;\n hits: number;\n };\n session: { id: string; name: string; ts: number };\n omni_router_config: { provider: string; selected_model: string };\n omni_state: { key: string; value: string; ts: number }; // router cooldowns / dead models / resolved ids\n step: { // deferred unit of work drained across invocations — see scheduler.ts\n id: number; job: string; seq: number; kind: string; payload: string; status: string;\n attempts: number; run_after: number; lease_until: number; needs: number | null; priority: number;\n result: string | null; error: string | null; created: number; updated: number;\n };\n progress: { session: string; events: string; ts: number }; // live turn progress, polled by the chat UI\n artifact_file: { artifact_id: number; path: string; content: string; ts: number }; // multi-file artifacts; index.html mirrors artifact.content\n // Durable counterpart to router-core.ts's in-memory breaker: that Map resets on every fresh isolate,\n // which is why /health's instance roster could show 0 requests moments after a real, failed attempt —\n // the isolate that served the attempt and the one that served the /health check are not guaranteed to\n // be the same one. This table survives across isolates; the in-memory breaker still governs open/closed\n // decisions (no added DB read on the hot path), this just makes the numbers you can actually SEE correct.\n provider_stats: { name: string; requests: number; ok: number; failed: number; last_error: string | null; updated_at: number };\n artifact: {\n id: number;\n session: string;\n title: string;\n kind: \"html\" | \"svg\" | \"markdown\";\n content: string;\n ts: number;\n };\n // Durable record of a swarm build's plan and overall status. Previously this lived only in an\n // omni_state key/value blob (job::) that was DELETED the moment a build finished\n // — so once a build was done there was no durable answer to \"what was built, from what plan, when\",\n // and while a build was running the state was an opaque JSON string, not something a query could join\n // against build_file below. One row per artifact now, kept forever (status transitions in place; never\n // deleted on \"done\") so it doubles as the artifact's permanent development record.\n build_job: {\n artifact_id: number; // PK — one build per artifact\n session: string;\n title: string;\n ask: string; // the original request that produced this manifest\n manifest: string; // JSON: {title, files:[{path,purpose,exports,imports,notes}], features, visual}\n status: \"planned\" | \"building\" | \"integrating\" | \"done\" | \"stopped\";\n created_ts: number;\n updated_ts: number;\n };\n // Per-file build status for a build_job — the piece that was previously missing entirely: build_file\n // (below, note the different name — this old singular-content table is `artifact_file`) stores a file's\n // CONTENT, but nothing durable recorded whether a given path had ever been built, what its last build's\n // issues/errors were, or how many attempts it took. buildOne() in main-script.ts upserts this row on\n // every attempt (queued → building → ok/issues/error), so /resume, the manifest UI, and any later\n // inspection all read the same source of truth instead of the manifest UI's own client-side memory.\n build_file: {\n artifact_id: number;\n path: string;\n purpose: string;\n status: \"queued\" | \"building\" | \"ok\" | \"issues\" | \"error\" | \"stopped\";\n lines: number | null;\n issues: string; // JSON array of lint-issue strings from the last build attempt\n error: string | null;\n attempts: number;\n updated_ts: number;\n };\n // Durable bug/feature backlog. Previously nothing tracked reported bugs or requested features as\n // structured data at all — they existed only as prose inside chat history, which is neither queryable\n // (\"what's still open for artifact #12\") nor reliable across a long or compacted conversation (an old\n // report can silently scroll out of the context window the model reads). The log_issue/list_issues/\n // update_issue tools in issues.ts read and write this table directly so work can be tracked and resumed\n // reliably instead of depending on the model remembering what was said several turns ago.\n issue: {\n id: number;\n session: string;\n artifact_id: number | null; // null = general/session-level, not tied to one artifact\n kind: \"bug\" | \"feature\";\n title: string;\n description: string;\n status: \"open\" | \"in_progress\" | \"fixed\" | \"wontfix\" | \"duplicate\";\n priority: \"low\" | \"medium\" | \"high\" | \"critical\";\n source: \"user\" | \"audit\" | \"model\";\n created_ts: number;\n updated_ts: number;\n resolved_ts: number | null;\n notes: string; // JSON array of {ts, text} — a short audit trail of what happened to this item\n };\n}\ntype Table = keyof Schema;\ntype Row = Schema[T];\n\nconst DDL: Record = {\n provider: `CREATE TABLE IF NOT EXISTS provider (\n id TEXT PRIMARY KEY, name TEXT NOT NULL, base TEXT NOT NULL, model TEXT NOT NULL,\n keyEnv TEXT, priority INTEGER NOT NULL)`,\n message: `CREATE TABLE IF NOT EXISTS message (\n id INTEGER PRIMARY KEY AUTOINCREMENT, role TEXT NOT NULL, content TEXT NOT NULL,\n ts INTEGER NOT NULL, session TEXT NOT NULL REFERENCES session(id),\n providerId TEXT REFERENCES provider(id))`,\n message_meta: `CREATE TABLE IF NOT EXISTS message_meta (\n message_id INTEGER PRIMARY KEY REFERENCES message(id) ON DELETE CASCADE, meta TEXT NOT NULL)`,\n memory: `CREATE TABLE IF NOT EXISTS memory (\n key TEXT PRIMARY KEY, value TEXT NOT NULL, weight REAL NOT NULL, ts INTEGER NOT NULL)`,\n memory_fact: `CREATE TABLE IF NOT EXISTS memory_fact (\n id INTEGER PRIMARY KEY AUTOINCREMENT, fact TEXT NOT NULL, salience REAL NOT NULL,\n created INTEGER NOT NULL, accessed INTEGER NOT NULL, hits INTEGER NOT NULL DEFAULT 0)`,\n session: `CREATE TABLE IF NOT EXISTS session (\n id TEXT PRIMARY KEY, name TEXT NOT NULL DEFAULT 'New Chat', ts INTEGER NOT NULL)`,\n omni_router_config: `CREATE TABLE IF NOT EXISTS omni_router_config (\n provider TEXT PRIMARY KEY, selected_model TEXT NOT NULL)`,\n omni_state: `CREATE TABLE IF NOT EXISTS omni_state (\n key TEXT PRIMARY KEY, value TEXT NOT NULL, ts INTEGER NOT NULL)`,\n // Unit of deferred work (see scheduler.ts). `needs` is a self-reference rather than a general edge\n // table: a step gates on at most one predecessor, which covers sequential chains and fan-in-to-one\n // without the cost of a join table. Fan-out is several steps sharing one `needs`.\n step: `CREATE TABLE IF NOT EXISTS step (\n id INTEGER PRIMARY KEY AUTOINCREMENT, job TEXT NOT NULL, seq INTEGER NOT NULL,\n kind TEXT NOT NULL, payload TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'ready',\n attempts INTEGER NOT NULL DEFAULT 0, run_after INTEGER NOT NULL DEFAULT 0,\n lease_until INTEGER NOT NULL DEFAULT 0, needs INTEGER REFERENCES step(id) ON DELETE SET NULL,\n priority INTEGER NOT NULL DEFAULT 0, result TEXT, error TEXT,\n created INTEGER NOT NULL, updated INTEGER NOT NULL)`,\n progress: `CREATE TABLE IF NOT EXISTS progress (\n session TEXT PRIMARY KEY, events TEXT NOT NULL, ts INTEGER NOT NULL)`,\n artifact_file: `CREATE TABLE IF NOT EXISTS artifact_file (\n artifact_id INTEGER NOT NULL REFERENCES artifact(id), path TEXT NOT NULL, content TEXT NOT NULL, ts INTEGER NOT NULL,\n PRIMARY KEY(artifact_id, path))`,\n provider_stats: `CREATE TABLE IF NOT EXISTS provider_stats (\n name TEXT PRIMARY KEY, requests INTEGER NOT NULL DEFAULT 0, ok INTEGER NOT NULL DEFAULT 0,\n failed INTEGER NOT NULL DEFAULT 0, last_error TEXT, updated_at INTEGER NOT NULL)`,\n // No UNIQUE(session, title): the real identity of an artifact is its id. A UNIQUE(session, title)\n // constraint here made `INSERT ... ON CONFLICT(session, title) DO UPDATE` silently overwrite any\n // earlier, unrelated artifact that happened to share a title within the session (models reach for\n // generic titles — \"Todo App\", \"Dashboard\" — routinely) — destructive, no versioning, no warning.\n // Identity is now always by id; (session, title) is only a non-unique lookup index (see idx_artifact_session_title).\n artifact: `CREATE TABLE IF NOT EXISTS artifact (\n id INTEGER PRIMARY KEY AUTOINCREMENT, session TEXT NOT NULL REFERENCES session(id),\n title TEXT NOT NULL, kind TEXT NOT NULL, content TEXT NOT NULL, ts INTEGER NOT NULL)`,\n // ON DELETE CASCADE on both FKs: without it, deleting an `artifact` row (there is no delete-artifact path\n // today, but nothing prevents one being added later) would either be blocked by the live FK check once one\n // of these child rows exists, or — for build_file, which references build_job not artifact directly — leave\n // orphaned build_job/build_file rows with no artifact behind them, silently corrupting future `?job` list\n // queries and the join in handleIssues/list_issues. CASCADE keeps a build's row lifecycle tied to its artifact's.\n build_job: `CREATE TABLE IF NOT EXISTS build_job (\n artifact_id INTEGER PRIMARY KEY REFERENCES artifact(id) ON DELETE CASCADE, session TEXT NOT NULL, title TEXT NOT NULL DEFAULT '',\n ask TEXT NOT NULL DEFAULT '', manifest TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'planned',\n created_ts INTEGER NOT NULL, updated_ts INTEGER NOT NULL)`,\n build_file: `CREATE TABLE IF NOT EXISTS build_file (\n artifact_id INTEGER NOT NULL REFERENCES build_job(artifact_id) ON DELETE CASCADE, path TEXT NOT NULL, purpose TEXT NOT NULL DEFAULT '',\n status TEXT NOT NULL DEFAULT 'queued', lines INTEGER, issues TEXT NOT NULL DEFAULT '[]', error TEXT,\n attempts INTEGER NOT NULL DEFAULT 0, updated_ts INTEGER NOT NULL, PRIMARY KEY(artifact_id, path))`,\n // issue.artifact_id is nullable by design (a general/session-level item has no artifact) — ON DELETE SET\n // NULL rather than CASCADE, so deleting the artifact a bug was filed against demotes the issue to\n // session-level instead of destroying the backlog entry (and its notes/audit trail) outright.\n issue: `CREATE TABLE IF NOT EXISTS issue (\n id INTEGER PRIMARY KEY AUTOINCREMENT, session TEXT NOT NULL, artifact_id INTEGER REFERENCES artifact(id) ON DELETE SET NULL,\n kind TEXT NOT NULL, title TEXT NOT NULL, description TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'open',\n priority TEXT NOT NULL DEFAULT 'medium', source TEXT NOT NULL DEFAULT 'model',\n created_ts INTEGER NOT NULL, updated_ts INTEGER NOT NULL, resolved_ts INTEGER, notes TEXT NOT NULL DEFAULT '[]')`,\n};\n\nconst INDEXES = [\n // The scheduler's hot query is \"what is runnable right now\", so it must be an index seek and not a\n // scan of every step ever enqueued — the table is append-heavy and completed rows outnumber ready ones\n // by orders of magnitude within a day.\n `CREATE INDEX IF NOT EXISTS idx_step_ready ON step(status, run_after)`,\n `CREATE INDEX IF NOT EXISTS idx_step_job ON step(job, seq)`,\n `CREATE INDEX IF NOT EXISTS idx_message_session_id ON message(session, id)`,\n `CREATE INDEX IF NOT EXISTS idx_memory_ts ON memory(ts)`,\n `CREATE INDEX IF NOT EXISTS idx_memory_fact_accessed ON memory_fact(accessed)`,\n `CREATE INDEX IF NOT EXISTS idx_artifact_session_ts ON artifact(session, ts)`,\n `CREATE INDEX IF NOT EXISTS idx_artifact_session_title ON artifact(session, title)`,\n `CREATE INDEX IF NOT EXISTS idx_build_job_session_status ON build_job(session, status)`,\n `CREATE INDEX IF NOT EXISTS idx_build_file_artifact ON build_file(artifact_id)`,\n `CREATE INDEX IF NOT EXISTS idx_issue_session_status ON issue(session, status)`,\n `CREATE INDEX IF NOT EXISTS idx_issue_artifact ON issue(artifact_id)`,\n];\n\n// One-time migration for an `artifact` table created before this fix, under the old\n// `UNIQUE(session, title)` constraint: `CREATE TABLE IF NOT EXISTS` above never touches an\n// already-existing table, so the constraint must be dropped explicitly (SQLite has no\n// ALTER TABLE ... DROP CONSTRAINT) by rebuilding the table without it. Idempotent: checks the\n// live schema text first and is a no-op once migrated (or on a fresh table that never had it).\n//\n// First cut of this migration failed live with \"FOREIGN KEY constraint failed\" on the final DROP:\n// `ALTER TABLE artifact RENAME TO ...` doesn't just rename — SQLite also silently rewrites every\n// OTHER table's stored `REFERENCES artifact(id)` clause to point at the new name, so `artifact_file`\n// ends up referencing `artifact_pre_unique_migration` mid-migration. Dropping that table while a live\n// FK still points at it is correctly refused. Fix: rebuild `artifact_file` too, in the same pass, so\n// nothing references the old name by the time it's dropped — and verify row counts before either\n// DROP, so a partial/mismatched copy aborts loudly instead of silently discarding rows.\nasync function migrateArtifactUniqueConstraint(): Promise {\n try {\n const r = await sqlite.execute({ sql: `SELECT sql FROM sqlite_master WHERE type='table' AND name='artifact'`, args: [] });\n const ddl = (r.rows?.[0] as any)?.sql as string | undefined;\n if (!ddl || !/UNIQUE\\s*\$\\s*session\\s*,\\s*title\\s*\$/i.test(ddl)) return; // not yet created, or already migrated\n\n const count = async (table: string) => {\n const c = await sqlite.execute({ sql: `SELECT COUNT(*) AS n FROM ${table}`, args: [] });\n return Number((c.rows?.[0] as any)?.n ?? -1);\n };\n const artifactBefore = await count(\"artifact\");\n const filesBefore = await count(\"artifact_file\");\n\n await sqlite.batch([\n `ALTER TABLE artifact RENAME TO artifact_pre_unique_migration`,\n `CREATE TABLE artifact (\n id INTEGER PRIMARY KEY AUTOINCREMENT, session TEXT NOT NULL REFERENCES session(id),\n title TEXT NOT NULL, kind TEXT NOT NULL, content TEXT NOT NULL, ts INTEGER NOT NULL)`,\n `INSERT INTO artifact (id, session, title, kind, content, ts)\n SELECT id, session, title, kind, content, ts FROM artifact_pre_unique_migration`,\n // artifact_file's REFERENCES clause was just silently rewritten (by the RENAME above) to point at\n // artifact_pre_unique_migration — rebuild it too, fresh, against the new `artifact` table, before\n // anything tries to drop the old one.\n `ALTER TABLE artifact_file RENAME TO artifact_file_pre_migration`,\n `CREATE TABLE artifact_file (\n artifact_id INTEGER NOT NULL REFERENCES artifact(id), path TEXT NOT NULL, content TEXT NOT NULL, ts INTEGER NOT NULL,\n PRIMARY KEY(artifact_id, path))`,\n `INSERT INTO artifact_file (artifact_id, path, content, ts)\n SELECT artifact_id, path, content, ts FROM artifact_file_pre_migration`,\n ]);\n\n const artifactAfter = await count(\"artifact\");\n const filesAfter = await count(\"artifact_file\");\n if (artifactAfter !== artifactBefore || filesAfter !== filesBefore) {\n // Leave everything as-is (both old and new tables present) rather than drop anything on a\n // mismatched copy — a human needs to look at this, not have rows silently vanish.\n console.error(`migrateArtifactUniqueConstraint: row-count mismatch after copy (artifact ${artifactBefore}->${artifactAfter}, artifact_file ${filesBefore}->${filesAfter}) — old tables left in place, NOT dropped, migration will retry next startup`);\n return;\n }\n\n // Nothing references the old table names anymore (artifact_file was rebuilt above) — safe to drop.\n await sqlite.batch([\n `DROP TABLE artifact_file_pre_migration`,\n `DROP TABLE artifact_pre_unique_migration`,\n ]);\n } catch (e) {\n console.error(\"migrateArtifactUniqueConstraint failed (artifact table left as-is):\", e);\n }\n}\n\nconst initDB = () =>\n attempt(async () => {\n await sqlite.batch([`PRAGMA foreign_keys = ON`, ...Object.values(DDL)]);\n await migrateArtifactUniqueConstraint(); // must run after CREATE TABLE IF NOT EXISTS (needs the table to exist) and before the new index below\n await sqlite.batch(INDEXES);\n });\n\n/* ────────────────────────────────────────────────────────────────\n Query core — one primitive, three call shapes.\n\n `sql` is a tagged template: values are never concatenated into\n the statement text, so injection is structurally impossible, not\n just discouraged by convention.\n\n The `Table` argument to `all`/`one` is a phantom: zero runtime\n cost, exists purely to pin the generic so the return type is\n declared honestly by the caller instead of inferred from SQL\n text (which is what broke in the original — template-literal\n type matching only resolves on string-literal SQL and silently\n collapses to `unknown` for anything built at runtime).\n ──────────────────────────────────────────────────────────────── */\n// The exact set of values libsql/SQLite can bind as a parameter (mirrors\n// @libsql/client's InValue). `unknown[]` doesn't satisfy either `execute`\n// overload — TS falls through to the `(sql: string, args?: InArgs)` form\n// and reports the whole `{sql, args}` object as an invalid `sql` argument,\n// which is a confusing symptom of an unrelated cause. Declaring the real\n// value type here fixes it at the source instead of casting at each call.\ntype SqlValue =\n | string\n | number\n | bigint\n | boolean\n | ArrayBuffer\n | Uint8Array\n | Date\n | null;\ntype Bound = { text: string; values: SqlValue[] };\nconst sql = (strings: TemplateStringsArray, ...values: SqlValue[]): Bound => ({\n text: strings.reduce(\n (acc, s, i) => acc + s + (i < values.length ? \"?\" : \"\"),\n \"\",\n ),\n values,\n});\n\n// sqlite.execute returns libsql's ResultSet, whose .rows are libsql's own\n// Row type — every column typed as `Value = null | string | number | bigint\n// | ArrayBuffer`, regardless of what our schema declares. TS correctly\n// refuses a direct cast to Row here: nothing in the type system knows a\n// TEXT NOT NULL column can't come back null, or that an INTEGER won't come\n// back as bigint. That guarantee lives in the SQL schema, not in types, so\n// this is an explicit, acknowledged boundary crossing — not a verified one.\nfunction all(_table: T, q: Bound) {\n return attempt(\n async () =>\n (await sqlite.execute({ sql: q.text, args: q.values }))\n .rows as unknown as Row[],\n );\n}\n\nasync function one(table: T, q: Bound) {\n const r = await all(table, q);\n return r.ok ? Ok(r.value[0] ?? null) : r;\n}\n\n// Escape hatch for shapes that don't correspond to any single table — an\n// aggregate like `SELECT COUNT(*) AS c`, a join projection, etc. `all`/`one`\n// can't type these honestly because their phantom `Table` argument has\n// nothing to pin to. Here the caller declares the shape directly via the\n// explicit generic — same honesty contract as `all`, just without a table\n// to anchor it to.\nfunction raw(q: Bound) {\n return attempt(async () =>\n (await sqlite.execute({ sql: q.text, args: q.values }))\n .rows as unknown as T[]\n );\n}\n\n// unwrap(r) → value | null; unwrap(r, fallback) → value | fallback. The old signature\n// dropped the fallback, so every `unwrap(x, [])` caller got null on a DB error and\n// then crashed on `.map` — a latent bug the types were hiding.\nfunction unwrap(r: Result): T | null;\nfunction unwrap(r: Result, fallback: T): T;\nfunction unwrap(r: Result, fallback?: T): T | null {\n return r.ok ? r.value : (fallback === undefined ? null : fallback);\n}\n\n// libsql's ResultSet carries rowsAffected and lastInsertRowid — the only\n// way to learn the AUTOINCREMENT id of a row just inserted, or to confirm\n// a write actually touched anything. Discarding it (`.then(() => undefined)`)\n// made insertMessage() write rows whose id was permanently unrecoverable.\ntype Effect = { rowsAffected: number; lastInsertRowid: bigint | undefined };\nconst run = (q: Bound) =>\n attempt(async () => {\n const r = await sqlite.execute({ sql: q.text, args: q.values });\n return {\n rowsAffected: r.rowsAffected,\n lastInsertRowid: r.lastInsertRowid,\n } satisfies Effect;\n });\n\n/* ────────────────────────────────────────────────────────────────\n Domain operations — thin pipelines over the three primitives.\n Retention is not an afterthought: every write can fail on quota,\n and the failure is handled as data, not caught upstream by luck.\n ──────────────────────────────────────────────────────────────── */\nconst messagesFor = (session: string, limit = 200) =>\n all(\n \"message\",\n sql`SELECT * FROM message WHERE session = ${session} ORDER BY id DESC LIMIT ${limit}`,\n );\n\nconst insertMessage = async (m: Omit, \"id\">) => {\n const r = await run(\n sql`INSERT INTO message (role, content, ts, session, providerId)\n VALUES (${m.role}, ${m.content}, ${m.ts}, ${m.session}, ${m.providerId})`,\n );\n if (!r.ok) return r;\n // lastInsertRowid is undefined only if this wasn't actually an INSERT into\n // a ROWID table — Number(undefined) would silently produce NaN here, which\n // is worse than failing loudly, since a NaN id would propagate downstream\n // looking like a valid one.\n if (r.value.lastInsertRowid === undefined) return Err(\"UNKNOWN\");\n return Ok(Number(r.value.lastInsertRowid));\n};\n\nconst pruneSession = (session: string, keep = 200) =>\n run(sql`DELETE FROM message WHERE session = ${session} AND id NOT IN\n (SELECT id FROM message WHERE session = ${session} ORDER BY id DESC LIMIT ${keep})`);\n\n// Val Town's real ceiling is the storage quota (10MB free / 1GB paid,\n// Turso-backed), not SQLite's own ~2^31-byte string limit. On\n// QUOTA_EXCEEDED, prune this session hard and retry once. If the\n// retry still fails, the caller gets the real error, not a silent drop.\nconst insertMessageSafe = async (m: Omit, \"id\">) => {\n const first = await insertMessage(m);\n\n if (first.ok === false) {\n if (first.error === \"QUOTA_EXCEEDED\") {\n const pruned = await pruneSession(m.session, 100);\n return pruned.ok ? insertMessage(m) : pruned;\n }\n }\n return first;\n};\n\nconst upsertMemory = (key: string, value: string, weight: number, ts: number) =>\n run(\n sql`INSERT INTO memory (key, value, weight, ts) VALUES (${key}, ${value}, ${weight}, ${ts})\n ON CONFLICT(key) DO UPDATE SET value = excluded.value, weight = excluded.weight, ts = excluded.ts`,\n );\n\nconst providerById = (id: string) =>\n one(\"provider\", sql`SELECT * FROM provider WHERE id = ${id}`);\n\nconst providersByPriority = () =>\n all(\"provider\", sql`SELECT * FROM provider ORDER BY priority ASC`);\n\nconst touchSession = (id: string, name: string, ts: number) =>\n run(sql`INSERT INTO session (id, name, ts) VALUES (${id}, ${name}, ${ts})\n ON CONFLICT(id) DO UPDATE SET name = excluded.name, ts = excluded.ts`);\n\n// One row per provider instance name; requests/ok/failed are running totals across every isolate that\n// has ever reported for that name, not a per-call snapshot — the UPDATE adds this call's outcome to\n// whatever was already there rather than replacing it.\nconst bumpProviderStats = (name: string, ok: boolean, error: string | null, ts: number) =>\n run(sql`INSERT INTO provider_stats (name, requests, ok, failed, last_error, updated_at)\n VALUES (${name}, 1, ${ok ? 1 : 0}, ${ok ? 0 : 1}, ${error}, ${ts})\n ON CONFLICT(name) DO UPDATE SET\n requests = requests + 1,\n ok = ok + ${ok ? 1 : 0},\n failed = failed + ${ok ? 0 : 1},\n last_error = COALESCE(${error}, provider_stats.last_error),\n updated_at = ${ts}`);\n\nconst providerStatsAll = () => all(\"provider_stats\", sql`SELECT * FROM provider_stats`);\n\nexport {\n all,\n type Bound,\n bumpProviderStats,\n type DbError,\n Err,\n initDB,\n insertMessage,\n insertMessageSafe,\n messagesFor,\n Ok,\n one,\n providerById,\n providersByPriority,\n providerStatsAll,\n pruneSession,\n raw,\n type Result,\n type Row,\n run,\n type Schema,\n sql,\n type Table,\n touchSession,\n unwrap,\n upsertMemory,\n};",[],[596],"f8bca865-5d85-4915-8172-61ec0a2caa65","catalog.ts","b04a98e8-ab4e-11f1-a8c4-1607ee4eb77e",1410,["D",1789018830497],"// Vendor catalog. One row per OpenAI-compatible endpoint. `models` is the\n// ordered fallback list; `prefer` picks a replacement from the vendor's live\n// /models when every listed id 404s. `${ENV}` in `base` is interpolated.\n// Override/extend at runtime with OMNI_PROVIDERS (JSON array, merged by vendor)\n// and OMNI_DISABLE (comma list of vendors). Priority: lower = tried first;\n// 0–19 free & fast, 20–39 free & slow/quota'd, 40+ paid last resort.\nexport type Vendor = {\n vendor: string;\n base: string;\n keyEnv: string | null;\n models: string[];\n prefer?: string; // regex source, case-insensitive\n priority: number;\n tags?: string[]; // coder | reasoning | fast | long | vision\n headers?: Record;\n paid?: boolean; // paid vendors rank after every free one in `auto`, whatever their quality\n tps?: number; // measured/estimated output tokens per second (default 60)\n ttft?: number; // typical ms to first token (default 1500)\n maxOut?: number; // clamp for max_tokens: free tiers meter prompt+max_tokens per minute (Groq TPM 8000)\n maxIn?: number; // largest prompt (tokens) the free tier accepts per request; prompts above it skip the vendor without a wasted call\n};\n\nimport { FREE } from \"./catalog-free.ts\";\nimport { PAID } from \"./catalog-paid.ts\";\nexport const CATALOG: Vendor[] = [...FREE, ...PAID];\n\n// Quality prior per upstream model id (0–100). Drives `auto`/`best` ordering:\n// higher first across vendors, then vendor priority as tie-break. Editorial,\n// dated 2026-09; override any row via OMNI_QUALITY='{\"regex\":score,…}'.\nconst QUALITY: [RegExp, number][] = [\n [/deepseek-v4-pro/i, 95], [/kimi-k3/i, 94], [/qwen3\\.8-2\\.4t/i, 93], [/glm-5\\.3(?!-flash)/i, 92], [/nemotron-3-ultra/i, 90],\n [/deepseek-v4-flash/i, 88], [/minimax-m3/i, 86], [/qwen3-coder-next|qwen3-coder-plus/i, 86], [/qwen[-.]?3\\.8-27b/i, 85],\n [/glm-5\\.3-flash|glm-5-turbo/i, 84], [/nemotron-3-super/i, 84], [/deepseek-v3\\.2/i, 84], [/kimi-k2/i, 83], [/gpt-oss-120b/i, 82],\n [/gemini-2\\.5-flash(?!-lite)/i, 80], [/gemma-4-31b/i, 80], [/qwen3\\.6|qwen3\\.7/i, 78], [/nemotron-3\\.5-lightning/i, 76],\n [/gemini-2\\.5-flash-lite/i, 74], [/glm-4\\.5-air|glm-4\\.7/i, 72], [/mistral-small/i, 72], [/command-a/i, 72], [/qwen3-30b|qwen3-32b/i, 72],\n [/llama-3\\.3-70b|llama-3_3-70b/i, 70], [/gpt-oss-20b/i, 70], [/nemotron-70b|nemotron-51b/i, 68], [/qwen3-14b/i, 65], [/ministral-14b/i, 62],\n [/qwen3-8b/i, 55], [/ministral-8b|llama-3\\.1-8b/i, 50], [/gpt-5-mini/i, 88], [/claude-sonnet/i, 92], [/claude-haiku/i, 84], [/deepseek-chat|deepseek-reasoner/i, 90], [/grok-4/i, 88],\n];\nlet override: [RegExp, number][] | null = null;\nexport function quality(id: string): number {\n if (override === null) {\n override = [];\n try { for (const [k, v] of Object.entries(JSON.parse(Deno.env.get(\"OMNI_QUALITY\") ?? \"{}\"))) override.push([new RegExp(k, \"i\"), Number(v)]); } catch { /* ignore */ }\n }\n for (const [rx, q] of override) if (rx.test(id)) return q;\n for (const [rx, q] of QUALITY) if (rx.test(id)) return q;\n return 40;\n}\n",[],[605],"6b6be713-93fa-47ed-bafe-4eeb65f5abbe","catalog-paid.ts","b0d2b336-ab4e-11f1-a8c4-1607ee4eb77e",1463,["D",1789096031038],"import type { Vendor } from \"./catalog.ts\";\n// Paid — last resort, only routed when a key is present.\nexport const PAID: Vendor[] = [\n { paid: true, vendor: \"deepseek\", base: \"https://api.deepseek.com/v1\", keyEnv: \"DEEPSEEK_API_KEY\", priority: 40, tags: [\"coder\", \"reasoning\"], models: [\"deepseek-chat\", \"deepseek-reasoner\"] },\n { paid: true, vendor: \"moonshot\", base: \"https://api.moonshot.ai/v1\", keyEnv: \"MOONSHOT_API_KEY\", priority: 41, tags: [\"coder\", \"long\"], models: [\"kimi-k2-turbo-preview\", \"kimi-k2-0905-preview\"], prefer: \"kimi\" },\n { paid: true, vendor: \"xai\", base: \"https://api.x.ai/v1\", keyEnv: \"XAI_API_KEY\", priority: 42, tags: [\"reasoning\"], models: [\"grok-4-fast-non-reasoning\", \"grok-4-fast-reasoning\"], prefer: \"grok.*fast\" },\n { paid: true, vendor: \"openai\", base: \"https://api.openai.com/v1\", keyEnv: \"OPENAI_API_KEY\", priority: 43, tags: [\"coder\", \"reasoning\", \"vision\"], models: [\"gpt-5-mini\", \"gpt-4.1-mini\"], prefer: \"gpt-5-mini|gpt-4.1-mini\" },\n // Credit-based (small free grants, then metered): ranked with the paid tier so they are last resorts, not daily drivers.\n { paid: true, vendor: \"deepinfra\", tps: 60, base: \"https://api.deepinfra.com/v1/openai\", keyEnv: \"DEEPINFRA_API_KEY\", priority: 41, tags: [\"coder\", \"reasoning\", \"long\"], models: [\"deepseek-ai/DeepSeek-V3.1\", \"Qwen/Qwen3-Coder-480B-A35B-Instruct\", \"meta-llama/Llama-3.3-70B-Instruct\"], prefer: \"deepseek|qwen3-coder|llama\" },\n { paid: true, vendor: \"fireworks\", tps: 120, base: \"https://api.fireworks.ai/inference/v1\", keyEnv: \"FIREWORKS_API_KEY\", priority: 42, tags: [\"coder\", \"reasoning\", \"long\"], models: [\"accounts/fireworks/models/deepseek-v3p1\", \"accounts/fireworks/models/qwen3-coder-480b-a35b-instruct\", \"accounts/fireworks/models/kimi-k2-instruct\"], prefer: \"deepseek|qwen3-coder|kimi\" },\n { paid: true, vendor: \"anthropic\", base: \"https://api.anthropic.com/v1\", keyEnv: \"ANTHROPIC_API_KEY\", priority: 44, tags: [\"coder\", \"reasoning\", \"vision\"], models: [\"claude-sonnet-4-5\", \"claude-haiku-4-5\"], prefer: \"haiku|sonnet\" },\n];\n",[],[613],"682fd4d5-fa55-46d5-93e0-f51806c1f9c8","catalog-free.ts","b08f5190-ab4e-11f1-b3f3-1607ee4eb77e",1462,["D",1789096030770],"import type { Vendor } from \"./catalog.ts\";\n// Free tiers, priority 0–19 = latency order (used by `fast`); `auto` ranks by QUALITY instead.\nexport const FREE: Vendor[] = [\n { vendor: \"groq\", tps: 400, maxOut: 5500, maxIn: 6500, base: \"https://api.groq.com/openai/v1\", keyEnv: \"GROQ_API_KEY\", priority: 0, tags: [\"fast\"],\n models: [\"qwen/qwen3.8-27b\", \"openai/gpt-oss-120b\", \"openai/gpt-oss-20b\"], prefer: \"gpt-oss|qwen|llama\" },\n { vendor: \"cerebras\", tps: 1200, maxOut: 8000, base: \"https://api.cerebras.ai/v1\", keyEnv: \"CEREBRAS_API_KEY\", priority: 1, tags: [\"fast\"],\n models: [\"qwen-3.8-27b\", \"gpt-oss-120b\", \"gemma-4-31b\"], prefer: \"gpt-oss|qwen|llama\" },\n { vendor: \"sambanova\", tps: 300, base: \"https://api.sambanova.ai/v1\", keyEnv: \"SAMBANOVA_API_KEY\", priority: 2, tags: [\"fast\", \"reasoning\"],\n models: [\"MiniMax-M3\", \"DeepSeek-V3.2\", \"gpt-oss-120b\", \"Meta-Llama-3.3-70B-Instruct\"], prefer: \"minimax|deepseek|gpt-oss|llama\" },\n { vendor: \"openrouter\", tps: 30, ttft: 4000, base: \"https://openrouter.ai/api/v1\", keyEnv: \"OPENROUTER_API_KEY\", priority: 3, tags: [\"coder\", \"reasoning\", \"long\"],\n // ordered by throughput on the free tier: the 550B ultra model times out inside a 50 s turn and is a last resort\n models: [\"nvidia/nemotron-3-super-120b-a12b:free\", \"google/gemma-4-31b-it:free\", \"nvidia/nemotron-3.5-lightning:free\", \"thinkingmachines/inkling:free\", \"nvidia/nemotron-3-ultra-550b-a55b:free\"],\n prefer: \"super|gemma|lightning\" },\n { vendor: \"huggingface\", tps: 50, base: \"https://router.huggingface.co/v1\", keyEnv: \"HF_TOKEN\", priority: 4, tags: [\"coder\", \"reasoning\", \"long\"],\n models: [\"deepseek-ai/DeepSeek-V4-Pro\", \"moonshotai/Kimi-K3\", \"zai-org/GLM-5.3\", \"deepseek-ai/DeepSeek-V4-Flash\", \"Qwen/Qwen3-Coder-Next\", \"Qwen/Qwen3.8-27B\", \"openai/gpt-oss-120b\", \"zai-org/GLM-5.3-Flash\"], prefer: \"deepseek|kimi|glm|qwen|gpt-oss\" },\n { vendor: \"gemini\", tps: 150, base: \"https://generativelanguage.googleapis.com/v1beta/openai\", keyEnv: \"GEMINI_API_KEY\", priority: 5, tags: [\"fast\", \"long\", \"vision\"],\n models: [\"gemini-2.5-flash-lite\", \"gemini-2.5-flash\", \"gemini-2.0-flash\"], prefer: \"flash\" },\n { vendor: \"mistral\", tps: 80, base: \"https://api.mistral.ai/v1\", keyEnv: \"MISTRAL_API_KEY\", priority: 6, tags: [\"coder\"],\n models: [\"mistral-small-latest\", \"ministral-14b-latest\", \"ministral-8b-latest\", \"devstral-small-latest\"], prefer: \"mistral-small|ministral\" },\n { vendor: \"nvidia_nim\", tps: 40, base: \"https://integrate.api.nvidia.com/v1\", keyEnv: \"NVIDIA_API_KEY\", priority: 20, tags: [\"reasoning\"],\n models: [\"nvidia/llama-3.1-nemotron-51b-instruct\", \"mistralai/mistral-nemotron\", \"meta/llama-3.2-90b-vision-instruct\"], prefer: \"nemotron-(51|70)b|mistral-nemotron\" },\n { vendor: \"zai\", base: \"https://open.bigmodel.cn/api/paas/v4\", keyEnv: \"ZAI_API_KEY\", priority: 8, tags: [\"coder\"],\n models: [\"glm-5.3-flash\", \"glm-4.5-air\", \"glm-5-turbo\"], prefer: \"flash|air\" },\n { vendor: \"cohere\", base: \"https://api.cohere.ai/compatibility/v1\", keyEnv: \"COHERE_API_KEY\", priority: 9,\n models: [\"command-a-03-2025\", \"command-r7b-12-2024\", \"command-r-plus\"], prefer: \"command\" },\n { vendor: \"cloudflare\", tps: 100, base: \"https://api.cloudflare.com/client/v4/accounts/${CF_ACCOUNT_ID}/ai/v1\", keyEnv: \"CF_AI_TOKEN\", priority: 10, tags: [\"fast\"],\n models: [\"@cf/openai/gpt-oss-120b\", \"@cf/meta/llama-3.3-70b-instruct-fp8-fast\", \"@cf/qwen/qwen3-30b-a3b-fp8\"], prefer: \"gpt-oss|llama-3.3|qwen\" },\n { vendor: \"together\", tps: 80, base: \"https://api.together.xyz/v1\", keyEnv: \"TOGETHER_API_KEY\", priority: 11,\n models: [\"openai/gpt-oss-20b\", \"Qwen/Qwen3-14B\", \"meta-llama/Llama-3.3-70B-Instruct\", \"openai/gpt-oss-120b\"], prefer: \"gpt-oss-20b|qwen3-14b|llama-3.3-70b-instruct$\" },\n { vendor: \"siliconflow\", base: \"https://api.siliconflow.cn/v1\", keyEnv: \"SILICONFLOW_API_KEY\", priority: 12,\n models: [\"Qwen/Qwen3-8B\", \"THUDM/GLM-4-9B-0414\"], prefer: \"qwen3-8b|glm\" },\n { vendor: \"ovh\", base: \"https://oai.endpoints.kepler.ai.cloud.ovh.net/v1\", keyEnv: \"OVH_AI_ENDPOINTS_ACCESS_TOKEN\", priority: 13,\n models: [\"Meta-Llama-3_3-70B-Instruct\", \"gpt-oss-120b\", \"Qwen3-32B\"], prefer: \"llama|gpt-oss|qwen\" },\n { vendor: \"chutes\", base: \"https://llm.chutes.ai/v1\", keyEnv: \"CHUTES_API_KEY\", priority: 14,\n models: [\"openai/gpt-oss-120b\", \"Qwen/Qwen3-235B-A22B-Instruct-2507\"], prefer: \"gpt-oss|qwen\" },\n { vendor: \"novita\", base: \"https://api.novita.ai/v3/openai\", keyEnv: \"NOVITA_API_KEY\", priority: 15,\n models: [\"openai/gpt-oss-120b\", \"meta-llama/llama-3.3-70b-instruct\"], prefer: \"gpt-oss|llama-3.3\" },\n { vendor: \"hyperbolic\", base: \"https://api.hyperbolic.xyz/v1\", keyEnv: \"HYPERBOLIC_API_KEY\", priority: 16,\n models: [\"openai/gpt-oss-120b\", \"meta-llama/Llama-3.3-70B-Instruct\"], prefer: \"gpt-oss|llama-3.3\" },\n { vendor: \"dashscope\", base: \"https://dashscope-intl.aliyuncs.com/compatible-mode/v1\", keyEnv: \"DASHSCOPE_API_KEY\", priority: 17, tags: [\"coder\"],\n models: [\"qwen-plus\", \"qwen3-coder-plus\", \"qwen-turbo\"], prefer: \"qwen\" },\n { vendor: \"scaleway\", base: \"https://api.scaleway.ai/v1\", keyEnv: \"SCW_SECRET_KEY\", priority: 18,\n models: [\"gpt-oss-120b\", \"llama-3.3-70b-instruct\"], prefer: \"gpt-oss|llama\" },\n { vendor: \"featherless\", base: \"https://api.featherless.ai/v1\", keyEnv: \"FEATHERLESS_API_KEY\", priority: 19,\n models: [\"meta-llama/Llama-3.3-70B-Instruct\"], prefer: \"llama-3.3|qwen\" },\n];\n",[],[621],"7e760d86-8efa-4da0-97f4-c6f44f105027","brain.ts","71659d08-b15c-11f1-b827-1607ee4eb77e",1646,["D",1789514602268],"// The supervisor. Watches a running job, diagnoses why it is going wrong, rewrites the instructions the\n// workers get, and schedules corrective work. Runs as an ordinary `supervise` step, so it is subject to\n// the same budget and lease rules as everything else it supervises.\n//\n// Deliberately rule-first. Diagnosis is deterministic pattern-matching over step outcomes; the model is\n// consulted only to phrase a better instruction, and never to decide WHETHER to act or HOW MUCH work to\n// create. A supervisor that can both judge and spend is a runaway: it observes its own corrections\n// failing, corrects harder, and converts a stuck build into an unbounded bill. Every actuator below is\n// saturated — bounded directives, bounded new steps, bounded passes — and the caps are the point, not\n// defensive decoration.\nimport { all, one, run, sql } from \"./db.ts\";\nimport { enqueue, MAX_ATTEMPTS } from \"./scheduler.ts\";\n\nexport const MAX_DIRECTIVES = 6; // instruction text is a budget too: past ~6 added rules, workers start ignoring them\nexport const MAX_NEW_STEPS_PER_PASS = 4;\nexport const MAX_PASSES = 8; // a job the supervisor cannot fix in 8 passes is not one more pass away\n\n/** [18] MULTIPLE TESTING. The supervisor evaluates m rules against every step of every job, so with a\n * per-rule false-positive rate alpha the family-wise error is ~1-(1-alpha)^m ~ m*alpha. At m=5 rules and\n * the naive \"3 occurrences is a pattern\" threshold, spurious directives are not unlikely, they are\n * expected — and a spurious directive permanently constrains every subsequent worker. Bonferroni: to\n * hold family-wise error at alpha, test each rule at alpha/m, which for a geometric null (repeat\n * failures i.i.d. w.p. q) raises the evidence threshold to ceil(log(alpha/m)/log(q)). With q=0.3,\n * alpha=0.05, m=5 that is 4, not 3. Cheap to compute, and it is the difference between a supervisor\n * that reacts to noise and one that reacts to signal. */\nexport const RULE_COUNT = 5;\nexport const FAMILY_ALPHA = 0.05;\nexport const NULL_REPEAT_Q = 0.3;\nexport const evidenceThreshold = (m = RULE_COUNT, alpha = FAMILY_ALPHA, q = NULL_REPEAT_Q) =>\n Math.max(2, Math.ceil(Math.log(alpha / m) / Math.log(q)));\n\nexport type Signal = { kind: string; subject: string; detail: string; count: number };\nexport type Finding = { rule: string; subject: string; why: string; directive?: string; steps?: { kind: string; payload: unknown }[] };\n\nconst key = (job: string) => `brain:${job}`;\ntype BrainState = { passes: number; directives: string[]; seen: string[]; lastFailures?: number; idlePasses?: number };\n\nexport async function brainState(job: string): Promise {\n const r = await one(\"omni_state\", sql`SELECT * FROM omni_state WHERE key = ${key(job)}`);\n if (r.ok && r.value) { try { return JSON.parse((r.value as any).value); } catch { /* corrupt row: fall through to a fresh state rather than wedging the job */ } }\n return { passes: 0, directives: [], seen: [] };\n}\nconst saveState = (job: string, s: BrainState) =>\n run(sql`INSERT INTO omni_state (key, value, ts) VALUES (${key(job)}, ${JSON.stringify(s)}, ${Date.now()})\n ON CONFLICT(key) DO UPDATE SET value = excluded.value, ts = excluded.ts`);\n\n/** Extra instruction lines injected into every worker prompt for this job. Callers append these to the\n * system/user prompt they were already going to send — the supervisor never rewrites a base prompt, it\n * only adds constraints, so a bad directive degrades output rather than destroying the instruction. */\nexport async function directivesFor(job: string): Promise {\n return (await brainState(job)).directives;\n}\n\n/** OBSERVE — everything the supervisor is allowed to know, read in one pass. */\nexport async function observe(job: string): Promise {\n const out: Signal[] = [];\n const r = await all(\"step\", sql`SELECT kind, status, attempts, error, payload FROM step WHERE job = ${job}`);\n const rows = (r.ok ? r.value : []) as any[];\n\n const byErr = new Map }>();\n for (const s of rows) {\n if (!s.error) continue;\n const sig = String(s.error).slice(0, 80);\n const e = byErr.get(sig) ?? { n: 0, kinds: new Set() };\n e.n++; e.kinds.add(s.kind); byErr.set(sig, e);\n }\n for (const [sig, e] of byErr) out.push({ kind: \"repeated_error\", subject: [...e.kinds].join(\",\"), detail: sig, count: e.n });\n\n for (const s of rows) {\n if (s.attempts >= MAX_ATTEMPTS && s.status === \"failed\") out.push({ kind: \"exhausted\", subject: s.kind, detail: String(s.error ?? \"\").slice(0, 120), count: s.attempts });\n if (/truncat|max_tokens|output was cut/i.test(String(s.error ?? \"\"))) out.push({ kind: \"truncated\", subject: s.kind, detail: String(s.payload ?? \"\").slice(0, 80), count: 1 });\n if (/not owned by this run|find text not present|does not exist/i.test(String(s.error ?? \"\"))) out.push({ kind: \"misdirected_write\", subject: s.kind, detail: String(s.error).slice(0, 120), count: 1 });\n }\n const stuck = rows.filter((s) => s.status === \"ready\").length;\n const running = rows.filter((s) => s.status === \"running\").length;\n if (stuck > 0 && running === 0 && rows.some((s) => s.status === \"failed\")) out.push({ kind: \"blocked_by_failure\", subject: job, detail: `${stuck} ready, ${running} running`, count: stuck });\n return out;\n}\n\n/** DIAGNOSE — deterministic. Each rule names the directive it wants and the work it wants scheduled. */\nexport function diagnose(signals: Signal[]): Finding[] {\n const f: Finding[] = [];\n for (const s of signals) {\n if (s.kind === \"truncated\") {\n f.push({ rule: \"split_oversized\", subject: s.subject, why: `output truncated on ${s.subject}`,\n directive: \"Keep each file under ~200 lines. If the file would be longer, emit the first coherent section only and stop cleanly — a later step completes it.\",\n steps: [{ kind: \"verify_file\", payload: { hint: s.detail } }] });\n }\n if (s.kind === \"misdirected_write\") {\n f.push({ rule: \"pin_target_path\", subject: s.subject, why: s.detail,\n directive: \"Write ONLY the exact file path named in your instruction. Never write index.html unless it is your named path. If you believe another file needs changing, say so in your reply instead of writing it.\" });\n }\n if (s.kind === \"repeated_error\" && s.count >= evidenceThreshold()) {\n f.push({ rule: \"recurring_failure\", subject: s.subject, why: `${s.count}x: ${s.detail}`,\n directive: `A previous attempt failed repeatedly with: \"${s.detail}\". Do not repeat that approach.` });\n }\n if (s.kind === \"exhausted\") {\n f.push({ rule: \"give_up_visibly\", subject: s.subject, why: `${s.subject} exhausted ${s.count} attempts`,\n steps: [{ kind: \"report_blocked\", payload: { step: s.subject, error: s.detail } }] });\n }\n if (s.kind === \"blocked_by_failure\") {\n f.push({ rule: \"unblock\", subject: s.subject, why: s.detail, steps: [{ kind: \"report_blocked\", payload: { job: s.subject, detail: s.detail } }] });\n }\n }\n return f;\n}\n\n/** ACT — apply findings under saturation. Returns what it actually did, which is not what it wanted. */\nexport async function supervise(job: string): Promise<{ passes: number; applied: Finding[]; directives: string[]; scheduled: number; capped: string[] }> {\n const st = await brainState(job);\n const capped: string[] = [];\n if (st.passes >= MAX_PASSES) return { passes: st.passes, applied: [], directives: st.directives, scheduled: 0, capped: [\"max_passes\"] };\n\n // [19] ANTI-WINDUP. A controller that keeps integrating while its output is saturated, or while its\n // corrections are not moving the plant, winds up: it accumulates ever-larger interventions for a system\n // that is not responding to them. Here that looks like directive after directive piled onto workers\n // that are failing for a reason no instruction can fix. So: measure whether the last intervention\n // actually reduced the failure count, and if two consecutive passes produced no improvement, stop\n // intervening and escalate instead. The supervisor's job includes knowing it is not helping.\n const signals = await observe(job);\n const failures = signals.reduce((a, s) => a + (s.kind === \"exhausted\" || s.kind === \"repeated_error\" ? s.count : 0), 0);\n const improved = st.lastFailures === undefined || failures < st.lastFailures;\n st.idlePasses = improved ? 0 : (st.idlePasses ?? 0) + 1;\n st.lastFailures = failures;\n if ((st.idlePasses ?? 0) >= 2) {\n st.passes++; await saveState(job, st);\n await enqueue(job, [{ kind: \"report_blocked\", payload: { job, reason: \"supervisor made no progress over two passes; escalating instead of adding instructions\", failures }, priority: 10, dedupe: `noprogress:${job}` }]);\n return { passes: st.passes, applied: [], directives: st.directives, scheduled: 1, capped: [\"anti_windup\"] };\n }\n\n // [20] DEAD BAND. Below a minimum evidence level the controller does nothing at all — implemented as\n // evidenceThreshold() inside diagnose(). Without one, a feedback loop with delay reacts to every\n // fluctuation and oscillates around the target instead of settling, and each oscillation here costs a\n // permanent directive and real model calls.\n const findings = diagnose(signals);\n const fresh = findings.filter((x) => !st.seen.includes(x.rule + \"|\" + x.subject)); // never act twice on the same finding\n const applied: Finding[] = [];\n let scheduled = 0;\n\n for (const x of fresh) {\n if (x.directive && !st.directives.includes(x.directive)) {\n if (st.directives.length >= MAX_DIRECTIVES) { capped.push(\"max_directives\"); }\n else st.directives.push(x.directive);\n }\n if (x.steps?.length) {\n const room = MAX_NEW_STEPS_PER_PASS - scheduled;\n if (room <= 0) { capped.push(\"max_new_steps\"); }\n else { const ids = await enqueue(job, x.steps.slice(0, room).map((s) => ({ kind: s.kind, payload: s.payload, priority: 10, dedupe: `${x.rule}:${x.subject}:${s.kind}` }))); scheduled += ids.length; }\n }\n st.seen.push(x.rule + \"|\" + x.subject);\n applied.push(x);\n }\n st.passes++;\n st.seen = st.seen.slice(-100);\n await saveState(job, st);\n return { passes: st.passes, applied, directives: st.directives, scheduled, capped: [...new Set(capped)] };\n}\n\n/** Wipe supervision state for a job — used when a build is restarted from scratch so stale directives\n * from a previous run do not constrain a fresh attempt. */\nexport const resetBrain = (job: string) => run(sql`DELETE FROM omni_state WHERE key = ${key(job)}`);\n",[],[629],"cf368da4-6471-480c-9c0e-3fb483c457ed","artifacts.ts","4b6b75ba-ac6f-11f1-a399-1607ee4eb77e",1671,["D",1789516263682],18,"// Multi-file artifacts: an `artifact` row (title, kind, index content) plus\n// `artifact_file` rows. Served path-style at /artifact// so relative\n// ';\nexport function serveFile(\n origin: string,\n path: string,\n content: string,\n): Response {\n if (content === null) {\n return;\n }\n\n let ct = mimeFor(path || \"index.html\");\n let body: BodyInit = content;\n if (/^(index\\.html?)?$/.test(path) || /\\.html?$/.test(path)) {\n const i = content.search(/]*>/i);\n body = i >= 0\n ? content.slice(0, content.indexOf(\">\", i) + 1) + CONSOLE_HOOK +\n content.slice(content.indexOf(\">\", i) + 1)\n : CONSOLE_HOOK + content;\n }\n const m = content.length < 12_000_000 && content.startsWith(\"data:\")\n ? content.match(/^data:([^;,]+)?(;base64)?,/)\n : null;\n if (m) { // binary asset stored as a data URL by the workbench/zip import\n ct = m[1] || ct;\n const raw = content.slice(m[0].length);\n body = m[2]\n ? Uint8Array.from(atob(raw), (c) => c.charCodeAt(0))\n : decodeURIComponent(raw);\n }\n return new Response(body, {\n headers: {\n \"content-type\": ct,\n \"content-security-policy\":\n `default-src 'none'; script-src ${origin} 'unsafe-inline' 'unsafe-eval'; style-src ${origin} 'unsafe-inline'; img-src ${origin} data: blob: https:; font-src ${origin} data:; connect-src ${origin} data: blob:; media-src ${origin} data: blob:; worker-src ${origin} blob:; frame-ancestors 'self'`,\n \"x-content-type-options\": \"nosniff\",\n \"cache-control\": \"no-store\",\n },\n });\n}\n\n/** Pull a full HTML document out of a reply when the model wrote code instead of calling create_artifact. */\nexport function extractHtmlDocument(\n reply: string,\n): { title: string; html: string } | null {\n const m = reply.match(/```(?:html|htm)?\\s*\\n([\\s\\S]*?)\\n```/gi);\n if (!m) return null;\n for (const block of m) {\n const html = block.replace(/^```\\w*\\s*\\n/, \"\").replace(/\\n```$/, \"\");\n if (\n /]|= 25\n ) {\n const t = html.match(/([^<]{1,80})<\\/title>/i);\n return { title: t ? t[1].trim() : \"App\", html };\n }\n }\n return null;\n}",[],[637],"7c79a1b0-6777-4707-99cf-6720aa7cd0a8","app.tsx","a03409c6-79e4-11f1-bc29-1607ee4eb77e",["D",1789519272028],128,"import { PAGE_HTML } from \"./main-html.tsx\";\nimport {\n DEFAULT_PROMPTS,\n normalizePromptOverrides,\n PROMPT_VARS,\n type PromptKey,\n renderPrompt,\n} from \"./prompts.ts\";\nimport {\n APP_RX,\n type ArtFile,\n deleteFile,\n extractHtmlDocument,\n lintArtifact,\n listFiles,\n qualityReport,\n readFile,\n saveArtifact,\n saveMany,\n serveFile,\n writeFile,\n} from \"./artifacts.ts\";\nimport { discoverMcpTools } from \"./mcp-client.ts\";\nimport {\n activeSkills,\n type Focus,\n normalizeSettings,\n type Settings,\n type Skill,\n} from \"./app-settings.ts\";\nimport { handleSwarm } from \"./app-swarm.ts\";\nimport { handleIssues, ISSUE_TOOLS } from \"./issues.ts\";\nimport {\n BUILD_RX,\n callInference,\n type GenOpts,\n type InferResult,\n} from \"./app-infer.ts\";\nimport {\n compactMessage,\n handleCompact,\n liveChars,\n loadCompact,\n} from \"./app-compact.ts\";\nimport {\n deriveTitle,\n evalJs,\n getMemoryBlob,\n META_CLOSE,\n META_OPEN,\n parseMeta,\n parseTextToolCalls,\n preEstimate,\n retrieveFacts,\n salvageArtifactArgs,\n slimEvents,\n summarizeEvent,\n TOOL_ALIASES,\n type ToolEvent,\n webSearch,\n writeFact,\n} from \"./app-helpers.ts\";\nimport {\n all,\n type Bound,\n type DbError,\n Err,\n initDB,\n insertMessageSafe,\n messagesFor,\n Ok,\n one,\n pruneSession,\n raw,\n type Result,\n type Row,\n run,\n sql,\n touchSession,\n unwrap,\n} from \"./db.ts\";\n\nconst BUDGET = {\n loopHops: 8,\n planPass: 1,\n ensembleSamples: 3,\n verifyPass: 1,\n regroundPass: 1,\n hardCeilingPasses: 14,\n};\n\nconst VERIFIER_MODEL: string | null = null;\n\nconst recent = new Map<string, number>();\nfunction rateLimit(k: string, ms = 900): boolean {\n const now = Date.now();\n if (now - (recent.get(k) ?? 0) < ms) return false;\n recent.set(k, now);\n return true;\n}\nfunction clean(s: string): string {\n return s.replace(/\\u0000/g, \"\").trim().slice(0, 64_000);\n}\nasync function safeJson(res: Response) {\n const ct = res.headers.get(\"content-type\") || \"\";\n const body = await res.text();\n if (!res.ok || !ct.includes(\"application/json\")) {\n throw new Error(\n `Expected JSON, got ${res.status} ${ct}: ${body.slice(0, 120)}`,\n );\n }\n try {\n return JSON.parse(body);\n } catch {\n throw new Error(`Bad JSON: ${body.slice(0, 120)}`);\n }\n}\n\nasync function ensureSession(id: string): Promise<Row<\"session\">> {\n const existing = await one(\n \"session\",\n sql`SELECT * FROM session WHERE id = ${id}`,\n );\n\n if (existing?.ok && existing.value?.[0]) {\n return existing.value[0];\n }\n const row: Row<\"session\"> = { id, name: \"New Chat\", ts: Date.now() };\n await touchSession(row.id, row.name, row.ts);\n return row;\n}\n\nasync function listSessions(): Promise<Row<\"session\">[]> {\n return unwrap(\n await all(\"session\", sql`SELECT * FROM session ORDER BY ts DESC LIMIT 50`),\n [],\n );\n}\n\nasync function renameSession(id: string, name: string): Promise<void> {\n await run(sql`UPDATE session SET name = ${name} WHERE id = ${id}`);\n}\n\nasync function deleteSession(id: string): Promise<void> {\n await run(sql`DELETE FROM message WHERE session = ${id}`);\n await run(sql`DELETE FROM session WHERE id = ${id}`);\n}\n\nasync function clearSession(id: string): Promise<void> {\n await pruneSession(id, 0);\n}\n\nasync function addMsg(\n role: Row<\"message\">[\"role\"],\n content: string,\n providerId: string | null = null,\n session = \"default\",\n meta: Record<string, unknown> | null = null,\n): Promise<void> {\n const r = await insertMessageSafe({\n role,\n content,\n ts: Date.now(),\n session,\n providerId,\n });\n if (!r.ok) {\n console.error(`addMsg failed (session=${session}):`, r.error);\n return;\n }\n if (meta) {\n let json = JSON.stringify(meta);\n if (json.length > 120_000) {\n json = JSON.stringify({\n ...meta,\n toolEvents: slimEvents((meta.toolEvents as ToolEvent[]) ?? [], 200),\n });\n }\n await run(\n sql`INSERT INTO message_meta (message_id, meta) VALUES (${r.value}, ${json}) ON CONFLICT(message_id) DO UPDATE SET meta = excluded.meta`,\n );\n }\n}\n\n/** Newest messages that fit a character budget (≈ budget/3.6 tokens). Long single messages keep head + tail.\n * The budget is what keeps prompts under free-tier input ceilings (Groq ITPM 7000 ≈ 25k chars all-in, of which\n * system prompt + tool schemas already take ~10k); the router still skips vendors the prompt cannot fit. */\nasync function getContext(\n session = \"default\",\n limit = 24,\n budget = 16_000,\n): Promise<Row<\"message\">[]> {\n const compact = await loadCompact(session);\n const rows = unwrap(await messagesFor(session, limit), []).filter((m) =>\n !compact || m.id > compact.uptoId\n );\n const out: Row<\"message\">[] = [];\n let used = compact ? compact.chars : 0;\n for (const [i, m] of rows.entries()) {\n let content = m.content;\n if (content.length > 6_000) {\n content = content.slice(0, 4_200) + \"\\n…[\" + (content.length - 5_400) +\n \" chars trimmed]…\\n\" + content.slice(-1_200);\n }\n if (i >= 2 && used + content.length > budget) break;\n used += content.length;\n out.push({ ...m, content });\n }\n out.reverse();\n if (compact) {\n out.unshift(\n {\n id: 0,\n role: \"system\",\n content: compactMessage(compact).content,\n ts: compact.ts,\n session,\n providerId: null,\n } as Row<\"message\">,\n );\n }\n return out;\n}\n\nasync function getHistory(\n session: string,\n): Promise<(Row<\"message\"> & { meta: unknown })[]> {\n const rows = unwrap(\n await raw<Row<\"message\"> & { meta: string | null }>(\n sql`SELECT m.*, mm.meta AS meta FROM message m LEFT JOIN message_meta mm ON mm.message_id = m.id WHERE m.session = ${session} ORDER BY m.id ASC`,\n ),\n [],\n );\n const out = rows.map((r) => {\n let meta: any = null;\n if (r.meta) {\n try {\n meta = JSON.parse(r.meta);\n } catch { /* ignore */ }\n }\n return { ...r, meta };\n });\n\n if (out.some((m) => m.role === \"assistant\" && !m.meta)) {\n const arts = unwrap(\n await all(\n \"artifact\",\n sql`SELECT id, title, kind, ts FROM artifact WHERE session = ${session} ORDER BY ts ASC`,\n ),\n [],\n ) as { id: number; title: string; kind: string; ts: number }[];\n let prevTs = 0;\n for (const m of out) {\n if (m.role === \"assistant\" && !m.meta) {\n const mine = arts.filter((a) => a.ts > prevTs && a.ts <= m.ts + 2_000);\n if (mine.length) {\n m.meta = {\n backfilled: true,\n toolEvents: mine.map((a, i) => ({\n hop: i,\n tool: \"create_artifact\",\n args: { title: a.title, kind: a.kind },\n result: {\n ok: true,\n id: a.id,\n url: `/artifact/${a.id}/`,\n title: a.title,\n },\n })),\n };\n }\n }\n prevTs = m.ts;\n }\n }\n return out;\n}\n\ninterface ToolCtx {\n session: string;\n turn?: { artifactId?: number; artifactTitle?: string };\n\n tools: Record<string, Tool>;\n schemas: unknown[];\n}\ninterface Tool {\n schema: Record<string, unknown>;\n handle: (args: Record<string, unknown>, ctx: ToolCtx) => Promise<unknown>;\n}\n\nconst TOOLS: Record<string, Tool> = {\n memory_recall: {\n schema: {\n type: \"function\",\n function: {\n name: \"memory_recall\",\n description:\n \"Retrieve the most relevant remembered facts for a query, ranked by relevance × decayed-salience.\",\n parameters: {\n type: \"object\",\n properties: {\n query: { type: \"string\", description: \"What to recall about.\" },\n },\n required: [\"query\"],\n },\n },\n },\n handle: async ({ query }) => ({\n facts: await retrieveFacts(String(query)),\n }),\n },\n memory_write: {\n schema: {\n type: \"function\",\n function: {\n name: \"memory_write\",\n description:\n \"Persist a durable fact. Provide `predictability` 0..1: how obvious/derivable this fact was to you BEFORE learning it (0 = totally surprising, 1 = you would have guessed it). Surprising facts are retained longer.\",\n parameters: {\n type: \"object\",\n properties: {\n fact: { type: \"string\", description: \"The fact (≤400 chars).\" },\n predictability: {\n type: \"number\",\n description: \"0..1 self-estimated prior predictability.\",\n },\n },\n required: [\"fact\", \"predictability\"],\n },\n },\n },\n handle: async ({ fact, predictability }) => {\n const p = Number(predictability);\n await writeFact(String(fact), Number.isFinite(p) ? p : 0.5);\n return { ok: true };\n },\n },\n name_session: {\n schema: {\n type: \"function\",\n function: {\n name: \"name_session\",\n description:\n \"Set a concise title (≤40 chars, ≤4 words) for the current conversation.\",\n parameters: {\n type: \"object\",\n properties: {\n name: { type: \"string\", description: \"Session title.\" },\n },\n required: [\"name\"],\n },\n },\n },\n handle: async ({ name }, { session }) => {\n const trimmed = String(name).slice(0, 40);\n await renameSession(session, trimmed);\n return { ok: true, name: trimmed };\n },\n },\n session_clear: {\n schema: {\n type: \"function\",\n function: {\n name: \"session_clear\",\n description: \"Erase all messages in the current session.\",\n parameters: { type: \"object\", properties: {}, required: [] },\n },\n },\n handle: async (_a, { session }) => {\n await clearSession(session);\n return { ok: true };\n },\n },\n session_delete: {\n schema: {\n type: \"function\",\n function: {\n name: \"session_delete\",\n description:\n \"Permanently delete the current session and all its messages.\",\n parameters: { type: \"object\", properties: {}, required: [] },\n },\n },\n handle: async (_a, { session }) => {\n await deleteSession(session);\n return { ok: true };\n },\n },\n create_artifact: {\n schema: {\n type: \"function\",\n function: {\n name: \"create_artifact\",\n description:\n 'Build an application, visualization, game, graphic or document the user opens and uses. `content` is the entry file (a complete HTML document for kind html; an SVG; or Markdown). Optional `files` adds sibling files (app.js, style.css, shader.glsl, data.json …) that the entry references by RELATIVE path (<script src=\"app.js\">, fetch(\"data.json\")). Call this ONCE per turn with the complete program; to change something afterwards call update_artifact — a second create_artifact in the same turn updates the first one instead of duplicating it. Renders in a sandboxed frame: no cookies, no parent page, network limited to its own files.',\n parameters: {\n type: \"object\",\n properties: {\n title: {\n type: \"string\",\n description:\n \"Short, stable name — the artifact's identity for future updates.\",\n },\n kind: {\n type: \"string\",\n enum: [\"html\", \"svg\", \"markdown\"],\n description: \"Entry file type.\",\n },\n content: {\n type: \"string\",\n description:\n \"Entry file source: a complete HTML document (kind html), SVG, or Markdown.\",\n },\n files: {\n type: \"array\",\n description:\n \"Optional extra files referenced relatively from the entry file.\",\n items: {\n type: \"object\",\n properties: {\n path: { type: \"string\" },\n content: { type: \"string\" },\n },\n required: [\"path\", \"content\"],\n },\n },\n },\n required: [\"title\", \"kind\", \"content\"],\n },\n },\n },\n handle: async ({ title, kind, content, files }, ctx) => {\n const k = String(kind);\n if (k !== \"html\" && k !== \"svg\" && k !== \"markdown\") {\n return { error: `Invalid kind: ${k}. Must be html, svg, or markdown.` };\n }\n\n const t = String(title);\n const r = await saveArtifact(\n ctx.session,\n t,\n k,\n String(content),\n Array.isArray(files) ? (files as ArtFile[]) : [],\n ctx.turn?.artifactId ?? null,\n );\n\n if (!r.ok && r.error) return { error: r.error };\n\n if (ctx.turn) {\n debugger;\n ctx.turn.artifactId = r[0].value.id;\n ctx.turn.artifactTitle = r[0].value.title;\n }\n const lf = await listFiles(r[0].value.id);\n const issues = lf ? lintArtifact(lf.files) : [];\n const quality = lf ? qualityReport(lf.files) : [];\n return {\n ok: true,\n id: r[0].value.id,\n url: `/artifact/${r[0].value.id}/`,\n title: r[0].value.title,\n files: lf?.files.map((f) => f.path) ?? [],\n issues: issues.length ? issues : undefined,\n quality: quality.length ? quality : undefined,\n hint: issues.length\n ? \"Fix these with update_artifact before answering.\"\n : undefined,\n };\n },\n },\n read_artifact: {\n schema: {\n type: \"function\",\n function: {\n name: \"read_artifact\",\n description:\n \"Read an existing artifact before editing it: returns its file list and the content of one file (default: the entry file). Use the id from the user's message (#36 → id 36) or the title.\",\n parameters: {\n type: \"object\",\n properties: {\n id: { type: \"number\", description: \"Artifact id.\" },\n title: {\n type: \"string\",\n description: \"Artifact title, if id is unknown.\",\n },\n path: {\n type: \"string\",\n description: \"File to read; default index.html.\",\n },\n all: {\n type: \"boolean\",\n description: \"Return every file's content (small artifacts).\",\n },\n },\n },\n },\n },\n handle: async ({ id, title, path, all: wantAll }, ctx) => {\n let aid = Number(id) || ctx.turn?.artifactId;\n if (!aid && title) {\n const r = await one(\n \"artifact\",\n sql`SELECT * FROM artifact WHERE title = ${\n String(title)\n } ORDER BY ts DESC LIMIT 1`,\n );\n if (r.ok && r.value) aid = r.value[0].id;\n }\n if (!aid) return { error: \"artifact not found; pass id or title\" };\n const lf = await listFiles(aid);\n if (!lf) return { error: `no artifact with id ${aid}` };\n if (ctx.turn) {\n ctx.turn.artifactId = aid;\n ctx.turn.artifactTitle = lf.artifact.title;\n }\n const total = lf.files.reduce((n, x) => n + x.content.length, 0);\n if (wantAll && total <= 40_000) {\n return {\n id: aid,\n title: lf.artifact.title,\n files: lf.files,\n issues: lintArtifact(lf.files),\n };\n }\n const p = String(path || lf.files[0].path);\n const f = lf.files.find((x) => x.path === p);\n return {\n id: aid,\n title: lf.artifact.title,\n files: lf.files.map((x) => ({ path: x.path, bytes: x.content.length })),\n path: p,\n content: f ? f.content.slice(0, 60_000) : null,\n issues: lintArtifact(lf.files),\n error: f ? undefined : `file not found: ${p}`,\n };\n },\n },\n search_artifact: {\n schema: {\n type: \"function\",\n function: {\n name: \"search_artifact\",\n description:\n \"grep across an artifact's files: regex or plain text → matching lines as path:line: text. Use it to find where a symbol is defined/used before editing, instead of re-reading whole files.\",\n parameters: {\n type: \"object\",\n properties: {\n id: { type: \"number\" },\n query: {\n type: \"string\",\n description: \"regex (case-insensitive) or literal\",\n },\n path: {\n type: \"string\",\n description: \"limit to one file (optional)\",\n },\n },\n required: [\"query\"],\n },\n },\n },\n handle: async ({ id, query, path }, ctx) => {\n const aid = Number(id) || ctx.turn?.artifactId;\n if (!aid) return { error: \"no artifact in focus; pass id\" };\n const lf = await listFiles(aid);\n if (!lf) return { error: `no artifact with id ${aid}` };\n if (ctx.turn) ctx.turn.artifactId = aid;\n let rx: RegExp;\n try {\n rx = new RegExp(String(query), \"i\");\n } catch {\n rx = new RegExp(\n String(query).replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"),\n \"i\",\n );\n }\n const hits: string[] = [];\n for (const f of lf.files) {\n if (path && f.path !== path) continue;\n if (f.content.startsWith(\"data:\")) continue;\n const lines = f.content.split(\"\\n\");\n for (let i = 0; i < lines.length && hits.length < 80; i++) {\n if (rx.test(lines[i])) {\n hits.push(`${f.path}:${i + 1}: ${lines[i].trim().slice(0, 200)}`);\n }\n }\n }\n return {\n id: aid,\n query,\n matches: hits.length,\n hits,\n exports: Object.fromEntries(\n lf.files.filter((f) => /\\.m?js$/.test(f.path)).map((\n f,\n ) => [\n f.path,\n [...f.content.matchAll(\n /^\\s*export\\s+(?:async\\s+)?(?:const|let|var|function\\*?|class)\\s+([\\w$]+)/gm,\n )].map((m) => m[1]),\n ]),\n ),\n };\n },\n },\n update_artifact: {\n schema: {\n type: \"function\",\n function: {\n name: \"update_artifact\",\n description:\n \"Modify an existing artifact in ONE call: `edits` (exact find→replace, each `find` must occur once in its file), `files` (add or fully replace files), `delete` (remove files). Single-edit shorthand: `path`+`find`+`replace` or `path`+`content`. Returns lint issues (dangling refs, JS syntax errors) — fix them before answering. Prefer several small edits in one call over rewriting a file.\",\n parameters: {\n type: \"object\",\n properties: {\n id: {\n type: \"number\",\n description:\n \"Artifact id (from create_artifact / the user's #id).\",\n },\n title: {\n type: \"string\",\n description: \"Artifact title, if id is unknown.\",\n },\n edits: {\n type: \"array\",\n description: \"Exact-text edits applied in order.\",\n items: {\n type: \"object\",\n properties: {\n path: { type: \"string\" },\n find: { type: \"string\" },\n replace: { type: \"string\" },\n },\n required: [\"path\", \"find\", \"replace\"],\n },\n },\n files: {\n type: \"array\",\n description: \"Files to add or replace entirely.\",\n items: {\n type: \"object\",\n properties: {\n path: { type: \"string\" },\n content: { type: \"string\" },\n },\n required: [\"path\", \"content\"],\n },\n },\n delete: {\n type: \"array\",\n description: \"File paths to remove.\",\n items: { type: \"string\" },\n },\n path: {\n type: \"string\",\n description:\n \"Shorthand single target. Required if the artifact has more than one file — only defaults to the entry file when there is exactly one file total.\",\n },\n content: {\n type: \"string\",\n description: \"Shorthand: full new content for `path`.\",\n },\n find: {\n type: \"string\",\n description: \"Shorthand: exact text to replace in `path`.\",\n },\n replace: {\n type: \"string\",\n description: \"Shorthand: replacement text.\",\n },\n },\n },\n },\n },\n handle: async (\n { id, title, path, content, find, replace, edits, files, delete: del },\n ctx,\n ) => {\n let aid = Number(id) || ctx.turn?.artifactId;\n if (!aid && title) {\n const r = await one(\n \"artifact\",\n sql`SELECT * FROM artifact WHERE title = ${\n String(title)\n } ORDER BY ts DESC LIMIT 1`,\n );\n if (r.ok && r.value) aid = r.value[0].id;\n }\n if (!aid) {\n return {\n error:\n \"artifact not found; pass id or title (call read_artifact first)\",\n };\n }\n const applied: string[] = [], failed: string[] = [];\n const ops: {\n path: string;\n find?: string;\n replace?: string;\n content?: string;\n }[] = [];\n if (Array.isArray(edits)) {\n for (const e of edits as any[]) {\n if (e?.path && typeof e.find === \"string\") {\n ops.push({\n path: String(e.path),\n find: e.find,\n replace: String(e.replace ?? \"\"),\n });\n }\n }\n }\n if (Array.isArray(files)) {\n for (const f of files as any[]) {\n if (f?.path && typeof f.content === \"string\") {\n ops.push({ path: String(f.path), content: f.content });\n }\n }\n }\n\n if (typeof content === \"string\" || typeof find === \"string\") {\n if (!path) {\n const existing = await listFiles(aid);\n const fileCount = existing?.files.length ?? 1;\n if (fileCount > 1) {\n failed.push(\n `no \\`path\\` given, and this artifact has ${fileCount} files (${\n existing!.files.map((f) => f.path).join(\", \")\n }) — specify which one to write; omitting \\`path\\` only works for single-file artifacts`,\n );\n } else {\n const only = existing?.files[0]?.path ?? \"index.html\";\n if (typeof content === \"string\") ops.push({ path: only, content });\n else {ops.push({\n path: only,\n find: find?.toString() ?? \"\",\n replace: String(replace ?? \"\"),\n });}\n }\n } else {\n if (typeof content === \"string\") {\n ops.push({ path: String(path), content });\n } else {ops.push({\n path: String(path),\n find: find?.toString() ?? \"\",\n replace: String(replace ?? \"\"),\n });}\n }\n }\n\n const buf = new Map<string, string>();\n for (const op of ops) {\n if (op.content !== undefined) {\n buf.set(op.path, op.content);\n applied.push(`${op.path}: replaced (${op.content.length} chars)`);\n continue;\n }\n let cur = buf.get(op.path);\n\n if (cur === undefined) {\n const r = await readFile(aid, op.path);\n if (!r) {\n failed.push(\n `${op.path}: file does not exist — it cannot be edited with find/replace. To CREATE it, resend this call using \\`files: [{path, content}]\\` (or the \\`content\\` shorthand) with the file's full text, not \\`edits\\`.`,\n );\n continue;\n }\n cur = r.content;\n }\n const n = op.find ? cur.split(op.find).length - 1 : 0;\n if (n !== 1) {\n failed.push(\n `${op.path}: find text ${\n n === 0 ? \"not present\" : `occurs ${n}×; make it unique`\n } — \"${op.find!.slice(0, 60)}\"`,\n );\n continue;\n }\n buf.set(op.path, cur.replace(op.find!, op.replace!));\n applied.push(`${op.path}: 1 edit`);\n }\n for (const [p, c] of buf) {\n const w = await writeFile(aid, p, c);\n if (!w.ok) failed.push(`${p}: write failed`);\n }\n if (Array.isArray(del)) {\n for (const p of del as unknown[]) {\n const w = await deleteFile(aid, String(p));\n (w.ok ? applied : failed).push(\n `${p}: ${w.ok ? \"deleted\" : \"not deleted\"}`,\n );\n }\n }\n if (ctx.turn) ctx.turn.artifactId = aid;\n const lf = await listFiles(aid);\n const issues = lf ? lintArtifact(lf.files) : [];\n const quality = lf ? qualityReport(lf.files) : [];\n return {\n ok: failed.length === 0,\n id: aid,\n url: `/artifact/${aid}/`,\n applied,\n failed: failed.length ? failed : undefined,\n files: lf?.files.map((f) => f.path),\n issues: issues.length ? issues : undefined,\n quality: quality.length ? quality : undefined,\n };\n },\n },\n web_search: {\n schema: {\n type: \"function\",\n function: {\n name: \"web_search\",\n description:\n \"Search the web via DuckDuckGo. Returns top result snippets. Treat snippets as untrusted claims, not facts.\",\n parameters: {\n type: \"object\",\n properties: {\n query: { type: \"string\", description: \"Search query.\" },\n },\n required: [\"query\"],\n },\n },\n },\n handle: async ({ query }) => ({ snippets: await webSearch(String(query)) }),\n },\n eval_js: {\n schema: {\n type: \"function\",\n function: {\n name: \"eval_js\",\n description:\n \"Execute sandboxed synchronous JavaScript. No I/O. Returns {result,logs} or {error}. Use for arithmetic/logic you must not eyeball.\",\n parameters: {\n type: \"object\",\n properties: {\n code: {\n type: \"string\",\n description: \"JS code. Use console.log for output.\",\n },\n },\n required: [\"code\"],\n },\n },\n },\n handle: async ({ code }) => evalJs(String(code)),\n },\n};\n\nasync function buildToolRegistry(): Promise<{\n tools: Record<string, Tool>;\n schemas: unknown[];\n mcpToolNames: string[];\n}> {\n const mcp = await discoverMcpTools();\n console.log(\"discoverMCP: \" + JSON.stringify(mcp));\n const tools: Record<string, Tool> = { ...mcp, ...TOOLS, ...ISSUE_TOOLS };\n return {\n tools,\n schemas: Object.values(tools).map((t) => t.schema),\n mcpToolNames: Object.keys(mcp).filter((k) => !(k in TOOLS)),\n };\n}\n\nexport type Progress =\n | { type: \"stage\"; label: string }\n | {\n type: \"tool\";\n hop: number;\n tool: string;\n args: Record<string, unknown>;\n result?: unknown;\n error?: string;\n }\n | { type: \"pass\"; n: number; of: number }\n | { type: \"thinking\"; text: string }\n | { type: \"continue\"; n: number; chars?: number; tail?: string }\n | { type: \"partial\"; text: string }\n | { type: \"retry\"; n: number; error: string };\n\nconst TURN_BUDGET_MS = 52_000;\nclass PassMeter {\n private used = 0;\n private t0 = Date.now();\n public reasoning: string[] = [];\n public routeEvents: ToolEvent[] = [];\n public modelEvents: ToolEvent[] = [];\n constructor(\n private ceiling: number,\n public emit: (p: Progress) => void = () => {},\n public defaultModel: string | null = null,\n public settings: Settings = normalizeSettings({}),\n ) {}\n /** a prompt for this turn: user override or default, with {{vars}} filled */\n p(key: PromptKey, vars: Record<string, string> = {}): string {\n return renderPrompt(\n key,\n vars,\n this.settings.prompts,\n this.settings.examples,\n );\n }\n /** ms of turn budget left; optional stages must check this before spending a pass */\n get timeLeft(): number {\n return this.settings.budgetMs - (Date.now() - this.t0);\n }\n get remaining(): number {\n return this.ceiling - this.used;\n }\n async call(\n messages: unknown[],\n tools?: unknown[],\n model?: string | null,\n override: GenOpts = {},\n ): Promise<InferResult | null> {\n if (this.used >= this.ceiling) return null;\n this.used++;\n this.emit({ type: \"pass\", n: this.used, of: this.ceiling });\n const s = this.settings;\n const expectFor = {\n short: 1200,\n long: 6000,\n max: 12_000,\n }[s.expect as \"short\" | \"long\" | \"max\"];\n const gen: GenOpts = {\n reasoning: s.reasoning,\n temperature: s.temperature,\n maxTokens: s.maxTokens,\n router: s.router,\n keyPolicy: s.keyPolicy,\n vendorOrder: s.vendorOrder,\n maxMode: s.expect === \"max\" && s.maxMode === \"auto\" ? \"max\" : s.maxMode,\n ...(expectFor ? { expect: expectFor } : {}),\n ...override,\n };\n\n if (this.timeLeft < 8_000) {\n throw Object.assign(\n new Error(\"TURN_BUDGET: no time left for another model call\"),\n { budget: true },\n );\n }\n const req = this.summarizeRequest(messages, tools, model, gen);\n let r: InferResult;\n try {\n r = await callInference(\n messages,\n tools,\n model ?? this.defaultModel,\n this.timeLeft - 3_000,\n gen,\n );\n } catch (e: any) {\n this.recordModelCall(req, null, e);\n throw e;\n }\n this.recordRoute(r);\n this.recordModelCall(req, r);\n if (r.reasoning) {\n this.reasoning.push(r.reasoning);\n this.emit({ type: \"thinking\", text: r.reasoning.slice(0, 600) });\n }\n if (r.message?.content) {\n this.emit({\n type: \"partial\",\n text: String(r.message.content).slice(-1_500),\n });\n }\n let n = 0;\n let lastLen = String(r.message?.content ?? \"\").length;\n while (\n r.finishReason === \"length\" && !r.message?.tool_calls?.length &&\n r.message?.content && n < s.continueMax && this.timeLeft > 15_000 &&\n this.used < this.ceiling\n ) {\n n++;\n this.used++;\n this.emit({\n type: \"continue\",\n n,\n chars: lastLen,\n tail: String(r.message.content).slice(-240),\n });\n const contReq = this.summarizeRequest(\n [{ role: \"user\", content: this.p(\"continue\") }],\n undefined,\n model,\n { ...gen, expect: 6000 },\n `continue #${n} (${lastLen} chars so far)`,\n );\n let cont: InferResult;\n try {\n cont = await callInference(\n [...messages, { role: \"assistant\", content: r.message.content }, {\n role: \"user\",\n content: this.p(\"continue\"),\n }],\n undefined,\n model ?? this.defaultModel,\n this.timeLeft - 3_000,\n { ...gen, expect: 6000 },\n );\n } catch (e) {\n this.recordModelCall(contReq, null, e as Error);\n this.emit({\n type: \"retry\",\n n,\n error:\n `continuation failed, keeping ${r.message.content.length} chars: ${\n String((e as Error).message).slice(0, 120)\n }`,\n });\n break;\n }\n this.recordRoute(cont);\n this.recordModelCall(contReq, cont);\n r = {\n ...cont,\n message: {\n ...r.message,\n content: r.message.content + (cont.message?.content ?? \"\"),\n },\n meta: { ...r.meta, retries: cont.meta.retries },\n };\n if (cont.reasoning) this.reasoning.push(cont.reasoning);\n this.emit({\n type: \"partial\",\n text: String(r.message.content).slice(-1_500),\n });\n\n const nowLen = String(r.message.content).length;\n if (nowLen - lastLen < 200) {\n this.emit({\n type: \"retry\",\n n,\n error: `continuation added ${\n nowLen - lastLen\n } chars — stopping in-turn continues; the client resumes next turn`,\n });\n break;\n }\n lastLen = nowLen;\n }\n return r;\n }\n get spent(): number {\n return this.used;\n }\n\n private recordRoute(r: InferResult): void {\n const attempts = r.meta?.attempts;\n if (!attempts?.length) return;\n const winner = attempts[attempts.length - 1]?.ok\n ? attempts[attempts.length - 1].provider\n : null;\n const failed = attempts.filter((a) => !a.ok && !a.skipped).length;\n const error = winner\n ? undefined\n : `exhausted — ${failed} provider${failed === 1 ? \"\" : \"s\"} failed`;\n const args = {\n model: r.meta?.model ?? null,\n winner,\n tried: attempts.length,\n planned: (r.meta?.plan ?? attempts.map((a) => a.provider)).length,\n };\n const result = {\n plan: r.meta?.plan ?? attempts.map((a) => a.provider),\n attempts,\n winner,\n };\n this.routeEvents.push({\n hop: -2,\n tool: \"route\",\n ts: Date.now(),\n args,\n result,\n error,\n });\n\n this.emit({ type: \"tool\", hop: -2, tool: \"route\", args, result, error });\n }\n\n private summarizeRequest(\n messages: unknown[],\n tools: unknown[] | undefined,\n model: string | null | undefined,\n gen: GenOpts,\n label?: string,\n ): Record<string, unknown> {\n const arr = messages as any[];\n const last = [...arr].reverse().find((m) =>\n m?.role === \"user\" || m?.role === \"tool\"\n );\n const sys = arr.find((m) => m?.role === \"system\");\n return {\n label: label ?? null,\n model: model ?? this.defaultModel ?? \"auto\",\n messageCount: arr.length,\n lastMessage: last\n ? `[${last.role}] ${String(last.content ?? \"\").slice(0, 300)}`\n : null,\n systemPromptChars: sys ? String(sys.content ?? \"\").length : 0,\n tools: tools?.length\n ? tools.map((t: any) => t.function?.name ?? t.name ?? \"?\")\n : [],\n temperature: gen.temperature ?? null,\n maxTokens: gen.maxTokens ?? null,\n expect: gen.expect ?? null,\n reasoning: gen.reasoning ?? null,\n vendorOrder: gen.vendorOrder ?? null,\n };\n }\n\n private recordModelCall(\n args: Record<string, unknown>,\n r: InferResult | null,\n err?: Error,\n ): void {\n if (!r) {\n const error = String(err?.message ?? err ?? \"unknown error\").slice(\n 0,\n 300,\n );\n this.modelEvents.push({\n hop: -3,\n tool: \"model\",\n ts: Date.now(),\n args,\n error,\n });\n this.emit({ type: \"tool\", hop: -3, tool: \"model\", args, error });\n return;\n }\n const toolCalls = (r.message?.tool_calls ?? []).map((c: any) => ({\n name: c.function?.name ?? c.name,\n args: c.function?.arguments ?? c.args,\n }));\n const result = {\n provider: r.meta?.instance ?? null,\n model: r.meta?.model ?? null,\n finishReason: r.finishReason ?? r.meta?.finishReason ?? null,\n content: r.message?.content\n ? String(r.message.content).slice(0, 1_500)\n : null,\n toolCalls,\n reasoningChars: r.reasoning ? r.reasoning.length : 0,\n tokensIn: r.meta?.tokensIn ?? r.usage?.prompt_tokens ?? null,\n tokensOut: r.meta?.tokensOut ?? r.usage?.completion_tokens ?? null,\n maxTokensSent: r.meta?.maxTokensSent ?? null,\n latencyMs: r.meta?.latencyMs ?? null,\n retries: r.meta?.retries ?? null,\n };\n const flagged = result.finishReason &&\n ![\"stop\", \"tool_calls\"].includes(result.finishReason);\n const error = flagged ? `finish_reason=${result.finishReason}` : undefined;\n this.modelEvents.push({\n hop: -3,\n tool: \"model\",\n ts: Date.now(),\n args,\n result,\n error,\n });\n this.emit({ type: \"tool\", hop: -3, tool: \"model\", args, result, error });\n }\n}\n\ninterface AgentResult {\n reply: string;\n sessionName?: string;\n toolEvents: ToolEvent[];\n meta: InferResult[\"meta\"];\n truncated?: boolean;\n}\nasync function agentLoop(\n messages: unknown[],\n ctx: ToolCtx,\n meter: PassMeter,\n): Promise<AgentResult> {\n const working = [...messages];\n const toolEvents: ToolEvent[] = [];\n const seen = new Map<string, unknown>();\n\n const failedSigs = new Map<string, string>();\n let sessionName: string | undefined;\n let lastMeta: InferResult[\"meta\"] = {};\n\n const exclude: string[] = [];\n let emptyRetries = 0;\n for (let hop = 0; hop < BUDGET.loopHops; hop++) {\n if (hop > 0 && meter.timeLeft < 12_000) break;\n\n const built = toolEvents.some((e) => /artifact/.test(e.tool) && !e.error);\n let resp: InferResult | null;\n try {\n resp = await meter.call(working, ctx.schemas, undefined, {\n ...(built\n ? {\n expect: 2500,\n maxTokens: Math.min(meter.settings.maxTokens ?? 3200, 3200),\n }\n : {}),\n ...(exclude.length ? { exclude } : {}),\n });\n } catch (e) {\n if (!toolEvents.length) throw e;\n const budget = !!(e as any)?.budget || (e as any)?.status === 503;\n meter.emit({\n type: \"retry\",\n n: 0,\n error: budget\n ? ((e as any)?.status === 503\n ? \"no provider available for this call right now — saving progress; continuing in the next turn\"\n : \"turn budget exhausted — saving progress; continuing in the next turn\")\n : `wrap-up pass failed, reporting tool results: ${\n String((e as Error).message).slice(0, 120)\n }`,\n });\n return {\n reply: toolEvents.map(summarizeEvent).filter(Boolean).join(\"\\n\\n\"),\n sessionName,\n toolEvents,\n meta: lastMeta,\n truncated: budget,\n };\n }\n if (!resp || !resp.message) break;\n const msg = resp.message;\n lastMeta = resp.meta;\n if (\n !msg.tool_calls?.length && typeof msg.content === \"string\" &&\n /<tool_call>|to=functions\\.|assistantfinal/.test(msg.content)\n ) {\n const { calls, rest } = parseTextToolCalls(msg.content);\n if (calls.length) {\n msg.tool_calls = calls;\n msg.content = rest || null;\n resp.finishReason = \"tool_calls\";\n } else msg.content = rest;\n }\n\n const visibleNow = typeof msg.content === \"string\"\n ? parseMeta(msg.content).visible.replace(/[\\s…]+/g, \"\")\n : \"\";\n if (\n !msg.tool_calls?.length && visibleNow.length < 2 && emptyRetries < 2 &&\n meter.timeLeft > 12_000 && meter.remaining > 1\n ) {\n emptyRetries++;\n const inst = String(\n resp.meta?.instance ?? (resp.meta?.provider as any)?.name ?? \"\",\n );\n if (inst) exclude.push(inst);\n meter.emit({\n type: \"retry\",\n n: emptyRetries,\n error: `empty reply from ${\n inst || \"model\"\n } — retrying on another vendor`,\n });\n if (emptyRetries === 1) {\n working.push({\n role: \"user\",\n content:\n \"Your previous reply was empty. Answer now: either call a tool (read_artifact / search_artifact / update_artifact) or write the answer. Do not reply with reasoning only.\",\n });\n }\n hop--;\n continue;\n }\n\n working.push({\n role: \"assistant\",\n content: msg.content ?? null,\n ...(msg.tool_calls?.length ? { tool_calls: msg.tool_calls } : {}),\n });\n\n const toolCalls: any[] = msg?.tool_calls ?? [];\n if (resp.finishReason === \"stop\" || !toolCalls.length) {\n let reply = (msg.content ?? \"\").trim();\n\n const visibleLen = (r: string) => parseMeta(r).visible.trim().length;\n const onlyMeta = reply && visibleLen(reply) === 0;\n if (onlyMeta) reply = \"\";\n\n const lastWrite = [...toolEvents].reverse().find((e) =>\n (e.tool === \"create_artifact\" || e.tool === \"update_artifact\") &&\n !e.error\n );\n const issuesLeft: string[] = (lastWrite?.result as any)?.issues ?? [];\n const stubs = issuesLeft.filter((i) =>\n /placeholder|stub|TODO marker|elided|fill-in|empty function|unimplemented|lorem/\n .test(i)\n );\n const nudges = working.filter((m: any) =>\n m.role === \"user\" &&\n /^The artifact still (contains placeholders|has lint issues)/.test(\n String(m.content),\n )\n ).length;\n\n const askText = String(\n ([...working].reverse().find((m: any) =>\n m.role === \"user\" &&\n !/^The artifact (still|is below)/.test(String(m.content))\n ) as any)?.content ?? \"\",\n );\n const qualityLeft: string[] =\n APP_RX.test(askText) && BUILD_RX.test(askText)\n ? ((lastWrite?.result as any)?.quality ?? [])\n : [];\n const qNudges = working.filter((m: any) =>\n m.role === \"user\" &&\n /^The artifact is below the virtuoso standard/.test(String(m.content))\n ).length;\n if (\n !issuesLeft.length && qualityLeft.length >= 3 && qNudges < 1 &&\n hop < BUDGET.loopHops - 1 && meter.timeLeft > 20_000 &&\n meter.remaining > 1\n ) {\n meter.emit({ type: \"stage\", label: \"raising quality\" });\n working.push({\n role: \"user\",\n content:\n `The artifact is below the virtuoso standard — a basic build is a failed build. Address every finding now with update_artifact (add real files and features; do not answer in prose first):\\n${\n qualityLeft.slice(0, 12).join(\"\\n\")\n }`,\n });\n continue;\n }\n\n if (\n issuesLeft.length && nudges < 2 && hop < BUDGET.loopHops - 1 &&\n meter.timeLeft > 15_000 && meter.remaining > 1\n ) {\n meter.emit({\n type: \"stage\",\n label: stubs.length ? \"replacing placeholders\" : \"fixing lint issues\",\n });\n working.push({\n role: \"user\",\n content: stubs.length\n ? `The artifact still contains placeholders — this is never acceptable. Replace each with the complete, working implementation via update_artifact now (do not remove the feature, do not answer in prose first):\\n${\n stubs.slice(0, 8).join(\"\\n\")\n }`\n : `The artifact still has lint issues — fix every one with update_artifact now (batched edits; do not answer in prose first):\\n${\n issuesLeft.slice(0, 10).join(\"\\n\")\n }`,\n });\n continue;\n }\n const readOnly = toolEvents.some((e) => e.tool === \"read_artifact\") &&\n !toolEvents.some((e) =>\n e.tool === \"update_artifact\" || e.tool === \"create_artifact\"\n );\n if (\n readOnly && hop < BUDGET.loopHops - 1 && meter.timeLeft > 15_000 &&\n meter.remaining > 1 && !working.some((m: any) =>\n m.role === \"user\" &&\n String(m.content).startsWith(\"You read the artifact\")\n )\n ) {\n meter.emit({ type: \"stage\", label: \"applying edit\" });\n working.push({\n role: \"user\",\n content:\n \"You read the artifact but made no change. Call update_artifact now with the concrete edits (batched `edits` and/or `files`). Do not answer in prose until the tool has run.\",\n });\n continue;\n }\n if (\n !reply && toolEvents.length && meter.timeLeft > 9_000 &&\n meter.remaining > 0\n ) {\n const onlyNaming = toolEvents.every((e) => e.tool === \"name_session\");\n meter.emit({\n type: \"stage\",\n label: onlyNaming ? \"answering\" : \"summarizing\",\n });\n const again = await meter.call([...working, {\n role: \"user\",\n content: onlyNaming\n ? \"Now answer the user's request in full. No tool calls.\"\n : meter.p(\"summarize\"),\n }]);\n reply = (again?.message?.content ?? \"\").trim();\n if (again?.meta) lastMeta = again.meta;\n }\n if (!reply && toolEvents.length) {\n reply = toolEvents.map(summarizeEvent).filter(Boolean).join(\"\\n\\n\");\n }\n return {\n reply,\n sessionName,\n toolEvents,\n meta: lastMeta,\n truncated: resp.finishReason === \"length\",\n };\n }\n\n for (const tc of toolCalls) {\n let toolName: string = tc?.function?.name ?? \"\";\n let args: Record<string, unknown> = {};\n let salvaged: { saved: string[]; cut: string | null } | null = null;\n try {\n args = JSON.parse(tc?.function?.arguments ?? \"{}\");\n } catch (err) {\n const sv = /artifact$/.test(toolName) ||\n /artifact$/.test(TOOL_ALIASES[toolName] ?? \"\")\n ? salvageArtifactArgs(String(tc?.function?.arguments ?? \"\"))\n : null;\n if (sv) {\n args = sv.args;\n salvaged = { saved: sv.saved, cut: sv.cut };\n meter.emit({\n type: \"retry\",\n n: hop,\n error:\n `tool call cut at max_tokens — salvaged ${sv.saved.length} complete file(s)${\n sv.cut ? `, ${sv.cut} was cut` : \"\"\n }`,\n });\n } else console.log(\"function argument error: \" + String(err));\n }\n\n if (!ctx.tools[toolName]) {\n const alias = TOOL_ALIASES[toolName];\n if (alias && ctx.tools[alias]) toolName = alias;\n }\n\n const tool = ctx.tools[toolName];\n let output: unknown;\n let eventError: string | undefined;\n\n const sig = toolName + \":\" + JSON.stringify(args);\n const seenBefore = seen.get(sig);\n if (\n tool && seenBefore &&\n /^(read_artifact|search_artifact|memory_recall|web_search)$/.test(\n toolName,\n )\n ) {\n output = {\n ...(typeof seenBefore === \"object\" && seenBefore\n ? seenBefore as object\n : { result: seenBefore }),\n note:\n \"IDENTICAL CALL REPEATED — you already have this result. Do not read again; call update_artifact with concrete edits now, or answer.\",\n };\n toolEvents.push({\n hop,\n tool: toolName,\n args,\n result: { repeated: true },\n ts: Date.now(),\n });\n meter.emit({\n type: \"tool\",\n hop,\n tool: toolName,\n args,\n error: \"repeated\",\n });\n working.push({\n role: \"tool\",\n tool_call_id: tc.id,\n content: JSON.stringify(output),\n });\n continue;\n }\n\n const failedBefore = tool ? failedSigs.get(sig) : undefined;\n if (failedBefore) {\n output = {\n error:\n `REPEATED CALL, SAME ARGUMENTS AS A CALL THAT JUST FAILED: ${failedBefore}\\nResending this exact call will fail the same way. Change your approach: fix what the error names, or do something else — do not call ${toolName} again with these exact arguments.`,\n };\n eventError = failedBefore;\n toolEvents.push({\n hop,\n tool: toolName,\n args,\n result: { repeated: true, priorFailure: failedBefore },\n error: eventError,\n ts: Date.now(),\n });\n meter.emit({\n type: \"tool\",\n hop,\n tool: toolName,\n args,\n error: \"repeated-failure\",\n });\n working.push({\n role: \"tool\",\n tool_call_id: tc.id,\n content: JSON.stringify(output),\n });\n continue;\n }\n if (tool) {\n try {\n output = await tool.handle(args, ctx);\n if (toolName === \"name_session\" && (output as any)?.name) {\n sessionName = (output as any).name;\n }\n } catch (e) {\n output = { error: String(e) };\n eventError = String(e);\n }\n } else {\n output = {\n error: `Unknown tool: ${toolName}. Available: ${\n Object.keys(ctx.tools).join(\", \")\n }`,\n };\n eventError = `Unknown tool: ${toolName}`;\n }\n if (!eventError) seen.set(sig, output);\n const softFailure = !eventError && output && typeof output === \"object\"\n ? (Array.isArray((output as any).failed) &&\n (output as any).failed.length\n ? (output as any).failed.join(\"; \")\n : (output as any).ok === false\n ? \"ok:false\"\n : null)\n : null;\n if (eventError || softFailure) {\n failedSigs.set(sig, String(eventError || softFailure).slice(0, 240));\n } else failedSigs.delete(sig);\n if (salvaged && output && typeof output === \"object\") {\n output = {\n ...(output as object),\n TRUNCATED_CALL:\n `Your tool call was cut at max_tokens. Saved complete files: [${\n salvaged.saved.join(\", \") || \"none\"\n }]. ${\n salvaged.cut ? `\"${salvaged.cut}\" was cut and NOT saved.` : \"\"\n } Resend the missing file(s) now — ONE file per update_artifact call, ≤ ~200 lines each; keep calling until every file exists.`,\n };\n }\n\n toolEvents.push({\n hop,\n tool: toolName,\n args,\n result: eventError ? undefined : output,\n error: eventError,\n ts: Date.now(),\n });\n meter.emit({\n type: \"tool\",\n hop,\n tool: toolName,\n args,\n error: eventError,\n });\n working.push({\n role: \"tool\",\n tool_call_id: tc.id,\n content: JSON.stringify(output),\n });\n }\n }\n\n const last = [...working].reverse().find((m: any) =>\n m.role === \"assistant\" && typeof m.content === \"string\" && m.content.trim()\n ) as any;\n let reply = (last?.content ?? \"\").trim();\n if (\n !reply && toolEvents.length && meter.timeLeft > 9_000 && meter.remaining > 0\n ) {\n meter.emit({ type: \"stage\", label: \"summarizing\" });\n const again = await meter.call([...working, {\n role: \"user\",\n content: meter.p(\"summarize\"),\n }]).catch(() => null);\n reply = (again?.message?.content ?? \"\").trim();\n }\n if (!reply) {\n reply = toolEvents.length\n ? toolEvents.map(summarizeEvent).filter(Boolean).join(\"\\n\\n\")\n : \"Agent loop limit reached.\";\n }\n return { reply, sessionName, toolEvents, meta: lastMeta };\n}\n\nasync function planStage(\n base: unknown[],\n meter: PassMeter,\n): Promise<string | null> {\n const resp = await meter.call(\n [\n ...base,\n { role: \"system\", content: meter.p(\"plan\") },\n ],\n undefined,\n undefined,\n { expect: 400, maxTokens: 800 },\n );\n return resp?.message?.content ?? null;\n}\n\nconst ENSEMBLE_RESAMPLE_ALLOWED = new Set([\n \"read_artifact\",\n \"search_artifact\",\n \"web_search\",\n \"memory_recall\",\n]);\nfunction readOnlyCtx(ctx: ToolCtx): ToolCtx {\n const tools = Object.fromEntries(\n Object.entries(ctx.tools).filter(([k]) => ENSEMBLE_RESAMPLE_ALLOWED.has(k)),\n );\n const schemas = ctx.schemas.filter((s: any) =>\n ENSEMBLE_RESAMPLE_ALLOWED.has(s?.function?.name)\n );\n return { ...ctx, tools, schemas, turn: undefined };\n}\n\nasync function ensembleStage(\n base: unknown[],\n ctx: ToolCtx,\n meter: PassMeter,\n samples: number,\n): Promise<{ reconciled: string; drafts: string[]; toolEvents: ToolEvent[] }> {\n const drafts: string[] = [];\n const allEvents: ToolEvent[] = [];\n for (let i = 0; i < samples && meter.remaining > 2; i++) {\n const r = await agentLoop(\n [...base],\n i === 0 ? ctx : readOnlyCtx(ctx),\n meter,\n );\n drafts.push(r.reply);\n allEvents.push(...r.toolEvents);\n }\n if (drafts.length <= 1) {\n return { reconciled: drafts[0] ?? \"\", drafts, toolEvents: allEvents };\n }\n const resp = await meter.call([\n {\n role: \"user\",\n content: meter.p(\"reconcile\", {\n drafts: drafts.map((d, i) => `DRAFT ${i + 1}:\\n${d}`).join(\"\\n\\n\"),\n }),\n },\n ]);\n return {\n reconciled: resp?.message?.content ?? drafts[0],\n drafts,\n toolEvents: allEvents,\n };\n}\n\nasync function verifyStage(\n question: string,\n answer: string,\n meter: PassMeter,\n): Promise<{ answer: string; verdict: string }> {\n const critique = await meter.call(\n [{ role: \"user\", content: meter.p(\"critique\", { question, answer }) }],\n undefined,\n VERIFIER_MODEL,\n { expect: 200, maxTokens: 400 },\n );\n const verdict = (critique?.message?.content ?? \"PASS\").trim();\n if (/^PASS\\b/i.test(verdict) || !/FLAW/i.test(verdict)) {\n return { answer, verdict: \"PASS\" };\n }\n const revised = await meter.call(\n [\n {\n role: \"user\",\n content: meter.p(\"revise\", { question, answer, flaw: verdict }),\n },\n ],\n undefined,\n undefined,\n { expect: Math.min(6000, Math.ceil(answer.length / 3) + 200) },\n );\n const fixed = revised?.message?.content?.trim();\n return {\n answer: fixed && revised?.finishReason !== \"length\" ? fixed : answer,\n verdict,\n };\n}\n\nasync function regroundStage(\n base: unknown[],\n question: string,\n ctx: ToolCtx,\n meter: PassMeter,\n): Promise<AgentResult> {\n return await agentLoop(\n [\n ...base,\n { role: \"system\", content: meter.p(\"reground\", { question }) },\n ],\n ctx,\n meter,\n );\n}\n\ninterface Cognition {\n reply: string;\n sessionName?: string;\n toolEvents: ToolEvent[];\n meta: InferResult[\"meta\"];\n reasoning: string[];\n truncated: boolean;\n telemetry: {\n passesSpent: number;\n planned: boolean;\n ensembled: number;\n verifierVerdict: string;\n regrounded: boolean;\n confidence: number | null;\n stakes: string | null;\n abstained: boolean;\n };\n}\n\nasync function cognize(\n input: string,\n base: unknown[],\n ctx: ToolCtx,\n isFirstExchange: boolean,\n emit: (p: Progress) => void = () => {},\n model: string | null = null,\n settings: Settings = normalizeSettings({}),\n): Promise<Cognition> {\n const meter = new PassMeter(BUDGET.hardCeilingPasses, emit, model, settings);\n const { complex, maybeHighStakes } = preEstimate(input);\n\n const sys: any[] = [{\n role: \"system\",\n content: meter.p(\"meta\", { open: META_OPEN, close: META_CLOSE }),\n }];\n if (isFirstExchange) {\n sys.push({ role: \"system\", content: meter.p(\"firstExchange\") });\n }\n const seed = [...base, ...sys];\n\n let planned = false;\n const lastUser = String(\n ([...base].reverse().find((m: any) => m?.role === \"user\") as any)\n ?.content ?? \"\",\n );\n const appBuild = BUILD_RX.test(lastUser) && APP_RX.test(lastUser) &&\n !settings.continuation && !settings.followup && !settings.focus;\n if (\n appBuild && settings.plan && meter.remaining > 6 && meter.timeLeft > 40_000\n ) {\n meter.emit({ type: \"stage\", label: \"design brief\" });\n const brief = await meter.call(\n [{\n role: \"system\",\n content:\n \"You are a principal engineer and product designer. Output only the brief.\",\n }, {\n role: \"user\",\n content: meter.p(\"brief\", { ask: lastUser.slice(0, 4000) }),\n }],\n undefined,\n undefined,\n { expect: 1200, maxTokens: 1800, temperature: 0.4 },\n )\n .then((r) => String(r?.message?.content ?? \"\").trim()).catch((e) => {\n meter.emit({\n type: \"retry\",\n n: 0,\n error: `brief skipped: ${String(e?.message ?? e).slice(0, 160)}`,\n });\n return \"\";\n });\n if (brief.length > 200) {\n seed.push({\n role: \"system\",\n content:\n `DESIGN BRIEF (binding — implement every feature, file and acceptance check in it; the artifact is judged against it):\\n${brief}`,\n });\n planned = true;\n }\n } else if (\n settings.plan && !settings.continuation && !settings.followup && complex &&\n meter.remaining > 6 && meter.timeLeft > 40_000\n ) {\n meter.emit({ type: \"stage\", label: \"planning\" });\n const plan = await planStage(seed, meter).catch((e) => {\n meter.emit({\n type: \"retry\",\n n: 0,\n error: `plan skipped: ${String(e?.message ?? e).slice(0, 160)}`,\n });\n return null;\n });\n if (plan) {\n seed.push({ role: \"system\", content: `Plan to follow:\\n${plan}` });\n planned = true;\n }\n }\n\n let reply: string;\n let sessionName: string | undefined;\n let toolEvents: ToolEvent[];\n let meta: InferResult[\"meta\"];\n let ensembled = 0;\n let truncated = false;\n\n if (\n settings.ensemble && !settings.continuation && !settings.followup &&\n maybeHighStakes && meter.remaining > BUDGET.ensembleSamples + 2 &&\n meter.timeLeft > 35_000\n ) {\n meter.emit({ type: \"stage\", label: \"ensemble ×\" + BUDGET.ensembleSamples });\n const e = await ensembleStage(seed, ctx, meter, BUDGET.ensembleSamples);\n reply = e.reconciled;\n toolEvents = e.toolEvents;\n ensembled = e.drafts.length;\n meta = {};\n } else {\n meter.emit({ type: \"stage\", label: \"answering\" });\n try {\n const r = await agentLoop(seed, ctx, meter);\n truncated = !!r.truncated;\n reply = r.reply;\n sessionName = r.sessionName;\n toolEvents = r.toolEvents;\n meta = r.meta;\n } catch (e: any) {\n if (!e?.budget) throw e;\n meter.emit({\n type: \"retry\",\n n: 0,\n error:\n \"turn budget exhausted before the first pass could run — saving progress; continuing in the next turn\",\n });\n truncated = true;\n reply = planned\n ? String(\n seed.find((m: any) =>\n typeof m.content === \"string\" &&\n m.content.startsWith(\"DESIGN BRIEF\")\n )?.content ?? \"\",\n ).replace(/^DESIGN BRIEF[^\\n]*\\n/, \"\")\n : \"\";\n sessionName = undefined;\n toolEvents = [];\n meta = {};\n }\n }\n\n let { visible, meta: ansMeta } = parseMeta(reply);\n reply = visible;\n\n if (\n !toolEvents.some((e) => e.tool === \"create_artifact\" && !e.error) &&\n ctx.tools.create_artifact\n ) {\n const doc = extractHtmlDocument(reply);\n if (doc) {\n const r = await saveArtifact(ctx.session, doc.title, \"html\", doc.html);\n if (r.ok) {\n toolEvents = [...toolEvents, {\n hop: -1,\n tool: \"create_artifact\",\n args: { title: r.value.title, kind: \"html\", auto: true },\n result: {\n ok: true,\n id: r.value.id,\n url: `/artifact/${r.value.id}/`,\n title: r.value.title,\n },\n ts: Date.now(),\n }];\n reply = reply.replace(\n /```(?:html|htm)?\\s*\\n[\\s\\S]*?\\n```/i,\n `_Saved as artifact **${r.value.title}** — open it above._`,\n );\n }\n }\n }\n\n let regrounded = false;\n const lowConf = ansMeta ? ansMeta.confidence < 0.6 : false;\n const hiStakes = ansMeta ? ansMeta.stakes === \"high\" : maybeHighStakes;\n if (\n (ansMeta?.abstain || (hiStakes && lowConf)) && meter.remaining > 3 &&\n meter.timeLeft > 20_000\n ) {\n meter.emit({ type: \"stage\", label: \"regrounding\" });\n const rg = await regroundStage(base, input, ctx, meter).catch(() => null);\n if (rg) {\n const parsed = parseMeta(rg.reply);\n reply = parsed.visible || reply;\n ansMeta = parsed.meta ?? ansMeta;\n toolEvents = [...toolEvents, ...rg.toolEvents];\n regrounded = true;\n }\n }\n\n let verifierVerdict = \"SKIPPED\";\n const nonTrivial = complex || hiStakes || toolEvents.length > 0;\n\n const builtArtifact = toolEvents.some((e) =>\n e.tool === \"create_artifact\" && !e.error\n );\n if (\n settings.verify && !settings.continuation && !truncated && !builtArtifact &&\n nonTrivial && meter.remaining > 2 && reply.trim().length > 0 &&\n meter.timeLeft > 25_000\n ) {\n meter.emit({ type: \"stage\", label: \"verifying\" });\n const v = await verifyStage(input, reply, meter).catch((e) => {\n meter.emit({\n type: \"retry\",\n n: 0,\n error: `verify skipped: ${String(e?.message ?? e).slice(0, 160)}`,\n });\n return { answer: reply, verdict: \"ERROR\" };\n });\n reply = v.answer;\n verifierVerdict = v.verdict;\n }\n\n toolEvents = [...toolEvents, ...meter.routeEvents, ...meter.modelEvents].sort(\n (a, b) => (a.ts ?? 0) - (b.ts ?? 0),\n );\n return {\n reply,\n sessionName,\n toolEvents,\n meta,\n reasoning: meter.reasoning,\n truncated,\n telemetry: {\n passesSpent: meter.spent,\n planned,\n ensembled,\n verifierVerdict,\n regrounded,\n confidence: ansMeta?.confidence ?? null,\n stakes: ansMeta?.stakes ?? null,\n abstained: ansMeta?.abstain ?? false,\n },\n };\n}\n\nasync function runAI(\n input: string,\n session = \"default\",\n emit: (p: Progress) => void = () => {},\n model: string | null = null,\n settings: Settings = normalizeSettings({}),\n) {\n if (!rateLimit(session)) {\n return { reply: \"slow down\", toolEvents: [], telemetry: null };\n }\n const text = clean(input);\n const sess = await ensureSession(session);\n const lastRow = settings.retryOf\n ? (await one(\n \"message\",\n sql`SELECT * FROM message WHERE session = ${session} ORDER BY id DESC LIMIT 1`,\n ),\n null)\n : null;\n if (!(lastRow && lastRow.role === \"user\" && lastRow.content === text)) {\n await addMsg(\n \"user\",\n text,\n null,\n session,\n settings.continuation\n ? { hidden: true, continuation: true }\n : settings.followup\n ? { hidden: true, followup: true }\n : null,\n );\n }\n await run(sql`UPDATE session SET ts = ${Date.now()} WHERE id = ${session}`);\n\n const blob = settings.memory ? await getMemoryBlob() : null;\n const recalled = settings.memory ? await retrieveFacts(text) : [];\n const context = await getContext(session, 24, settings.contextChars);\n const registry0 = await buildToolRegistry();\n const allow = settings.tools ? new Set(settings.tools) : null;\n const registry = allow\n ? {\n ...registry0,\n tools: Object.fromEntries(\n Object.entries(registry0.tools).filter(([k]) =>\n allow.has(k) || k === \"name_session\"\n ),\n ),\n schemas: Object.values(registry0.tools).filter((t: any) =>\n allow.has(t.schema?.function?.name) ||\n t.schema?.function?.name === \"name_session\"\n ).map((t: any) => t.schema),\n }\n : registry0;\n\n const memoryHeader = [\n blob?.value ? `blob:${blob.value}` : null,\n recalled.length ? `recalled:\\n- ${recalled.join(\"\\n- \")}` : null,\n ].filter(Boolean).join(\"\\n\\n\") || \"∅\";\n\n const hasRojs = registry.mcpToolNames.some((n) => n.startsWith(\"rojs_\"));\n const rojsHint = hasRojs\n ? `\\n\\nC#/Roslyn code-analysis tools (rojs_*) are connected via MCP. Workflow: rojs_create_session first (inline files[] or root_dir on the analysis host) — it returns a session_id every other rojs tool requires. Then: rojs_get_diagnostics (compile errors), rojs_hover, rojs_find_references, rojs_get_outline, rojs_context_bundle (token-budgeted context around a symbol — prefer it over pasting whole files), rojs_speculative_bind (check an expression compiles BEFORE proposing it), rojs_apply_edits with commit=false (dry-run diagnostic delta), rojs_rename_symbol. Sessions expire after idle timeout — recreate on NOT_FOUND. Positions are 0-based line/col.`\n : \"\";\n\n const toolNames =\n registry.schemas.map((t: any) => t?.function?.name).filter(Boolean).join(\n \", \",\n ) || \"none\";\n const skillsOn = activeSkills(settings.skills, text);\n const ctx0HasArtifactTools = !!registry.tools.update_artifact;\n if (skillsOn.length) {\n emit({\n type: \"stage\",\n label: \"skills: \" + skillsOn.map((k) => k.name).join(\", \"),\n });\n }\n const base = [\n {\n role: \"system\",\n content: renderPrompt(\n \"system\",\n {\n date: new Date().toISOString().slice(0, 10),\n tools: toolNames,\n skills: skillsOn.length\n ? \"\\n\" + skillsOn.map((k) =>\n renderPrompt(\n \"skill\",\n { name: k.name, body: k.body },\n settings.prompts,\n settings.examples,\n )\n ).join(\"\\n\\n\") + \"\\n\"\n : \"\",\n focus: settings.focus && ctx0HasArtifactTools\n ? \"\\n\" + renderPrompt(\n \"workbench\",\n {\n id: String(settings.focus.id),\n title: settings.focus.title,\n files: settings.focus.files.join(\", \") || \"index.html\",\n file: settings.focus.file || \"index.html\",\n selection: settings.focus.selection\n ? `\\nSelected text in ${settings.focus.file}:\\n\\`\\`\\`\\n${settings.focus.selection}\\n\\`\\`\\``\n : \"\",\n errors: settings.focus.errors.length\n ? `\\nConsole (latest first):\\n${\n settings.focus.errors.slice().reverse().map((e) => \"- \" + e)\n .join(\"\\n\")\n }`\n : \"\",\n },\n settings.prompts,\n settings.examples,\n ) + \"\\n\"\n : \"\",\n memory: memoryHeader === \"∅\"\n ? \"\"\n : `\\nMemory (recalled facts about this user; trust as stated, do not repeat back):\\n${memoryHeader}\\n`,\n rojs: rojsHint ? `\\n${rojsHint.trim()}\\n` : \"\",\n user: settings.system\n ? `\\nUser instructions (override the doctrine where they conflict):\\n${settings.system}\\n`\n : \"\",\n },\n settings.prompts,\n settings.examples,\n ),\n },\n ...context.map(({ role, content }) => ({ role, content })),\n ];\n\n const msgCount = unwrap(\n await raw<{ c: number }>(\n sql`SELECT COUNT(*) AS c FROM message WHERE session = ${session}`,\n ),\n [],\n );\n const isFirstExchange = (msgCount[0]?.c ?? 0) <= 2;\n\n let turnText = text;\n if (text.length > 18_000 && !settings.continuation) {\n emit({\n type: \"stage\",\n label: `splitting ${Math.ceil(text.length / 12_000)} parts`,\n });\n const ask = text.slice(0, 400).replace(/\\s+/g, \" \");\n const parts: string[] = [];\n for (let i = 0; i < text.length && parts.length < 8; i += 12_000) {\n parts.push(text.slice(i, i + 12_000));\n }\n const digests = await Promise.all(parts.map((part, i) =>\n callInference(\n [{\n role: \"system\",\n content:\n \"You compress source material for a later step. Output only the digest.\",\n }, {\n role: \"user\",\n content: renderPrompt(\n \"digest\",\n { ask, part: String(i + 1), n: String(parts.length), text: part },\n settings.prompts,\n settings.examples,\n ),\n }],\n undefined,\n \"fast\",\n 25_000,\n {\n expect: 900,\n maxTokens: 1_200,\n router: settings.router,\n keyPolicy: settings.keyPolicy,\n vendorOrder: settings.vendorOrder,\n },\n ).then((r) => (r.message?.content ?? \"\").trim()).catch((e) =>\n `[part ${i + 1} could not be digested: ${\n String(e.message).slice(0, 80)\n }]`\n )\n ));\n turnText = `${\n text.slice(0, 1_500)\n }\\n\\n[The message was ${text.length} chars; it was split into ${parts.length} parts and digested. Work from these digests:]\\n\\n${\n digests.map((d, i) => `--- part ${i + 1}/${parts.length} ---\\n${d}`).join(\n \"\\n\\n\",\n )\n }`;\n emit({ type: \"stage\", label: \"digests ready\" });\n }\n\n const result = await cognize(\n turnText,\n base,\n { session, tools: registry.tools, schemas: registry.schemas, turn: {} },\n isFirstExchange,\n emit,\n model,\n settings,\n );\n\n let sessionName = result.sessionName;\n if (\n !sessionName && !settings.continuation &&\n (sess.name === \"New Chat\" || !sess.name)\n ) {\n sessionName = deriveTitle(text);\n await renameSession(session, sessionName);\n }\n await addMsg(\"assistant\", result.reply, null, session, {\n provider: result.meta?.provider ?? null,\n model: result.meta?.model ?? null,\n instance: result.meta?.instance ?? null,\n reasoning: result.reasoning ?? [],\n truncated: !!result.truncated,\n continuation: settings.continuation,\n followup: settings.followup,\n maxTokensSent: result.meta?.maxTokensSent ?? null,\n maxTokensAsked: result.meta?.maxTokensAsked ?? null,\n finishReason: result.meta?.finishReason ?? null,\n tokensOut: result.meta?.tokensOut ?? null,\n\n attempts: result.meta?.attempts?.length ?? null,\n telemetry: result.telemetry ?? null,\n toolEvents: slimEvents(result.toolEvents ?? []),\n skills: skillsOn.map((k) => k.name),\n });\n\n let completion: { done: boolean; remaining: string[] } | null = null;\n const worked = (result.toolEvents ?? []).some((e) =>\n /artifact|eval_js|rojs_/.test(e.tool)\n );\n if (\n !settings.continuation && (worked || BUILD_RX.test(text)) &&\n !result.truncated\n ) {\n try {\n const did = (result.toolEvents ?? []).map((e) =>\n `${e.tool}${e.error ? \" (failed)\" : \"\"}: ${\n JSON.stringify(e.args).slice(0, 160)\n }`\n ).join(\"\\n\") || \"(no tools)\";\n const aid = [...(result.toolEvents ?? [])].reverse().map((e) =>\n Number((e.result as any)?.id)\n ).find((n) =>\n Number.isInteger(n)\n ) ?? Number(settings.focus?.id);\n let quality = \"(no artifact this turn)\";\n if (Number.isInteger(aid) && APP_RX.test(text)) {\n const lf = await listFiles(aid);\n if (lf) {\n const q = qualityReport(lf.files);\n quality = q.length\n ? `artifact #${aid}: ${lf.files.length} files\\n` +\n q.map((x) => \"- \" + x).join(\"\\n\")\n : `artifact #${aid} clears the rubric`;\n }\n }\n const r = await callInference(\n [{\n role: \"system\",\n content: \"You audit whether a task is finished. Output only JSON.\",\n }, {\n role: \"user\",\n content: renderPrompt(\n \"completion\",\n {\n ask: text.slice(0, 3000),\n did,\n reply: (result.reply ?? \"\").slice(0, 3000),\n quality,\n },\n settings.prompts,\n settings.examples,\n ),\n }],\n undefined,\n \"fast\",\n 12_000,\n {\n expect: 300,\n maxTokens: 500,\n router: settings.router,\n keyPolicy: settings.keyPolicy,\n vendorOrder: settings.vendorOrder,\n },\n );\n const raw = String(r.message?.content ?? \"\");\n const j = JSON.parse(\n raw.slice(raw.indexOf(\"{\"), raw.lastIndexOf(\"}\") + 1),\n );\n completion = {\n done: j.done !== false &&\n !(Number(j.quality) > 0 && Number(j.quality) < 4),\n remaining: Array.isArray(j.remaining)\n ? j.remaining.filter((x: unknown) => typeof x === \"string\").slice(\n 0,\n 8,\n )\n : [],\n };\n if (completion.remaining.length === 0) completion.done = true;\n } catch {\n completion = null;\n }\n }\n\n let needsCompact = false;\n try {\n const c = await loadCompact(session);\n const live = await liveChars(session, c?.uptoId ?? 0);\n needsCompact = live.count > 8 && live.chars > 2 * settings.contextChars;\n } catch { /* hint only */ }\n return {\n reply: result.reply,\n sessionName,\n toolEvents: result.toolEvents,\n meta: result.meta,\n reasoning: result.reasoning,\n truncated: result.truncated,\n telemetry: result.telemetry,\n completion,\n needsCompact,\n };\n}\n\nexport default async function handler(req: Request): Promise<Response> {\n const url = new URL(req.url);\n const method = req.method;\n const init = await initDB();\n if (!init.ok) {\n return new Response(`DB init failed: ${(init?.error ?? \"\")}`, {\n status: 500,\n });\n }\n\n const am = url.pathname.match(/^\\/artifact\\/(\\d+)(?:\\/(.*))?$/);\n if (am) {\n const id = Number(am[1]);\n if (am[2] === undefined) {\n return new Response(null, {\n status: 302,\n headers: { Location: `/artifact/${id}/` },\n });\n }\n if (method === \"GET\") {\n const f = await readFile(id, am[2] || \"\");\n if (!f) return new Response(\"not found\", { status: 404 });\n const path = am[2] ||\n (f.kind === \"html\"\n ? \"index.html\"\n : f.kind === \"svg\"\n ? \"index.svg\"\n : \"index.md\");\n return serveFile(url.origin, path, f.content);\n }\n }\n const compacted = await handleCompact(\n req,\n url,\n (messages, settings) =>\n callInference(messages, undefined, \"fast\", 45_000, {\n expect: 1400,\n maxTokens: 2000,\n temperature: 0.2,\n router: settings.router,\n keyPolicy: settings.keyPolicy,\n vendorOrder: settings.vendorOrder,\n }).then((r) => String(r.message?.content ?? \"\")),\n );\n if (compacted) return compacted;\n if (method === \"GET\" && url.searchParams.has(\"artifact_files\")) {\n const r = await listFiles(Number(url.searchParams.get(\"artifact_files\")));\n if (!r) return Response.json({ error: \"not found\" }, { status: 404 });\n return Response.json({\n id: r.artifact.id,\n title: r.artifact.title,\n kind: r.artifact.kind,\n session: r.artifact.session,\n files: r.files,\n issues: lintArtifact(r.files),\n });\n }\n const swarm = await handleSwarm(req, url, {\n PassMeter,\n deriveTitle,\n clean,\n ensureSession,\n });\n if (swarm) return swarm;\n const issuesRes = await handleIssues(req, url);\n if (issuesRes) return issuesRes;\n if (method === \"POST\" && url.searchParams.has(\"artifact_save_many\")) {\n const b = await req.json().catch(() => ({}));\n const id = Number.isInteger(b.id) ? b.id : null;\n if (id) {\n const a = await listFiles(id);\n if (!a) return Response.json({ error: \"not found\" }, { status: 404 });\n }\n const r = await saveMany(\n String(b.session ?? \"default\"),\n id,\n String(b.title ?? \"\"),\n Array.isArray(b.files) ? b.files : [],\n );\n return r\n ? Response.json({ ok: true, ...r, url: `/artifact/${r.id}/` })\n : Response.json({ error: \"save failed\" }, { status: 500 });\n }\n if (method === \"POST\" && url.searchParams.has(\"artifact_delete_file\")) {\n const b = await req.json().catch(() => ({}));\n const w = await deleteFile(\n Number(b.id),\n String(b.path ?? \"\"),\n b.dir === true,\n );\n return w.ok\n ? Response.json({ ok: true })\n : Response.json({ error: \"cannot delete\" }, { status: 400 });\n }\n if (method === \"POST\" && url.searchParams.has(\"artifact_save\")) {\n const b = await req.json().catch(() => ({}));\n const id = Number(b.id),\n path = String(b.path ?? \"\"),\n content = typeof b.content === \"string\" ? b.content : null;\n if (!id || !path || content === null) {\n return Response.json({ error: \"id, path, content required\" }, {\n status: 400,\n });\n }\n const w = await writeFile(id, path, content);\n return w.ok\n ? Response.json({ ok: true, url: `/artifact/${id}/` })\n : Response.json({ error: w?.error }, { status: 500 });\n }\n\n if (\n method === \"GET\" &&\n !url.searchParams.has(\"q\") &&\n !url.searchParams.has(\"sessions\") &&\n !url.searchParams.has(\"session\") &&\n !url.searchParams.has(\"history\") &&\n !url.searchParams.has(\"artifact\") &&\n !url.searchParams.has(\"progress\") &&\n !url.searchParams.has(\"prompts\")\n ) {\n return new Response(PAGE_HTML, {\n headers: { \"content-type\": \"text/html\" },\n });\n }\n\n if (method === \"GET\" && url.searchParams.has(\"sessions\")) {\n return Response.json(await listSessions());\n }\n\n if (method === \"GET\" && url.searchParams.has(\"history\")) {\n return Response.json(await getHistory(url.searchParams.get(\"history\")!));\n }\n\n if (method === \"GET\" && url.searchParams.has(\"artifacts\")) {\n const session = url.searchParams.get(\"session\") ?? \"default\";\n const rows = unwrap(\n await all(\n \"artifact\",\n sql`SELECT * FROM artifact WHERE session = ${session} ORDER BY ts DESC`,\n ),\n [],\n );\n return Response.json(\n rows.map(({ id, title, kind, ts }) => ({ id, title, kind, ts })),\n );\n }\n\n if (method === \"GET\" && url.searchParams.has(\"artifact\")) {\n const id = Number(url.searchParams.get(\"artifact\"));\n if (!Number.isInteger(id)) return new Response(\"bad id\", { status: 400 });\n return new Response(null, {\n status: 302,\n headers: { Location: `/artifact/${id}/` },\n });\n }\n\n if (method === \"GET\" && url.searchParams.has(\"q\")) {\n const q = url.searchParams.get(\"q\")!;\n const session = url.searchParams.get(\"session\") ?? \"default\";\n try {\n const { reply, sessionName, toolEvents, meta, telemetry } = await runAI(\n q,\n session,\n undefined,\n url.searchParams.get(\"model\"),\n );\n return Response.json({ reply, sessionName, toolEvents, meta, telemetry });\n } catch (err) {\n console.error(\"q failed:\", q.slice(0, 80), err);\n return Response.json({ error: String(err) }, { status: 500 });\n }\n }\n\n if (method === \"POST\" && url.searchParams.has(\"q\")) {\n const body = await req.json().catch(() => ({}));\n const q = String(body.q ?? \"\");\n const session = String(body.session ?? \"default\");\n const settings = normalizeSettings({\n ...(body.settings ?? {}),\n model: body.settings?.model ?? body.model,\n });\n\n const model = settings.model ??\n (BUILD_RX.test(q) && APP_RX.test(q) && !body.settings?.continuation\n ? \"coder\"\n : null);\n if (!q.trim()) {\n return Response.json({ error: { message: \"empty prompt\" } }, {\n status: 400,\n });\n }\n\n const log: Progress[] = [];\n let chain = Promise.resolve();\n const persist = () => {\n chain = chain.then(() =>\n run(\n sql`INSERT INTO progress (session, events, ts) VALUES (${session}, ${\n JSON.stringify(log)\n }, ${Date.now()})\n ON CONFLICT(session) DO UPDATE SET events = excluded.events, ts = excluded.ts`,\n ).then(() => {})\n ).catch(() => {});\n };\n const emit = (p: Progress) => {\n log.push(p);\n persist();\n };\n emit({ type: \"stage\", label: \"starting\" });\n try {\n const r = await runAI(q, session, emit, model, settings);\n await chain;\n return Response.json(r);\n } catch (err: any) {\n console.error(\"q(post) failed:\", q.slice(0, 80), err);\n const msg = String(err?.message ?? err);\n const [head, ...rest] = msg.split(\"\\n\");\n return Response.json({ error: { message: head, details: rest } }, {\n status: err?.status && err.status >= 400 && err.status < 600\n ? err.status\n : 500,\n });\n } finally {\n emit({ type: \"stage\", label: \"done\" });\n await chain.catch(() => {});\n }\n }\n\n if (method === \"GET\" && url.searchParams.has(\"prompts\")) {\n return Response.json({ defaults: DEFAULT_PROMPTS, vars: PROMPT_VARS });\n }\n\n if (method === \"GET\" && url.searchParams.has(\"progress\")) {\n const r = await one<\"progress\">(\n \"progress\",\n sql`SELECT * FROM progress WHERE session = ${url.searchParams.get(\n \"progress\",\n )!}`,\n );\n const events: Progress[] = r.ok && r.value\n ? JSON.parse(r.value[0].events)\n : [];\n const since = Number(url.searchParams.get(\"since\") ?? 0) || 0;\n return Response.json({ events: events.slice(since), next: events.length });\n }\n\n if (method === \"POST\" && url.searchParams.has(\"rename\")) {\n const { id, name } = await req.json();\n await renameSession(id, name);\n return Response.json({ ok: true });\n }\n\n if (method === \"POST\" && url.searchParams.has(\"clear\")) {\n const { id } = await req.json();\n await clearSession(id);\n return Response.json({ ok: true });\n }\n\n if (method === \"DELETE\" && url.searchParams.has(\"session\")) {\n await deleteSession(url.searchParams.get(\"session\")!);\n return Response.json({ ok: true });\n }\n\n return new Response(\"not found\", { status: 404 });\n}","freeai",[],[646],"8067f941-cb00-473b-abeb-53be60e3d555","app-swarm.ts","40d1c4cc-acda-11f1-b796-1607ee4eb77e",1627,["D",1789494602834],"// Swarm build endpoints (?plan, ?build_file): one user action → many val invocations, each under its\n// own 60 s. Dependencies from app.tsx are injected to avoid an import cycle.\nimport { renderPrompt } from \"./prompts.ts\";\nimport { lintArtifact, saveMany } from \"./artifacts.ts\";\nimport { activeSkills, normalizeSettings } from \"./app-settings.ts\";\nimport { all, run, sql, unwrap } from \"./db.ts\";\nexport type SwarmDeps = {\n PassMeter: any; // class from app.tsx: new PassMeter(ceiling, emit, model, settings) with .p(key, vars) and .call(messages, tools, model, override)\n deriveTitle: (text: string) => string;\n clean: (s: string) => string;\n ensureSession: (id: string) => Promise<unknown>;\n};\n/** Returns a Response for ?plan / ?build_file, or null when the request is not a swarm route. */\nexport async function handleSwarm(req: Request, url: URL, d: SwarmDeps): Promise<Response | null> {\n const method = req.method;\n const { PassMeter, deriveTitle, clean, ensureSession } = d;\n // ── swarm build: one user action → many val invocations, each under its own 60 s ──\n // POST ?plan {q, session, settings} → manifest + an artifact shell (index placeholder + manifest.json) builders write into.\n if (method === \"POST\" && url.searchParams.has(\"plan\")) {\n const b = await req.json().catch(() => ({}));\n const settings = normalizeSettings(b.settings ?? {});\n const session = String(b.session ?? \"default\"), ask = clean(String(b.q ?? \"\"));\n if (!ask) return Response.json({ error: { message: \"empty ask\" } }, { status: 400 });\n await ensureSession(session);\n const meter = new PassMeter(3, () => {}, settings.model, settings);\n const skillsOn = activeSkills(settings.skills, ask);\n const prompt = meter.p(\"architect\", { ask, user: settings.system ? `\\nUser instructions: ${settings.system}\\n` : \"\", skills: skillsOn.length ? \"\\n\" + skillsOn.map((k) => renderPrompt(\"skill\", { name: k.name, body: k.body }, settings.prompts)).join(\"\\n\") : \"\" });\n try {\n const r = await meter.call([{ role: \"system\", content: \"Output only JSON.\" }, { role: \"user\", content: prompt }], undefined, settings.model ?? \"coder\", { expect: 3000, temperature: 0.2 });\n const raw = String(r?.message?.content ?? \"\");\n const j = raw.slice(raw.indexOf(\"{\"), raw.lastIndexOf(\"}\") + 1);\n const manifest = JSON.parse(j);\n if (!Array.isArray(manifest.files) || !manifest.files.length) throw new Error(\"manifest has no files\");\n manifest.features = [].concat(manifest.features ?? []).map(String).slice(0, 20); manifest.visual = String(manifest.visual ?? \"\");\n manifest.files = manifest.files.filter((f: any) => f && typeof f.path === \"string\").map((f: any) => ({ path: f.path.replace(/^\\.\\//, \"\"), purpose: String(f.purpose ?? \"\"), exports: [].concat(f.exports ?? []).map(String), imports: [].concat(f.imports ?? []).map(String), notes: String(f.notes ?? \"\") }));\n if (!manifest.files.some((f: any) => /^readme\\.md$/i.test(f.path))) manifest.files.push({ path: \"README.md\", purpose: \"what it is, every feature, controls/shortcuts, how to run (static host or open index.html), file map\", exports: [], imports: [], notes: \"markdown; ≥ 10 feature bullets\" });\n if (!manifest.files.some((f: any) => /^index\\.html?$/.test(f.path))) manifest.files.unshift({ path: \"index.html\", purpose: \"entry: markup + boot; loads every sibling\", exports: [], imports: manifest.files.map((f: any) => f.path), notes: \"\" });\n const title = String(manifest.title ?? deriveTitle(ask)).slice(0, 60);\n const shell = await saveMany(session, null, title, [{ path: \"index.html\", content: `<!doctype html><html><head><meta charset=\"utf-8\"><title>${title}

building ${manifest.files.length} files…

` }, { path: \"manifest.json\", content: JSON.stringify({ ...manifest, ask }, null, 2) }]);\n // Durable plan + per-file registry (build_job/build_file — see db.ts) so \"what files exist and what state\n // are they in\" has one queryable answer instead of living only in the client's in-memory manifest card and\n // an ephemeral, delete-on-completion omni_state blob. One row per manifest file, all starting \"queued\".\n if (shell?.id) {\n const now = Date.now();\n await run(sql`INSERT INTO build_job (artifact_id, session, title, ask, manifest, status, created_ts, updated_ts)\n VALUES (${shell.id}, ${session}, ${title}, ${ask.slice(0, 2000)}, ${JSON.stringify(manifest).slice(0, 60_000)}, 'planned', ${now}, ${now})\n ON CONFLICT(artifact_id) DO UPDATE SET manifest = excluded.manifest, title = excluded.title, ask = excluded.ask, status = 'planned', updated_ts = excluded.updated_ts`);\n for (const f of manifest.files) {\n await run(sql`INSERT INTO build_file (artifact_id, path, purpose, status, updated_ts) VALUES (${shell.id}, ${f.path}, ${String(f.purpose ?? \"\").slice(0, 500)}, 'queued', ${now})\n ON CONFLICT(artifact_id, path) DO UPDATE SET purpose = excluded.purpose, status = 'queued', updated_ts = excluded.updated_ts`);\n }\n }\n return Response.json({ manifest, artifactId: shell?.id ?? null, title, meta: r?.meta ?? null });\n } catch (e: any) {\n return Response.json({ error: { message: `plan failed: ${String(e?.message ?? e).slice(0, 300)}` } }, { status: 502 });\n }\n }\n // POST ?build_file {session, artifactId, manifest, path, settings} → writes that one file (auto-continued), returns lint issues.\n if (method === \"POST\" && url.searchParams.has(\"build_file\")) {\n const b = await req.json().catch(() => ({}));\n const settings = normalizeSettings(b.settings ?? {});\n const session = String(b.session ?? \"default\"), id = Number(b.artifactId), manifest = b.manifest, path = String(b.path ?? \"\");\n const spec = manifest?.files?.find((f: any) => f.path === path);\n if (!Number.isInteger(id) || !spec) return Response.json({ error: { message: \"bad artifactId/path\" } }, { status: 400 });\n const meter = new PassMeter(6, () => {}, settings.model, settings);\n const compact = manifest.files.map((f: any) => `${f.path}: ${f.purpose}${f.exports?.length ? ` — exports ${f.exports.join(\", \")}` : \"\"}`).join(\"\\n\");\n const prompt = meter.p(\"builder\", { title: String(manifest.title ?? \"\"), path, purpose: spec.purpose, exports: spec.exports?.join(\", \") || \"(none)\", imports: spec.imports?.join(\", \") || \"(none)\", shared: String(manifest.shared ?? \"\"), manifest: compact, notes: spec.notes || \"(none)\", features: [].concat(manifest.features ?? []).map((x: unknown, i: number) => `${i + 1}. ${String(x)}`).join(\"\\n\") || \"(see purpose)\", visual: String(manifest.visual ?? \"(designer's choice: tokens, dark default, real identity)\") });\n try {\n const r = await meter.call([{ role: \"system\", content: \"You write one complete source file. Output only a fenced code block.\" }, { role: \"user\", content: prompt }], undefined, settings.model ?? \"coder\", { expect: 6000, temperature: 0.2 });\n const raw = String(r?.message?.content ?? \"\");\n const fence = raw.match(/```[\\w.+-]*\\s*\\n([\\s\\S]*?)\\n```\\s*$/m) ?? raw.match(/```[\\w.+-]*\\s*\\n([\\s\\S]*)$/m);\n const content = (fence ? fence[1] : raw).replace(/\\n```\\s*$/, \"\");\n if (!content.trim()) throw new Error(\"empty file\");\n const w = await saveMany(session, id, \"\", [{ path, content }]);\n // builders run in parallel, so cross-file checks are meaningless here: report only this file's own defects (syntax, JSON, blocked externals)\n const own = lintArtifact([{ path, content }]).filter((i) => !/does not exist|imports \\{/.test(i));\n const truncated = r?.finishReason === \"length\";\n // Persist this attempt's outcome into build_file — the durable per-file record — regardless of how the\n // manifest card is currently rendered client-side. ON CONFLICT because a file rebuilt via the manifest's\n // single-file \"rebuild\" button, or a job resumed after this row's artifact_id/path pair already exists,\n // both hit the same (artifact_id, path) primary key as the original plan-time insert.\n await run(sql`INSERT INTO build_file (artifact_id, path, purpose, status, lines, issues, error, attempts, updated_ts)\n VALUES (${id}, ${path}, ${String(spec.purpose ?? \"\").slice(0, 500)}, ${truncated || own.length ? \"issues\" : \"ok\"}, ${content.split(\"\\n\").length}, ${JSON.stringify(own).slice(0, 4000)}, NULL, 1, ${Date.now()})\n ON CONFLICT(artifact_id, path) DO UPDATE SET status = excluded.status, lines = excluded.lines, issues = excluded.issues, error = NULL, attempts = build_file.attempts + 1, updated_ts = excluded.updated_ts`).catch(() => {});\n return Response.json({ ok: true, path, chars: content.length, lines: content.split(\"\\n\").length, truncated, issues: own, written: !!w, meta: r?.meta ?? null });\n } catch (e: any) {\n const errMsg = `build ${path} failed: ${String(e?.message ?? e).slice(0, 300)}`;\n await run(sql`INSERT INTO build_file (artifact_id, path, status, error, attempts, updated_ts) VALUES (${id}, ${path}, 'error', ${errMsg}, 1, ${Date.now()})\n ON CONFLICT(artifact_id, path) DO UPDATE SET status = 'error', error = excluded.error, attempts = build_file.attempts + 1, updated_ts = excluded.updated_ts`).catch(() => {});\n return Response.json({ error: { message: errMsg }, path }, { status: 502 });\n }\n }\n // ── build jobs: the orchestration state of a swarm build, persisted so a closed tab / dead network / reload can resume it ──\n // GET ?job=list&session=S → unfinished jobs; POST ?job {session, artifactId, state} → update status (manifest/files already\n // live in build_job/build_file — see ?plan and ?build_file above — so this no longer needs to carry done/failed arrays).\n //\n // Previously this was a single opaque JSON blob per job in omni_state (key \"job::\"), DELETED the\n // instant a build finished — so build_job/build_file (db.ts) exist specifically so \"what got built, from what plan, in\n // what state\" has a durable, queryable, joinable answer that survives past \"done\" instead of vanishing on completion.\n if (url.searchParams.has(\"job\")) {\n if (method === \"GET\") {\n const session = String(url.searchParams.get(\"session\") ?? \"\");\n const jobs = unwrap(await all(\"build_job\", sql`SELECT * FROM build_job WHERE session = ${session} AND status != 'done' ORDER BY updated_ts DESC LIMIT 20`), []);\n const out = [];\n for (const j of jobs) {\n let manifest: any = null, manifestError: string | null = null;\n try { manifest = JSON.parse(j.manifest); } catch (e: any) { manifestError = `stored manifest is corrupt JSON: ${String(e?.message ?? e).slice(0, 200)}`; }\n // Previously a corrupt row was silently `continue`d past — the job vanished from the list with no\n // trace, so a client polling ?job=list had no way to know a build existed at all, let alone that it\n // needed attention. Surface it instead: the client can render an error state and offer to clear it\n // (e.g. by marking the job 'stopped' via ?job POST) rather than the build silently disappearing.\n if (!manifest) { out.push({ artifactId: j.artifact_id, manifest: null, manifestError, title: j.title, ask: j.ask, status: j.status, ts: j.updated_ts, done: [], failed: [] }); continue; }\n const files = unwrap(await all(\"build_file\", sql`SELECT path, status FROM build_file WHERE artifact_id = ${j.artifact_id}`), []);\n out.push({\n artifactId: j.artifact_id, manifest, title: j.title, ask: j.ask, status: j.status, ts: j.updated_ts,\n done: files.filter((f: any) => f.status === \"ok\").map((f: any) => f.path),\n failed: files.filter((f: any) => f.status === \"error\" || f.status === \"issues\").map((f: any) => f.path),\n });\n }\n return Response.json({ jobs: out });\n }\n if (method === \"POST\") {\n const b = await req.json().catch(() => ({}));\n const session = String(b.session ?? \"\"), id = Number(b.artifactId), state = b.state ?? {};\n if (!session || !Number.isInteger(id)) return Response.json({ error: { message: \"bad session/artifactId\" } }, { status: 400 });\n // Previously any client-supplied string landed straight in build_job.status with no validation — a typo\n // or a future caller sending e.g. \"complete\" instead of \"done\" would silently create a status value\n // that every reader (checkResume's `status !== 'done'` filter, any future dashboard) doesn't recognize,\n // rather than failing loudly at the one place that writes it.\n const BUILD_STATUSES = new Set([\"planned\", \"building\", \"integrating\", \"done\", \"stopped\"]);\n const status = String(state.status ?? \"building\");\n if (!BUILD_STATUSES.has(status)) return Response.json({ error: { message: `bad status \"${status}\" — must be one of ${[...BUILD_STATUSES].join(\", \")}` } }, { status: 400 });\n const title = String(state.title ?? \"\"), ask = String(state.ask ?? \"\").slice(0, 2000);\n await run(sql`UPDATE build_job SET status = ${status}, updated_ts = ${Date.now()},\n title = CASE WHEN ${title} = '' THEN title ELSE ${title} END,\n ask = CASE WHEN ${ask} = '' THEN ask ELSE ${ask} END\n WHERE artifact_id = ${id}`);\n return Response.json({ ok: true });\n }\n }\n return null;\n}\n",[],[655],"65e5dd38-8866-49c9-8459-21d968ef0e6c","app-settings.ts","405c3590-acda-11f1-ac59-1607ee4eb77e",1466,["D",1789150837612],"// Per-request settings: shape, validation and the skill matcher. Split out of app.tsx\n// to keep each file under Val Town's 80 kB file-API limit.\nimport { normalizePromptOverrides, type PromptKey } from \"./prompts.ts\";\nexport interface Settings {\n model: string | null; // router alias/pin; null = auto\n reasoning: \"low\" | \"medium\" | \"high\" | null;\n temperature: number | null;\n maxTokens: number | null; // null = size to task (respecting vendor limits); number = hard preference\n system: string; // custom instructions appended to the system prompt\n tools: string[] | null; // enabled tool names; null = all\n plan: boolean; verify: boolean; ensemble: boolean; memory: boolean;\n continueMax: number; // auto-continue passes when a reply is cut at max_tokens\n budgetMs: number; // wall-clock budget for the turn (free plan hard cap is 60 s)\n prompts: Partial>; // per-prompt overrides; see prompts.ts\n examples: boolean; // append the two exemplars per prompt (prompt-examples.ts); off saves ~1–3k input tokens per call\n focus: Focus | null; // artifact the workbench has open when the message was sent\n skills: Skill[]; // user-defined instruction packs; `always` or keyword-triggered `auto`\n router: { url: string; key: string | null } | null; // inference router override (allowlisted hosts only)\n maxMode: \"auto\" | \"fixed\" | \"max\"; // auto = size to task; fixed = maxTokens; max = ask for the vendor ceiling\n continuation: boolean; // this turn resumes a reply cut at the output limit: skip plan/verify/ensemble, hide the user turn\n expect: \"auto\" | \"short\" | \"long\" | \"max\"; // expected reply length → omni_expect_tokens and max_tokens sizing\n keyPolicy: \"depth\" | \"rr\" | \"breadth\" | null; // router key rotation for this request (null = router default)\n contextChars: number; // history budget sent to the model (chars); small keeps free-tier ITPM limits reachable\n retryOf: boolean; // client re-sent the same ask after a 503: do not insert the user message again\n vendorOrder: string[]; // vendors to try first, in order (every key slot of one before the next); [] = router default\n followup: boolean; // auto-continuation of unfinished work (client-issued): hide the synthetic user turn, skip plan/ensemble\n}\nconst ROUTER_ALLOW = (Deno.env.get(\"OMNI_ROUTER_ALLOW\") ?? \"\").split(\",\").map((s) => s.trim()).filter(Boolean);\nexport function normalizeRouter(x: any): Settings[\"router\"] {\n if (!x || typeof x !== \"object\" || typeof x.url !== \"string\") return null;\n try {\n const u = new URL(x.url);\n if (u.protocol !== \"https:\" || !(u.hostname.endsWith(\".val.run\") || ROUTER_ALLOW.includes(u.hostname))) return null;\n return { url: u.origin + (u.pathname === \"/\" ? \"\" : u.pathname.replace(/\\/$/, \"\")), key: typeof x.key === \"string\" && x.key ? x.key.slice(0, 200) : null };\n } catch { return null; }\n}\nexport interface Focus { id: number; title: string; file: string; files: string[]; selection: string; errors: string[] }\nexport interface Skill { name: string; when: string; body: string; mode: \"always\" | \"auto\" }\nexport function normalizeFocus(x: any): Focus | null {\n if (!x || typeof x !== \"object\" || !Number.isInteger(x.id)) return null;\n const str = (v: unknown, n: number) => (typeof v === \"string\" ? v.slice(0, n) : \"\");\n return { id: x.id, title: str(x.title, 120), file: str(x.file, 200), files: Array.isArray(x.files) ? x.files.filter((f: unknown) => typeof f === \"string\").slice(0, 40) : [],\n selection: str(x.selection, 4000), errors: Array.isArray(x.errors) ? x.errors.filter((e: unknown) => typeof e === \"string\").slice(-8).map((e: string) => e.slice(0, 400)) : [] };\n}\nexport function normalizeSkills(x: any): Skill[] {\n if (!Array.isArray(x)) return [];\n return x.filter((k) => k && typeof k === \"object\" && typeof k.name === \"string\" && typeof k.body === \"string\" && k.body.trim())\n .slice(0, 12).map((k) => ({ name: k.name.slice(0, 60), when: typeof k.when === \"string\" ? k.when.slice(0, 300) : \"\", body: k.body.slice(0, 6000), mode: k.mode === \"always\" ? \"always\" : \"auto\" }));\n}\n/** Skills that apply to this message: `always`, or `auto` whose `when` (comma/pipe-separated keywords or /regex/) matches the text. */\nexport function activeSkills(skills: Skill[], text: string): Skill[] {\n const t = text.toLowerCase();\n return skills.filter((k) => {\n if (k.mode === \"always\") return true;\n const w = k.when.trim(); if (!w) return false;\n const m = w.match(/^\\/(.+)\\/([a-z]*)$/);\n if (m) { try { return new RegExp(m[1], m[2].replace(/g/g, \"\") || \"i\").test(text); } catch { return false; } }\n return w.split(/[,|]/).map((s) => s.trim().toLowerCase()).filter(Boolean).some((kw) => t.includes(kw));\n });\n}\nexport function normalizeSettings(x: any): Settings {\n const num = (v: unknown, lo: number, hi: number, d: number | null) => (typeof v === \"number\" && isFinite(v)) ? Math.min(hi, Math.max(lo, v)) : d;\n return {\n model: typeof x?.model === \"string\" && x.model && x.model !== \"auto\" ? x.model : null,\n reasoning: [\"low\", \"medium\", \"high\"].includes(x?.reasoning) ? x.reasoning : null,\n temperature: num(x?.temperature, 0, 2, null),\n maxTokens: num(x?.maxTokens, 256, 65_536, null),\n system: typeof x?.system === \"string\" ? x.system.slice(0, 8000) : \"\",\n tools: Array.isArray(x?.tools) ? x.tools.filter((t: unknown) => typeof t === \"string\") : null,\n plan: x?.plan !== false, verify: x?.verify !== false, ensemble: x?.ensemble !== false, memory: x?.memory !== false,\n continueMax: num(x?.continueMax, 0, 8, 3) as number,\n budgetMs: num(x?.budgetMs, 15_000, 52_000, 52_000) as number,\n prompts: normalizePromptOverrides(x?.prompts),\n examples: x?.examples !== false,\n focus: normalizeFocus(x?.focus),\n skills: normalizeSkills(x?.skills),\n router: normalizeRouter(x?.router),\n maxMode: x?.maxMode === \"fixed\" ? \"fixed\" : x?.maxMode === \"max\" ? \"max\" : \"auto\",\n continuation: x?.continuation === true,\n expect: [\"short\", \"long\", \"max\"].includes(x?.expect) ? x.expect : \"auto\",\n keyPolicy: [\"depth\", \"rr\", \"breadth\"].includes(x?.keyPolicy) ? x.keyPolicy : null,\n contextChars: num(x?.contextChars, 2_000, 120_000, 16_000) as number,\n retryOf: x?.retryOf === true,\n followup: x?.followup === true,\n vendorOrder: typeof x?.vendorOrder === \"string\" ? x.vendorOrder.split(\",\").map((s: string) => s.trim().toLowerCase()).filter(Boolean).slice(0, 12) : [],\n };\n}\n",[],[663],"d8d610f5-14c1-41ad-9c59-2cbe1c27e7ab","app-infer.ts","d82c8fe0-ae16-11f1-98dc-1607ee4eb77e",1619,["D",1789466755087],4,"// Inference client (moved from app.tsx for the 80k-char limit): in-process router call, request shaping, size-bound retries.\nimport routerHandler from \"./router.tsx\";\nimport type { Settings } from \"./app-settings.ts\";\nimport { normalizeMessages, shrinkMessages } from \"./app-helpers.ts\";\n\nexport const INFERENCE_URL = \"https://router.val.run\";\n// The router is a module of this val. Calling it in-process removes the val→val HTTP hop entirely: Cloudflare in front of\n// *.val.run blocks server-side fetches from Val Town's own egress (\"Blocked\", server: cloudflare) regardless of volume,\n// and every hop was also a second 60 s wall clock and a second invocation. HTTP is used only for a custom router URL.\nexport const routerCall = (url: string, init: RequestInit): Promise =>\n url.replace(/\\/$/, \"\") === INFERENCE_URL || !url ? routerHandler(new Request(INFERENCE_URL + \"/v1/chat/completions\", init)) : fetch(url, init);\n\n// ════════════════════════════════════════════════════════════════════════════\n// INFERENCE (accepts optional model override for the verifier pass)\n// ════════════════════════════════════════════════════════════════════════════\nexport interface InferResult {\n message: any;\n finishReason: string;\n reasoning?: string; // model \"thinking\" (gpt-oss `reasoning`, qwen/deepseek `reasoning_content`)\n usage?: { prompt_tokens?: number; completion_tokens?: number };\n meta: { provider?: unknown; model?: string; latencyMs?: number; retries?: number; instance?: string; maxTokensSent?: number | null; maxTokensAsked?: number; finishReason?: string; tokensOut?: number | null; tokensIn?: number | null;\n // Routing flowchart material, straight from router-core.ts's trail (via router-openai.ts's _omni_meta) —\n // plan is the intended provider order, attempts is what actually happened (tried/skipped, ok/failed, timing).\n plan?: string[]; attempts?: { provider: string; vendor: string; model: string; pass: number; timeoutMs: number; ok: boolean; skipped?: boolean; demoted?: boolean; latencyMs?: number; error?: string; ts: number }[] };\n}\nexport interface GenOpts { reasoning?: string | null; temperature?: number | null; maxTokens?: number | null; expect?: number; router?: Settings[\"router\"]; maxMode?: Settings[\"maxMode\"]; keyPolicy?: Settings[\"keyPolicy\"]; vendorOrder?: string[]; exclude?: string[] }\n// Long-output requests (code, apps, documents) need throughput, not just quality:\n// the router ranks by quality among vendors whose eta fits the deadline.\nexport const BUILD_RX = /\\b(create|build|write|implement|generate|make|design|code|app|renderer|shader|script|component|page|game|simulat|program|class|function|refactor|port|convert)\\b/i;\nexport const expectTokens = (messages: unknown[]) => {\n const last = [...messages].reverse().find((m: any) => m?.role === \"user\") as any;\n return BUILD_RX.test(String(last?.content ?? \"\")) ? 6000 : 1500;\n};\nexport async function callInference(\n messages: unknown[],\n tools?: unknown[],\n model?: string | null,\n deadlineMs?: number,\n gen: GenOpts = {},\n): Promise {\n // Ask for the most output the task can use; the router shrinks max_tokens to a\n // vendor's per-request/TPM limit and retries, and PassMeter auto-continues on\n // finish_reason \"length\", so a big request degrades to more passes, not an error.\n const expect = gen.expect ?? expectTokens(messages);\n // max_tokens policy — auto: size to task (router clamps to vendor/learned caps); fixed: the user's number; max: ask for the ceiling and let the router clamp.\n const maxTokens = gen.maxMode === \"max\" ? 65_536 : gen.maxMode === \"fixed\" && gen.maxTokens ? gen.maxTokens : (gen.maxTokens ?? (expect >= 6000 ? 16_000 : 4_000));\n const body: Record = { messages: normalizeMessages(messages), max_tokens: maxTokens, omni_expect_tokens: expect };\n const routerUrl = gen.router?.url ?? INFERENCE_URL;\n const routerHeaders: Record = { \"content-type\": \"application/json\", ...(gen.router?.key ? { authorization: `Bearer ${gen.router.key}` } : {}) };\n if (deadlineMs) body.omni_deadline_ms = deadlineMs;\n if (gen.keyPolicy) body.omni_key_policy = gen.keyPolicy;\n if (gen.vendorOrder?.length) body.omni_vendor_order = gen.vendorOrder;\n if (gen.exclude?.length) body.omni_exclude = gen.exclude;\n if (tools?.length) body.tools = tools;\n if (model) body.model = model;\n if (gen.reasoning) body.reasoning_effort = gen.reasoning;\n if (typeof gen.temperature === \"number\") body.temperature = gen.temperature;\n const t0 = Date.now();\n let lastErr: Error = new Error(\"unreachable\");\n let shrinks = 0;\n // Carried across retries so a call that eventually throws (after all 4 client-side retries) still reports\n // the last router pass's routing trail, instead of the flowchart going dark exactly when it matters most.\n let lastPlan: string[] | undefined;\n let lastAttempts: InferResult[\"meta\"][\"attempts\"];\n for (let retry = 0; retry < 4; retry++) {\n if (retry) {\n // Prompt-size exhaustion: the vendors that are left cannot take this prompt, so make the prompt fit —\n // drop oldest history, trim tool payloads — and try again at once instead of burning retries on an\n // identical, unwinnable resend.\n //\n // This regex previously looked for \"prompt ≈N tok > maxIn\" / \"too large\" / \"input limit\" / \"maxIn\" —\n // a message format router-core.ts and router-openai.ts never actually produce anywhere (confirmed:\n // no occurrence of any of those substrings in either file). ALL_PROVIDERS_EXHAUSTED just concatenates\n // each provider's own raw upstream error text (router-core.ts's `errors.push(`${p.name}: ${e.message}`)`),\n // so the old regex could never match and shrinkMessages() below had exactly one call site — this whole\n // branch was dead code; every size-exhausted request instead fell through to the generic retry path and\n // resent the identical oversized prompt up to 4 times, guaranteed to fail identically each time, burning\n // the wall-clock budget until the loop's own deadline check gave up. Replaced with patterns actually\n // observed live this session (a real Groq 413: \"Request too large ... please reduce your message size\n // and try again\") plus the standard phrasings other vendors use for the same failure.\n const sizeBound = /reduce (?:your|the) (?:message|prompt) size|request too large|prompt is too long|too many tokens|context_length_exceeded|maximum context length|exceeds the (?:model'?s? )?(?:context|token) (?:length|limit)|input (?:is )?too long/i.test(lastErr.message) && (lastErr as any).status === 503;\n if (sizeBound && shrinks < 2) { shrinks++; body.messages = shrinkMessages(body.messages as any[], shrinks); body.omni_expect_tokens = Math.min(expect, 2000); }\n const wait = sizeBound ? 0 : 1200 * retry;\n if (deadlineMs && Date.now() - t0 + wait + 4000 > deadlineMs) break;\n if (wait) await new Promise((r) => setTimeout(r, wait));\n if (deadlineMs) body.omni_deadline_ms = deadlineMs - (Date.now() - t0);\n }\n try {\n const res = await routerCall(routerUrl, { method: \"POST\", headers: routerHeaders, body: JSON.stringify(body) });\n const text = await res.text();\n let json: any = null;\n try { json = JSON.parse(text); } catch { /* non-JSON */ }\n if (!res.ok || !json?.choices?.[0]) {\n // An HTML body is an edge/WAF page (Val Town \"Blocked\", Cloudflare challenge), not the router: report its title + who served it, never the markup.\n const html = /^\\s*<(?:!doctype|html)/i.test(text);\n const detail = json?.error ? (typeof json.error === \"string\" ? json.error : `${json.error.message}${json.error.details ? \"\\n\" + [].concat(json.error.details).join(\"\\n\") : \"\"}`)\n : html ? `${routerUrl} answered with an HTML page \"${(text.match(/([^<]{1,80})<\\/title>/i)?.[1] ?? \"no title\").trim()}\" (server: ${res.headers.get(\"server\") ?? \"?\"}, cf-ray: ${res.headers.get(\"cf-ray\") ?? \"-\"}) — the request was blocked before reaching the router; check https://router.val.run/health in a browser and the val's logs`\n : text.slice(0, 600);\n if (json?.error?.plan) lastPlan = json.error.plan;\n if (json?.error?.attempts) lastAttempts = json.error.attempts;\n lastErr = Object.assign(new Error(`router ${res.status}: ${detail}`), { status: res.status, html, plan: lastPlan, attempts: lastAttempts });\n if (res.status === 404 || res.status === 400 || res.status === 401) throw lastErr; // not retryable\n continue;\n }\n const choice = json.choices[0];\n const m = choice.message ?? {};\n // Defense in depth: router-core.ts already rejects an empty/all-dot response before it can win a\n // provider race (see EMPTY_OR_DOT_RESPONSE there), but gen.router.url can point at a different,\n // custom router the user configured — this is the last checkpoint before an empty/junk reply would\n // otherwise be accepted as done. Treated exactly like a 503: retried, not silently returned.\n const omni = json._omni_meta;\n if (omni?.plan) lastPlan = omni.plan;\n if (omni?.attempts) lastAttempts = omni.attempts;\n const hasToolCalls = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;\n if (!hasToolCalls && typeof m.content === \"string\") {\n const stripped = m.content.replace(/\\s+/g, \"\");\n if (stripped.length === 0 || /^\\.+$/.test(stripped)) {\n lastErr = Object.assign(new Error(`router returned an empty/dot response from ${omni?.provider?.name ?? \"an unknown provider\"}`), { status: 503, plan: lastPlan, attempts: lastAttempts });\n continue;\n }\n }\n return {\n message: m,\n finishReason: choice.finish_reason ?? \"stop\",\n reasoning: typeof m.reasoning === \"string\" ? m.reasoning : typeof m.reasoning_content === \"string\" ? m.reasoning_content : undefined,\n usage: json.usage,\n meta: { provider: omni?.provider, model: json.model, latencyMs: omni?.latency_ms, retries: retry,\n instance: omni?.instance ?? omni?.provider?.name, maxTokensSent: omni?.max_tokens_sent ?? maxTokens, maxTokensAsked: maxTokens, finishReason: choice.finish_reason ?? \"stop\", tokensOut: json.usage?.completion_tokens ?? null, tokensIn: json.usage?.prompt_tokens ?? null,\n plan: lastPlan, attempts: lastAttempts },\n };\n } catch (e: any) {\n lastErr = e;\n if (e.status && ![503, 502, 500, 429].includes(e.status)) throw e;\n }\n }\n throw lastErr;\n}\n\n// A metered wrapper: every inference call decrements a shared pass budget so no\n// stage can silently blow past the hard ceiling. This is THE governor's teeth.\n",[],[671],"3194c6f2-1696-49e9-97a5-ad6090c9fe2b","app-helpers.ts","e15c4b62-ad82-11f1-b116-1607ee4eb77e",1618,["D",1789466754495],"// Helpers split out of app.tsx to stay under the Val Town 80,000-character per-file limit:\n// legacy blob memory + salience facts, prompt shrinking, title derivation, tool-event slimming, web search, eval_js.\nimport { all, type Bound, one, type Row, run, sql, unwrap } from \"./db.ts\";\n// ts: optional wall-clock stamp — only the synthetic \"route\" events app.tsx's PassMeter pushes set it (real\n// tool-call events don't need it, their hop order already IS their chronology); when present, ui-timeline.ts\n// uses it to interleave route nodes with tool-call rows in the order they actually happened, not just hop order.\nexport interface ToolEvent { hop: number; tool: string; args: Record<string, unknown>; result?: unknown; error?: string; ts?: number }\n\nexport async function getMemoryBlob(): Promise<Row<\"memory\"> | null> {\n return unwrap(\n await one(\"memory\", sql`SELECT * FROM memory WHERE key = ${\"core\"}`),\n null,\n );\n}\n\n// ════════════════════════════════════════════════════════════════════════════\n// EPISODIC MEMORY: write with surprise-salience, retrieve by relevance, decay\n// ════════════════════════════════════════════════════════════════════════════\nexport const DECAY_HALFLIFE_MS = 1000 * 60 * 60 * 24 * 7; // 7 days\nexport const FACT_CAP = 500;\n\nexport function decayed(salience: number, accessed: number, now: number): number {\n const age = Math.max(0, now - accessed);\n return salience * Math.pow(0.5, age / DECAY_HALFLIFE_MS);\n}\n\nexport async function writeFact(fact: string, predictability: number): Promise<void> {\n const now = Date.now();\n // salience = information content ≈ (1 - self-reported predictability).\n const salience = Math.max(0.01, Math.min(1, 1 - predictability));\n await run(\n sql`INSERT INTO memory_fact (fact, salience, created, accessed, hits)\n VALUES (${fact}, ${salience}, ${now}, ${now}, 0)`,\n );\n\n // Bounded store: evict lowest current-value rows beyond a cap.\n const rows = unwrap(\n await all(\"memory_fact\", sql`SELECT * FROM memory_fact`),\n [],\n );\n if (rows.length <= FACT_CAP) return;\n const ranked = rows\n .map((r) => ({ id: r.id, v: decayed(r.salience, r.accessed, now) }))\n .sort((a, b) => a.v - b.v);\n const drop = ranked.slice(0, rows.length - FACT_CAP).map((r) => r.id);\n if (!drop.length) return;\n // Placeholder count varies with drop.length, but every bound value is still\n // a real parameter — this is `run` given a Bound built directly rather than\n // via the tagged template, which only supports a fixed interpolation count.\n const deleteEvicted: Bound = {\n text: `DELETE FROM memory_fact WHERE id IN (${\n drop.map(() => \"?\").join(\",\")\n })`,\n values: drop,\n };\n await run(deleteEvicted);\n}\n\n// Keyword-overlap retrieval — no embedding dependency. Deliberately simple;\n// swap for vector search later without touching callers.\nexport function tokenize(s: string): Set<string> {\n return new Set(\n s.toLowerCase().replace(/[^a-z0-9 ]/g, \" \").split(/\\s+/).filter((w) =>\n w.length > 2\n ),\n );\n}\n\nexport async function retrieveFacts(query: string, k = 5): Promise<string[]> {\n const now = Date.now();\n const qTok = tokenize(query);\n if (!qTok.size) return [];\n const rows = unwrap(\n await all(\"memory_fact\", sql`SELECT * FROM memory_fact`),\n [],\n );\n const scored = rows.map((r) => {\n const fTok = tokenize(r.fact);\n let overlap = 0;\n for (const t of qTok) if (fTok.has(t)) overlap++;\n const relevance = overlap / Math.sqrt(fTok.size || 1);\n const value = decayed(r.salience, r.accessed, now);\n return { id: r.id, fact: r.fact, score: relevance * (0.5 + value) };\n });\n const top = scored.filter((s) => s.score > 0).sort((a, b) =>\n b.score - a.score\n ).slice(0, k);\n // reinforce accessed facts (anti-decay); this is retrieval-as-rehearsal\n for (const t of top) {\n await run(\n sql`UPDATE memory_fact SET accessed = ${now}, hits = hits + 1 WHERE id = ${t.id}`,\n );\n }\n return top.map((t) => t.fact);\n}\n\n// ════════════════════════════════════════════════════════════════════════════\n// SESSION CRUD\n// ════════════════════════════════════════════════════════════════════════════\n\n/** Make a prompt fit a smaller input ceiling: keep system messages and the last user turn intact; level 1 drops the\n * oldest half of the history and caps tool results at 1.5k chars; level 2 keeps only the last 2 exchanges and caps at 600. */\nexport function shrinkMessages(messages: any[], level: number): any[] {\n const sys = messages.filter((m) => m.role === \"system\");\n const rest = messages.filter((m) => m.role !== \"system\");\n const cap = level >= 2 ? 600 : 1_500;\n const keep = level >= 2 ? Math.min(rest.length, 4) : Math.max(2, Math.ceil(rest.length / 2));\n const tail = rest.slice(-keep).map((m) => (m.role === \"tool\" && typeof m.content === \"string\" && m.content.length > cap ? { ...m, content: m.content.slice(0, cap) + \" …[trimmed]\" } : m));\n // a tool message must follow the assistant turn that requested it — drop leading orphans\n while (tail.length && tail[0].role === \"tool\") tail.shift();\n const last = tail[tail.length - 1];\n if (last?.role === \"user\" && typeof last.content === \"string\" && last.content.length > 24_000) tail[tail.length - 1] = { ...last, content: last.content.slice(0, 16_000) + \"\\n…[middle trimmed to fit the model's input limit]…\\n\" + last.content.slice(-6_000) };\n return [...sys, ...tail];\n}\n/** ≤4 significant words of the ask, Title Case; deterministic so two clients agree. */\nexport function deriveTitle(text: string): string {\n const STOP = new Set([\"a\", \"an\", \"the\", \"to\", \"of\", \"for\", \"in\", \"on\", \"and\", \"or\", \"with\", \"me\", \"my\", \"please\", \"can\", \"you\", \"i\", \"it\", \"that\", \"this\", \"is\", \"be\", \"make\", \"create\", \"build\", \"write\", \"help\", \"want\", \"need\", \"using\", \"use\"]);\n const words = text.replace(/```[\\s\\S]*?```/g, \" \").replace(/[^\\p{L}\\p{N}\\s#.-]/gu, \" \").split(/\\s+/).filter((w) => w && !STOP.has(w.toLowerCase()));\n const pick = (words.length ? words : text.split(/\\s+/)).slice(0, 4).map((w) => w.length > 18 ? w.slice(0, 18) : w);\n return (pick.map((w) => /^[a-z]/.test(w) ? w[0].toUpperCase() + w.slice(1) : w).join(\" \") || \"New Chat\").slice(0, 60);\n}\n\n/** Tool events as the UI needs them after a reload: args/results without file bodies. */\nexport function slimEvents(evs: ToolEvent[], cap = 2000): ToolEvent[] {\n // `arrayCap` exists because the 20-element cap — right for a tool's file list — silently truncated the\n // routing flowchart's plan (34 → 20) and attempts, which cut off exactly the tail where demoted\n // providers and late passes live. Route events are already bounded at the router (TRAIL_CAP=60), so they\n // get a cap that keeps the whole trail.\n const mk = (arrayCap: number) => {\n const trim = (v: unknown): unknown => {\n if (typeof v === \"string\") return v.length > cap ? v.slice(0, cap) + \"…\" : v;\n if (Array.isArray(v)) return v.slice(0, arrayCap).map(trim);\n if (v && typeof v === \"object\") return Object.fromEntries(Object.entries(v as Record<string, unknown>).filter(([k]) => ![\"content\", \"files\", \"edits\", \"html\"].includes(k)).map(([k, x]) => [k, trim(x)]));\n return v;\n };\n return trim;\n };\n const trimTool = mk(20), trimRoute = mk(80);\n return evs.map((e) => {\n const trim = e.tool === \"route\" ? trimRoute : trimTool;\n // ts is what cognize() sorted on to interleave route hops with tool calls; dropping it here meant a reload\n // could never re-establish that order.\n return { hop: e.hop, tool: e.tool, ...(e.ts ? { ts: e.ts } : {}), args: trim(e.args) as Record<string, unknown>, result: trim(e.result), ...(e.error ? { error: e.error } : {}) };\n });\n}\n\nexport async function webSearch(query: string): Promise<string> {\n const url = `https://html.duckduckgo.com/html/?q=${\n encodeURIComponent(query)\n }`;\n const res = await fetch(url, { headers: { \"User-Agent\": \"Mozilla/5.0\" } });\n const text = await res.text();\n const snippets: string[] = [];\n const re = /<a class=\"result__snippet\"[^>]*>([\\s\\S]*?)<\\/a>/g;\n let m: RegExpExecArray | null;\n while ((m = re.exec(text)) !== null && snippets.length < 6) {\n snippets.push(m[1].replace(/<[^>]+>/g, \"\").trim());\n }\n return snippets.length ? snippets.join(\"\\n---\\n\") : \"No results found.\";\n}\n\nexport function evalJs(code: string): unknown {\n try {\n const logs: string[] = [];\n const fakeConsole = { log: (...a: unknown[]) => logs.push(a.join(\" \")) };\n const fn = new Function(\n \"Math\",\n \"JSON\",\n \"Array\",\n \"Object\",\n \"String\",\n \"Number\",\n \"Boolean\",\n \"Date\",\n \"RegExp\",\n \"Map\",\n \"Set\",\n \"console\",\n `\"use strict\";\\n${code}`,\n );\n const result = fn(\n Math,\n JSON,\n Array,\n Object,\n String,\n Number,\n Boolean,\n Date,\n RegExp,\n Map,\n Set,\n fakeConsole,\n );\n return { result: result ?? null, logs };\n } catch (e) {\n return { error: String(e) };\n }\n}\n\n// Harmony / text-embedded tool-call parsing (gpt-oss leaks `to=functions.NAME json{…}` into content) and tool-name aliases.\nexport function balancedJson(s: string, at: number): string {\n if (s[at] !== \"{\") return \"\";\n let depth = 0, inStr = false, esc = false;\n for (let i = at; i < s.length; i++) {\n const c = s[i];\n if (inStr) { if (esc) esc = false; else if (c === \"\\\\\") esc = true; else if (c === '\"') inStr = false; continue; }\n if (c === '\"') inStr = true; else if (c === \"{\") depth++; else if (c === \"}\") { depth--; if (depth === 0) return s.slice(at, i + 1); }\n }\n return \"\";\n}\nexport function parseTextToolCalls(content: string): { calls: any[]; rest: string } {\n const calls: any[] = [];\n // gpt-oss \"Harmony\" channel leakage (some vendors' chat templates emit it as plain text):\n // analysis… commentary to=functions.NAME json{…} assistantfinal…\n // → tool call from the commentary segment; only the final channel is user-visible prose.\n if (/to=functions\\.[\\w.-]+/.test(content) || /assistantfinal/.test(content)) {\n const rx = /to=functions\\.([\\w.-]+)(?:\\s*<\\|[^|>]*\\|>\\s*|\\s*json\\s*|\\s)*(?=\\{)/g;\n for (const m of content.matchAll(rx)) {\n const json = balancedJson(content, m.index! + m[0].length);\n if (!json) continue;\n try { const j = JSON.parse(json); calls.push({ id: `call_${crypto.randomUUID().slice(0, 8)}`, type: \"function\", function: { name: m[1], arguments: JSON.stringify(j) } }); } catch { /* malformed */ }\n }\n const fin = content.split(/assistantfinal/); const visible = fin.length > 1 ? fin[fin.length - 1] : (calls.length ? \"\" : content.replace(/^\\s*analysis[\\s\\S]*?(?=assistant|$)/, \"\"));\n content = visible.replace(/<\\|[^|>]*\\|>/g, \"\");\n }\n const rest = content.replace(/<tool_call>([\\s\\S]*?)(?:<\\/tool_call>|$)/g, (_, inner: string) => {\n const t = inner.trim();\n try {\n if (t.startsWith(\"{\")) { const j = JSON.parse(t); if (j.name) calls.push({ id: `call_${crypto.randomUUID().slice(0, 8)}`, type: \"function\", function: { name: j.name, arguments: JSON.stringify(j.arguments ?? j.parameters ?? {}) } }); return \"\"; }\n } catch { /* fall through */ }\n const fn = t.match(/<function=([\\w.-]+)>/);\n if (!fn) return \"\";\n const args: Record<string, string> = {};\n for (const m of t.matchAll(/<parameter=([\\w.-]+)>([\\s\\S]*?)(?:<\\/parameter>|(?=<parameter=)|<\\/function>|$)/g)) args[m[1]] = m[2].replace(/^\\n/, \"\").replace(/\\n$/, \"\");\n calls.push({ id: `call_${crypto.randomUUID().slice(0, 8)}`, type: \"function\", function: { name: fn[1], arguments: JSON.stringify(args) } });\n return \"\";\n });\n return { calls, rest: rest.trim() };\n}\n\nexport const TOOL_ALIASES: Record<string, string> = { search: \"search_artifact\", grep: \"search_artifact\", find: \"search_artifact\", read_file: \"read_artifact\", read: \"read_artifact\", edit: \"update_artifact\", write_file: \"update_artifact\", edit_file: \"update_artifact\", write: \"update_artifact\", search_web: \"web_search\", browse: \"web_search\", remember: \"memory_write\", recall: \"memory_recall\" };\nexport const summarizeEvent = (ev: ToolEvent) =>\n ev.error ? `**${ev.tool}** failed: ${ev.error}`\n : ev.tool === \"create_artifact\" ? `Built **${(ev.result as any)?.title ?? ev.args.title ?? \"artifact\"}** — open it above.`\n : ev.tool === \"update_artifact\" ? `Updated **${String(ev.args.path ?? \"index.html\")}** in artifact #${(ev.result as any)?.id ?? \"\"} — reload it above.`\n : ev.tool === \"read_artifact\" ? \"\" : `Ran **${ev.tool}**.`;\n\n\n/** Vendor-portable message shapes. Strict OpenAI-compatible backends reject what lenient ones accept:\n * nvidia_nim — \"Assistant message must have either content or tool_calls, but not both\" → drop empty content beside tool_calls;\n * together — \"prompt cannot be empty\" → no message may carry empty-string content; tool results and assistant turns get a marker.\n * Consecutive system messages are merged (mistral/anthropic-style backends want one). Never mutates the input. */\nexport function normalizeMessages(messages: unknown[]): unknown[] {\n const out: any[] = [];\n for (const raw of messages as any[]) {\n if (!raw || typeof raw !== \"object\") continue;\n const m: any = { ...raw };\n const hasCalls = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;\n const empty = m.content == null || (typeof m.content === \"string\" && m.content.trim() === \"\") || (Array.isArray(m.content) && m.content.length === 0);\n if (hasCalls) { if (empty) delete m.content; }\n else if (empty) m.content = m.role === \"tool\" ? \"(no output)\" : m.role === \"assistant\" ? \"(continued)\" : \" \";\n if (m.role === \"system\" && out.length && out[out.length - 1].role === \"system\" && typeof m.content === \"string\" && typeof out[out.length - 1].content === \"string\") { out[out.length - 1] = { ...out[out.length - 1], content: out[out.length - 1].content + \"\\n\\n\" + m.content }; continue; }\n out.push(m);\n }\n return out;\n}\n\n/** Salvage a create_artifact / update_artifact call whose JSON arguments were cut at max_tokens: recover every COMPLETE\n * {path, content} object from the `files` array (and `content`/`title` when they closed), report which file was cut.\n * Returns null when nothing usable survived. The cut file is deliberately dropped — a half file is a placeholder. */\nexport function salvageArtifactArgs(raw: string): { args: Record<string, unknown>; saved: string[]; cut: string | null } | null {\n const files: { path: string; content: string }[] = [];\n let cut: string | null = null;\n // Anchored to a preceding `{`/`,` (an actual object-key position), not a bare substring search: `content`\n // is large, arbitrary, model-generated HTML/JS and typically precedes `files` in argument order, so a\n // plain `raw.indexOf('\"files\"')` can match text INSIDE that content instead of the real key — e.g.\n // generated markup containing `data-x=\"files\"` is JSON-escaped as `\\\"files\\\"`, and the 7-char sequence\n // `\"files\"` (unescaped) appears right after that backslash, matching before the real key ever does. That\n // false match then feeds a garbage `[` search and corrupts (or silently drops) the whole salvage.\n const filesKeyMatch = raw.match(/[{,]\\s*\"files\"\\s*:/);\n const at = filesKeyMatch ? filesKeyMatch.index! + filesKeyMatch[0].indexOf('\"files\"') : -1;\n if (at >= 0) {\n const arr = raw.indexOf(\"[\", at);\n let i = arr + 1;\n while (i < raw.length) {\n const o = raw.indexOf(\"{\", i); if (o < 0) break;\n const obj = balancedJson(raw, o);\n if (!obj) { const m = raw.slice(o).match(/\"path\"\\s*:\\s*\"([^\"]*)\"/); cut = m ? m[1] : \"(unnamed)\"; break; }\n try { const f = JSON.parse(obj); if (typeof f?.path === \"string\" && typeof f?.content === \"string\") files.push({ path: f.path, content: f.content }); } catch { break; }\n i = o + obj.length;\n }\n }\n const head = at >= 0 ? raw.slice(0, at) : raw; /* top-level strings only count when they precede the files array — after it they were cut */\n // Escape map covers \\n \\t \\u fully; every other escape (including the unmapped \\r \\b \\f) fell through to\n // \"output the raw character after the backslash\" — correct BY COINCIDENCE for \\\" and \\\\ (the char after\n // the backslash IS the literal character wanted), but wrong for \\r/\\b/\\f, which decoded to a literal\n // \"r\"/\"b\"/\"f\" letter instead of the actual control character. Rare in practice (most generated content\n // uses \\n, not \\r), but real whenever salvaged content contains Windows-style line endings.\n const str = (key: string) => { const m = head.match(new RegExp('\"' + key + '\"\\\\s*:\\\\s*\"')); if (!m) return undefined; const start = (m.index ?? 0) + m[0].length; let out = \"\", j = start; while (j < head.length) { const c = head[j]; if (c === \"\\\\\") { const n = head[j + 1]; out += n === \"n\" ? \"\\n\" : n === \"t\" ? \"\\t\" : n === \"r\" ? \"\\r\" : n === \"b\" ? \"\\b\" : n === \"f\" ? \"\\f\" : n === \"u\" ? String.fromCharCode(parseInt(head.slice(j + 2, j + 6), 16)) : n; j += n === \"u\" ? 6 : 2; continue; } if (c === '\"') return out; out += c; j++; } return undefined; };\n const args: Record<string, unknown> = {};\n const id = raw.match(/\"id\"\\s*:\\s*(\\d+)/); if (id) args.id = Number(id[1]);\n const title = str(\"title\"); if (title !== undefined) args.title = title;\n const kind = str(\"kind\"); if (kind !== undefined) args.kind = kind;\n const content = str(\"content\"); if (content !== undefined) args.content = content;\n if (files.length) args.files = files;\n if (!files.length && args.content === undefined) return null;\n return { args, saved: files.map((f) => f.path), cut };\n}\n\n// Hidden META control block parsing and the pre-estimate heuristics (moved from app.tsx for the 80k-char limit).\nexport const META_OPEN = \"<<<META\";\nexport const META_CLOSE = \"META>>>\";\n\nexport interface AnswerMeta {\n confidence: number; // 0..1 self-estimated P(answer correct)\n stakes: \"low\" | \"high\"; // self-estimated irreversibility of being wrong\n abstain: boolean; // true → model declines rather than confabulate\n}\nexport function parseMeta(text: string): { visible: string; meta: AnswerMeta | null } {\n const i = text.lastIndexOf(META_OPEN);\n const j = text.lastIndexOf(META_CLOSE);\n if (i !== -1 && (j === -1 || j < i)) return { visible: text.slice(0, i).trimEnd(), meta: null }; // dangling open marker: hide it\n if (i === -1) return { visible: text, meta: null };\n const raw = text.slice(i + META_OPEN.length, j).trim();\n const visible = (text.slice(0, i) + text.slice(j + META_CLOSE.length)).trim();\n try {\n const p = JSON.parse(raw);\n const meta: AnswerMeta = {\n confidence: Number.isFinite(+p.confidence) ? +p.confidence : 0.5,\n stakes: p.stakes === \"high\" ? \"high\" : \"low\",\n abstain: !!p.abstain,\n };\n return { visible, meta };\n } catch {\n return { visible, meta: null };\n }\n}\n\n// (META instruction now lives in prompts.ts as \"meta\")\n\n// ════════════════════════════════════════════════════════════════════════════\n// COMPLEXITY / STAKES PRE-ESTIMATE (heuristic, zero-cost — no inference call)\n// Governs whether the expensive stages are even eligible to fire.\n// ════════════════════════════════════════════════════════════════════════════\nexport function preEstimate(\n input: string,\n): { complex: boolean; maybeHighStakes: boolean } {\n const t = input.toLowerCase();\n const long = input.length > 180;\n const multiClause = (input.match(/[.?!]/g)?.length ?? 0) >= 2;\n const reasoningWords =\n /\\b(why|how|compare|prove|derive|design|analy|trade[- ]?off|implication|explain)\\b/\n .test(t);\n const stakesWords =\n /\\b(medical|legal|financial|invest|dose|security|delete|irreversible|production|deploy|money|contract)\\b/\n .test(t);\n const complex = (long && multiClause) || reasoningWords;\n return { complex, maybeHighStakes: stakesWords };\n}\n",[],[680],"e58fe85f-a1b0-4827-a664-8963190bba5c","app-compact.ts","7c7e2310-ae0d-11f1-b403-1607ee4eb77e",1609,["D",1789463126212],"// Conversation compaction: a running summary of everything older than the last few exchanges, stored per session in\n// omni_state (key compact:<session>) and prepended to the model context in place of the messages it covers. Messages\n// themselves are never deleted — history rendering is unchanged — only what the model sees is folded.\n// Runs as its own val invocation (POST ?compact) so it never competes with a turn's 60 s budget.\nimport { all, run, sql, unwrap } from \"./db.ts\";\nimport { renderPrompt } from \"./prompts.ts\";\nimport { normalizeSettings, type Settings } from \"./app-settings.ts\";\n\nexport type Compact = { summary: string; uptoId: number; ts: number; covered: number; chars: number };\n\nexport async function loadCompact(session: string): Promise<Compact | null> {\n const rows = unwrap(await all<\"omni_state\">(\"omni_state\", sql`SELECT value FROM omni_state WHERE key = ${\"compact:\" + session}`), []);\n try { return rows[0] ? JSON.parse(rows[0].value) as Compact : null; } catch { return null; }\n}\nexport async function saveCompact(session: string, c: Compact | null): Promise<void> {\n const key = \"compact:\" + session;\n if (!c) { await run(sql`DELETE FROM omni_state WHERE key = ${key}`); return; }\n await run(sql`INSERT INTO omni_state (key, value, ts) VALUES (${key}, ${JSON.stringify(c)}, ${Date.now()}) ON CONFLICT(key) DO UPDATE SET value = excluded.value, ts = excluded.ts`);\n}\n\n/** Chars of live (uncompacted) history — what a turn would have to fit. */\nexport async function liveChars(session: string, uptoId: number): Promise<{ chars: number; count: number }> {\n const rows = unwrap(await all<\"message\">(\"message\", sql`SELECT id, content FROM message WHERE session = ${session} AND id > ${uptoId} ORDER BY id DESC LIMIT 200`), []);\n return { chars: rows.reduce((n, r) => n + r.content.length, 0), count: rows.length };\n}\n\nconst KEEP_TAIL = 6; // the last 3 exchanges are never folded: the model needs them verbatim\n\n/** Fold everything older than the last KEEP_TAIL messages into the summary. `call` is the inference function (fast tier). */\nexport async function compactSession(\n session: string,\n call: (messages: unknown[]) => Promise<string>,\n prompts?: Record<string, string>,\n examples = true,\n): Promise<{ ok: boolean; before: number; after: number; covered: number; uptoId: number; reason?: string }> {\n const prev = await loadCompact(session);\n const uptoPrev = prev?.uptoId ?? 0;\n const rows = unwrap(await all<\"message\">(\"message\", sql`SELECT * FROM message WHERE session = ${session} AND id > ${uptoPrev} ORDER BY id ASC`), []);\n // Was `<= KEEP_TAIL + 1`: at rows.length === KEEP_TAIL+1 there is already exactly one row old enough\n // to fold (rows.length - KEEP_TAIL === 1), so the +1 rejected a foldable state as \"nothing old enough\"\n // and delayed the first compaction by one message past the intended KEEP_TAIL threshold.\n if (rows.length <= KEEP_TAIL) return { ok: false, before: 0, after: prev?.chars ?? 0, covered: 0, uptoId: uptoPrev, reason: \"nothing old enough to fold\" };\n const fold = rows.slice(0, rows.length - KEEP_TAIL);\n const before = fold.reduce((n, r) => n + r.content.length, 0);\n const transcript = fold.map((m) => `[#${m.id} ${m.role}] ${m.content.length > 5_000 ? m.content.slice(0, 3_800) + \"\\n…[\" + (m.content.length - 4_800) + \" chars trimmed]…\\n\" + m.content.slice(-1_000) : m.content}`).join(\"\\n\\n\");\n const prompt = renderPrompt(\"compact\", { previous: prev?.summary ?? \"(none — this is the first compaction)\", transcript }, prompts as any, examples);\n const summary = (await call([{ role: \"system\", content: \"You maintain the running summary of a long working conversation. Output only the summary.\" }, { role: \"user\", content: prompt }])).trim();\n if (summary.length < 80) return { ok: false, before, after: prev?.chars ?? 0, covered: 0, uptoId: uptoPrev, reason: \"model returned no usable summary\" };\n const storedSummary = summary.slice(0, 12_000);\n // chars must reflect what's actually stored (storedSummary), not the pre-truncation raw model output —\n // getContext() seeds its context-budget accounting with this value, so a mismatch here silently\n // over-reserves budget on every turn after a summary that ran past the 12,000-char cap.\n const next: Compact = { summary: storedSummary, uptoId: fold[fold.length - 1].id, ts: Date.now(), covered: (prev?.covered ?? 0) + fold.length, chars: storedSummary.length };\n await saveCompact(session, next);\n return { ok: true, before, after: next.chars, covered: fold.length, uptoId: next.uptoId };\n}\n\n/** The system message a turn prepends when a compaction exists. */\nexport function compactMessage(c: Compact): { role: \"system\"; content: string } {\n return { role: \"system\", content: `CONVERSATION SO FAR (compacted summary of ${c.covered} earlier messages; treat as established context, do not repeat it back):\\n${c.summary}` };\n}\n\n/** HTTP: POST ?compact {session, settings} folds old turns; GET ?compact=<session> reads the summary; DELETE clears it. Null when not a compact route. */\nexport async function handleCompact(req: Request, url: URL, infer: (messages: unknown[], settings: Settings) => Promise<string>): Promise<Response | null> {\n if (!url.searchParams.has(\"compact\")) return null;\n const session = url.searchParams.get(\"compact\") || \"\";\n if (req.method === \"GET\") {\n const c = await loadCompact(session); const budget = Number(url.searchParams.get(\"check\")) || 0;\n const live = budget ? await liveChars(session, c?.uptoId ?? 0) : null;\n return Response.json({ compact: c, needs: !!live && live.count > 8 && live.chars > 2 * budget, live });\n }\n if (req.method === \"DELETE\") { await saveCompact(session, null); return Response.json({ ok: true }); }\n if (req.method !== \"POST\") return null;\n const b = await req.json().catch(() => ({}));\n const settings = normalizeSettings(b.settings ?? {});\n const s = String(b.session ?? \"\");\n if (!s) return Response.json({ error: { message: \"session required\" } }, { status: 400 });\n try { return Response.json(await compactSession(s, (m) => infer(m, settings), settings.prompts as Record<string, string>, settings.examples)); }\n catch (e: any) { return Response.json({ error: { message: `compact failed: ${String(e?.message ?? e).slice(0, 300)}` } }, { status: 502 }); }\n}\n",[],[688],"a41cb04f-4a34-49bc-927c-6182c66feae3","_valtown-workspace.ts","9f0f3fb4-4610-11f1-a0e9-42b51c65c3df",1198,["D",1783676130488],14,"export default {\n async fetch(req: Request) {\n const url = new URL(req.url);\n const path = url.pathname;\n\n // Load workspace from v.storage\n const workspace = (await v.storage.get(\"workspace\")) ?? {\n directories: {},\n files: {},\n };\n\n // Helpers\n const save = async () => v.storage.set(\"workspace\", workspace);\n\n // -----------------------------\n // CREATE FILE\n // -----------------------------\n if (path === \"/create\" && req.method === \"POST\") {\n const body = await req.json();\n const { filePath, content } = body;\n\n workspace.files[filePath] = {\n name: filePath.split(\"/\").pop(),\n path: filePath,\n type: \"file\",\n content,\n };\n\n await save();\n return new Response(\"created\");\n }\n\n // -----------------------------\n // UPDATE FILE\n // -----------------------------\n if (path === \"/update\" && req.method === \"POST\") {\n const body = await req.json();\n const { filePath, content } = body;\n\n if (!workspace.files[filePath]) {\n return new Response(\"not found\", { status: 404 });\n }\n\n workspace.files[filePath].content = content;\n await save();\n return new Response(\"updated\");\n }\n\n // -----------------------------\n // DELETE FILE\n // -----------------------------\n if (path === \"/delete\" && req.method === \"POST\") {\n const body = await req.json();\n const { filePath } = body;\n\n delete workspace.files[filePath];\n await save();\n return new Response(\"deleted\");\n }\n\n // -----------------------------\n // LIST FILES\n // -----------------------------\n if (path === \"/list\") {\n return Response.json(Object.keys(workspace.files));\n }\n\n // -----------------------------\n // GET FILE\n // -----------------------------\n if (path === \"/file\") {\n const filePath = url.searchParams.get(\"path\");\n return Response.json(workspace.files[filePath]);\n }\n\n return new Response(\"unknown route\", { status: 404 });\n },\n};",[],[696],"6afd3ca7-07a8-46e7-b281-28b288595709","_valtown-file-editor.ts","9646c13a-467f-11f1-8bfd-42b51c65c3df",1197,["D",1783676124604],"export class ValFileEditor {\n constructor(public file) {\n this.file = file;\n }\n\n get content() {\n return this.file.content;\n }\n\n setContent(c) {\n this.file.content = c;\n return this;\n }\n\n // -----------------------------\n // Subdomain support\n // -----------------------------\n getSubdomain() {\n const m = this.file.content.match(/\\/\\/\\s*@subdomain:\\s*([a-z0-9-]+)/i);\n return m?.[1];\n }\n\n setSubdomain(name: string) {\n if (this.getSubdomain()) {\n return this.setContent(\n this.file.content.replace(\n /\\/\\/\\s*@subdomain:\\s*[a-z0-9-]+/i,\n `// @subdomain: ${name}`,\n ),\n );\n }\n return this.setContent(`// @subdomain: ${name}\\n` + this.file.content);\n }\n\n // -----------------------------\n // File type inference\n // -----------------------------\n inferKind() {\n const c = this.file.content;\n\n if (/export\\s+default\\s+async\\s+function\\s+handler/.test(c)) {\n return \"http-module\";\n }\n if (/export\\s+async\\s+function/.test(c)) {\n return \"val-function\";\n }\n if (/export\\s+const\\s+run\\s*=/.test(c)) {\n return \"scheduled-val\";\n }\n if (/export\\s+const\\s+cron\\s*=/.test(c)) {\n return \"cron-val\";\n }\n if (this.file.name.endsWith(\".json\")) return \"json\";\n if (this.file.name.endsWith(\".md\")) return \"markdown\";\n return \"unknown\";\n }\n\n // -----------------------------\n // Fingerprint (browser crypto)\n // -----------------------------\n async fingerprint() {\n const data = new TextEncoder().encode(this.file.content);\n const hash = await crypto.subtle.digest(\"SHA-256\", data);\n return [...new Uint8Array(hash)]\n .map((b) => b.toString(16).padStart(2, \"0\"))\n .join(\"\");\n }\n\n // -----------------------------\n // Save back to workspace\n // -----------------------------\n async save() {\n await fetch(\"https://ziggyware.vals.workers.dev/workspace/update\", {\n method: \"POST\",\n body: JSON.stringify({\n filePath: this.file.path,\n content: this.file.content,\n }),\n });\n }\n}",[],[705],"08041a77-a517-40c5-93ab-9dbd1e5fd18d","_valtown-api.ts","351d250c-467f-11f1-9311-42b51c65c3df",1196,["D",1783676119609],7,"const valAPI = {\n async createVal({ name, code }) {\n return await fetch(\"https://api.val.town/v1/vals\", {\n method: \"POST\",\n headers: {\n Authorization: `Bearer ${Deno.env.get(\"VALTOWN_API_KEY\")}`,\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify({ name, code }),\n }).then((r) => r.json());\n },\n\n async updateVal({ name, code }) {\n return await fetch(`https://api.val.town/v1/vals/${name}`, {\n method: \"PATCH\",\n headers: {\n Authorization: `Bearer ${Deno.env.get(\"VALTOWN_API_KEY\")}`,\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify({ code }),\n }).then((r) => r.json());\n },\n async deleteVal(name: string) {\n return await fetch(`https://api.val.town/v1/vals/${name}`, {\n method: \"DELETE\",\n headers: {\n Authorization: `Bearer ${Deno.env.get(\"VALTOWN_API_KEY\")}`,\n },\n }).then((r) => r.json());\n },\n};\n\nexport const ValAPI = {\n async createVal({ name, code }) {\n return await valAPI.createVal({ name, code });\n },\n async updateVal({ name, code }) {\n return await valAPI.updateVal({ name, code });\n },\n async deleteVal(name: string) {\n return await valAPI.deleteVal(name);\n },\n};",[],[713],"05156804-4768-43fc-b7f5-c39c53f573f3","_inference-router.ts","58cb4aa2-425f-11f1-bc49-42b51c65c3df",1193,["D",1783675978922],48,"import { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nimport { getProviderArray } from \"./inference-provider.ts\";\nimport type { Provider } from \"./db.ts\";\n\n// ============================================================================\n// 2. STATE MANAGEMENT (SQLite) & CACHING\n// ============================================================================\nasync function initDB() {\n await sqlite.execute(`\n CREATE TABLE IF NOT EXISTS omni_router_config (\n provider TEXT PRIMARY KEY,\n selected_model TEXT NOT NULL\n )\n `);\n}\n\nasync function getSavedModels(): Promise<Record<string, string>> {\n const result = await sqlite.execute(\n `SELECT provider, selected_model FROM omni_router_config`,\n );\n const map: Record<string, string> = {};\n for (const row of result.rows) {\n const r = row as any;\n map[r.provider as string] = r.selected_model as string;\n }\n return map;\n}\n\nconst MAX_CONCURRENCY = 3;\nlet inflight = 0;\n\nconst sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));\nconst now = () => performance.now();\n\n// ============================================================================\n// 3. ENTERPRISE CIRCUIT BREAKER\n// ============================================================================\ntype BreakerState = \"CLOSED\" | \"OPEN\" | \"HALF_OPEN\";\ninterface Breaker {\n failCount: number;\n state: BreakerState;\n nextAttempt: number;\n}\nconst breakers = new Map<string, Breaker>();\nconst MAX_FAILS = 2;\nconst BREAK_DURATION_MS = 25_000;\nconst HARD_TIMEOUT_MS = 12_000;\n\nfunction getBreaker(name: string): Breaker {\n if (!breakers.has(name)) {\n breakers.set(name, { failCount: 0, state: \"CLOSED\", nextAttempt: 0 });\n }\n return breakers.get(name)!;\n}\n\nfunction checkBreaker(name: string): boolean {\n const b = getBreaker(name);\n if (b.state === \"OPEN\" && Date.now() >= b.nextAttempt) {\n b.state = \"HALF_OPEN\";\n }\n return b.state === \"HALF_OPEN\" ||\n b.state === \"CLOSED\";\n}\n\nfunction reportBreaker(name: string, success: boolean) {\n const b = getBreaker(name);\n if (success) {\n b.failCount = 0;\n b.state = \"CLOSED\";\n } else {\n b.failCount++;\n if (\n b.failCount >= MAX_FAILS ||\n b.state === \"HALF_OPEN\"\n ) {\n b.state = \"OPEN\";\n b.nextAttempt = Date.now() + BREAK_DURATION_MS;\n b.failCount = 0;\n }\n }\n}\n\n// ============================================================================\n// 4. CORE INFERENCE ENGINE\n// ============================================================================\nasync function invokeProvider(\n provider: Provider,\n targetModel: string,\n messages: any[],\n tools?: any[],\n toolChoice?: any,\n) {\n const key = Deno.env.get(provider.keyEnv)!;\n const url = `${provider.base}/chat/completions`;\n\n const payload: any = {\n model: targetModel,\n messages,\n temperature: 0.0,\n stream: false,\n };\n if (tools && tools.length > 0) {\n payload.tools = tools;\n if (toolChoice) payload.tool_choice = toolChoice;\n }\n\n const controller = new AbortController();\n const timeoutId = setTimeout(() => controller.abort(), HARD_TIMEOUT_MS);\n\n try {\n const t0 = now();\n const res = await fetch(url, {\n method: \"POST\",\n headers: {\n \"Authorization\": `Bearer ${key}`,\n \"Content-Type\": \"application/json\",\n \"HTTP-Referer\": \"https://val.town\",\n \"X-Title\": \"Ziggyware-OmniRouter\",\n },\n body: JSON.stringify(payload),\n signal: controller.signal,\n });\n clearTimeout(timeoutId);\n if (!res.ok) {\n throw new Error(\n `HTTP ${res.status}: ${await res.text().catch(() => \"Unknown\")}`,\n );\n }\n\n const json = await res.json();\n if (!json.choices?.[0]?.message) throw new Error(\"Malformed JSON response\");\n\n return {\n message: json.choices[0].message,\n latencyMs: Math.round(now() - t0),\n modelUsed: targetModel,\n };\n } catch (e: any) {\n clearTimeout(timeoutId);\n throw new Error(\n e.name === \"AbortError\" ? \"API_STALLED_TIMEOUT\" : e.message,\n );\n }\n}\n\nasync function routeInference(\n messages: any[],\n tools?: any[],\n toolChoice?: any,\n) {\n while (inflight >= MAX_CONCURRENCY) await sleep(10);\n inflight++;\n\n try {\n const savedModels = await getSavedModels();\n const enabledProviders = getProviderArray();\n\n if (enabledProviders.length === 0) {\n throw new Error(\"NO_PROVIDERS_CONFIGURED\");\n }\n\n for (const provider of enabledProviders) {\n if (!checkBreaker(provider.name)) continue;\n const targetModel = savedModels[provider.name] ||\n provider.fallbackModel;\n\n try {\n const {\n message,\n latencyMs,\n modelUsed,\n } = await invokeProvider(\n provider,\n targetModel,\n messages,\n tools,\n toolChoice,\n );\n\n reportBreaker(provider.name, true);\n\n const resultPayload = {\n message,\n provider: provider,\n model: modelUsed,\n latencyMs,\n };\n\n return resultPayload;\n } catch (e: any) {\n reportBreaker(provider.name, false);\n console.warn(\n `[SEVERED] ${provider.name} failed (${e.message}). Routing next...`,\n );\n }\n }\n throw new Error(\"ALL_PROVIDERS_EXHAUSTED_OR_OPEN\");\n } finally {\n inflight--;\n }\n}\n\nexport default async function handler(req: Request): Promise<Response> {\n const url = new URL(req.url);\n\n // CORS & Preflight\n if (req.method === \"OPTIONS\") {\n return new Response(null, {\n headers: {\n \"Access-Control-Allow-Origin\": \"*\",\n \"Access-Control-Allow-Headers\": \"*\",\n \"Access-Control-Allow-Methods\": \"POST, GET, OPTIONS\",\n },\n });\n }\n\n // Ensure DB\n await initDB();\n if (req.method === \"GET\") {\n // --- API: Get Status ---\n if (url.pathname === \"/api/providers\") {\n const savedModels = await getSavedModels();\n const status = getProviderArray().map((p) => ({\n ...p,\n hasKey: !!Deno.env.get(p.keyEnv),\n currentModel: savedModels[p.name] || p.fallbackModel,\n })).sort((a, b) => a.priority - b.priority);\n return Response.json(status);\n }\n\n // --- API: Proxy Fetch Models ---\n if (url.pathname === \"/api/models\") {\n const pName = url.searchParams.get(\"provider\");\n const p = getProviderArray().find((x) => x.name === pName);\n if (!p) {\n return Response.json({ error: \"Provider not found\" }, { status: 404 });\n }\n\n const key = Deno.env.get(p.keyEnv);\n if (!key) {\n return Response.json({ error: \"Missing API Key\" }, { status: 401 });\n }\n\n try {\n const res = await fetch(`${p.base}/models`, {\n headers: { \"Authorization\": `Bearer ${key}` },\n });\n if (!res.ok) throw new Error(`HTTP ${res.status}`);\n const data = await res.json();\n return Response.json(data.data || data);\n } catch (e) {\n return Response.json({ error: e.message, fallback: p.fallbackModel }, {\n status: 500,\n });\n }\n }\n\n return new Response(\n `\n <!DOCTYPE html>\n <html lang=\"en\">\n <head>\n <meta charset=\"UTF-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n <title>Ziggyware AI Chat\n \n \n \n \n \n \n \n

\n \n \n \n `,\n { headers: { \"Content-Type\": \"text/html\" } },\n );\n } else if (req.method === \"POST\") {\n // --- API: Update SQLite DB ---\n if (url.pathname === \"/api/update\") {\n const { provider, model } = await req.json();\n await sqlite.execute({\n sql:\n `INSERT INTO omni_router_config (provider, selected_model) VALUES (?, ?) ON CONFLICT(provider) DO UPDATE SET selected_model = excluded.selected_model`,\n args: [provider, model],\n });\n return Response.json({ success: true });\n }\n\n try {\n const body = await req.json();\n const messages = body.messages ||\n (body.prompt ? [{ role: \"user\", content: body.prompt }] : []);\n if (!messages.length) {\n return new Response(\n JSON.stringify({ error: \"Empty message payload\" }),\n { status: 400 },\n );\n }\n const { message, provider, model, latencyMs } = await routeInference(\n messages,\n body.tools,\n body.tool_choice,\n );\n\n const activeGuards = getProviderArray()\n .filter((p) => Deno.env.get(p.keyEnv))\n .map(\n (p) => ({ name: p.name, state: getBreaker(p.name).state }),\n );\n\n const sseId = `chatcmpl-omni-${crypto.randomUUID()}`;\n\n if (body.stream) {\n const encoder = new TextEncoder();\n\n const stream = new ReadableStream({\n start(controller) {\n const sendChunk = (\n delta: any,\n finish_reason: string | null = null,\n ) => {\n controller.enqueue(encoder.encode(`data: ${\n JSON.stringify({\n id: sseId,\n object: \"chat.completion.chunk\",\n created: Math.floor(Date.now() / 1000),\n model: model,\n choices: [{ index: 0, delta, finish_reason }],\n _omni_meta: {\n provider: JSON.stringify(provider),\n latency_ms: latencyMs,\n inflight_requests: inflight,\n circuit_states: activeGuards,\n },\n })\n }\\n\\n`));\n };\n\n // 1. Role chunk\n sendChunk({ role: \"assistant\", content: \"\" });\n\n // 2. Content chunk\n if (message.content) sendChunk({ content: message.content });\n\n // 3. Tools chunk\n if (message.tool_calls) {\n sendChunk({ tool_calls: message.tool_calls });\n }\n\n // 4. Finish chunk\n sendChunk({}, message.tool_calls ? \"tool_calls\" : \"stop\");\n\n // 5. End Stream\n controller.enqueue(encoder.encode(\"data: [DONE]\\n\\n\"));\n controller.close();\n },\n });\n\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\",\n \"Cache-Control\": \"no-cache\",\n \"Connection\": \"keep-alive\",\n \"Access-Control-Allow-Origin\": \"*\",\n },\n });\n }\n\n return new Response(\n JSON.stringify({\n id: sseId,\n object: \"chat.completion\",\n created: Math.floor(Date.now() / 1000),\n model: model,\n choices: [{\n index: 0,\n message: message,\n finish_reason: message.tool_calls ? \"tool_calls\" : \"stop\",\n }],\n _omni_meta: {\n provider: provider,\n latency_ms: latencyMs,\n inflight_requests: inflight,\n circuit_states: activeGuards,\n },\n }),\n {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\",\n \"Access-Control-Allow-Origin\": \"*\",\n },\n },\n );\n } catch (e: any) {\n return new Response(\n JSON.stringify({\n error: {\n message: \"(error).\",\n details: e.message,\n },\n }),\n {\n status: 503,\n headers: {\n \"Content-Type\": \"application/json\",\n \"Access-Control-Allow-Origin\": \"*\",\n },\n },\n );\n }\n }\n\n return new Response(\"Not Found\", { status: 404 });\n}","inference-router",[],[722],"273340ae-9854-4838-aaed-d7c30d3e5c9d","_inference-router-dev.tsx","676ac11c-4595-11f1-99e3-42b51c65c3df",1191,["D",1783675963454],20,"import { getProviderArray } from \"./inference-provider.ts\";\nimport { all, initDB, type Row, run, sql } from \"./db.ts\";\n\ntype Provider = Row<\"provider\">;\n\nconst MAX_CONCURRENCY = 3;\nconst MAX_FAILS = 2;\nconst BREAK_DURATION_MS = 25_000;\nconst HARD_TIMEOUT_MS = 120_000;\nconst INFERENCE_TEMPERATURE = 0.0;\n\n// ============================================================================\n// 2. STATE MANAGEMENT (SQLite) & CACHING\n// ============================================================================\n// omni_router_config is already part of db.ts's shared Schema/DDL — initDB()\n// from db.ts creates it (and every other table) idempotently. The local\n// CREATE TABLE here was a second, drifting source of truth for the same\n// table and has been removed rather than kept \"just in case\" the two diverge.\n\nasync function getSavedModels(): Promise> {\n const r = await all(\n \"omni_router_config\",\n sql`SELECT * FROM omni_router_config`,\n );\n if (!r.ok) {\n console.error(\"getSavedModels failed:\", r.error);\n return {};\n }\n const map: Record = {};\n for (const row of r.value) map[row.provider] = row.selected_model;\n return map;\n}\n\nlet inflight = 0;\n\nconst sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));\nconst now = () => performance.now();\n\n// ============================================================================\n// 3. ENTERPRISE CIRCUIT BREAKER\n// ============================================================================\ntype BreakerState = \"CLOSED\" | \"OPEN\" | \"HALF_OPEN\";\ninterface Breaker {\n failCount: number;\n state: BreakerState;\n nextAttempt: number;\n}\nconst breakers = new Map();\n\nfunction getBreaker(name: string): Breaker {\n if (!breakers.has(name)) {\n breakers.set(name, { failCount: 0, state: \"CLOSED\", nextAttempt: 0 });\n }\n return breakers.get(name)!;\n}\n\nfunction checkBreaker(name: string): boolean {\n const b = getBreaker(name);\n if (b.state === \"OPEN\" && Date.now() >= b.nextAttempt) {\n b.state = \"HALF_OPEN\";\n }\n return b.state === \"HALF_OPEN\" || b.state === \"CLOSED\";\n}\n\nfunction reportBreaker(name: string, success: boolean) {\n const b = getBreaker(name);\n if (success) {\n b.failCount = 0;\n b.state = \"CLOSED\";\n } else {\n b.failCount++;\n if (b.failCount >= MAX_FAILS || b.state === \"HALF_OPEN\") {\n b.state = \"OPEN\";\n b.nextAttempt = Date.now() + BREAK_DURATION_MS;\n b.failCount = 0;\n }\n }\n}\n\n// ============================================================================\n// 4. CORE INFERENCE ENGINE\n// ============================================================================\nasync function invokeProvider(\n provider: Provider,\n targetModel: string,\n messages: any[],\n tools?: any[],\n toolChoice?: any,\n temperature: number = 0.0,\n maxTokens: number = 1024000,\n) {\n const key = Deno.env.get(provider.keyEnv!)!;\n const url = `${provider.base}/chat/completions`;\n\n const payload: any = {\n model: targetModel,\n messages,\n temperature: temperature,\n stream: false,\n max_tokens: maxTokens,\n };\n if (tools && tools.length > 0) {\n payload.tools = tools;\n if (toolChoice) payload.tool_choice = toolChoice;\n }\n\n const controller = new AbortController();\n const timeoutId = setTimeout(() => controller.abort(), HARD_TIMEOUT_MS);\n\n try {\n const t0 = now();\n const res = await fetch(url, {\n method: \"POST\",\n headers: {\n \"Authorization\": `Bearer ${key}`,\n \"Content-Type\": \"application/json\",\n \"HTTP-Referer\": \"https://val.town\",\n \"X-Title\": \"Ziggyware-OmniRouter\",\n },\n body: JSON.stringify(payload),\n signal: controller.signal,\n });\n clearTimeout(timeoutId);\n if (!res.ok) {\n throw new Error(\n `HTTP ${res.status}: ${await res.text().catch(() => \"Unknown\")}`,\n );\n }\n\n const json = await res.json();\n if (!json.choices?.[0]?.message) throw new Error(\"Malformed JSON response\");\n\n return {\n message: json.choices[0].message,\n latencyMs: Math.round(now() - t0),\n modelUsed: targetModel,\n provider: provider,\n };\n } catch (e: any) {\n clearTimeout(timeoutId);\n throw new Error(\n e.name === \"AbortError\" ? \"API_STALLED_TIMEOUT\" : e.message,\n );\n }\n}\n\nasync function routeInference(\n messages: any[],\n tools?: any[],\n toolChoice?: any,\n temperature: number = 0.0,\n maxTokens: number = 1024000,\n) {\n while (inflight >= MAX_CONCURRENCY) await sleep(10);\n inflight++;\n\n try {\n const savedModels = await getSavedModels();\n const enabledProviders = getProviderArray()\n .filter((p) => Deno.env.get(p.keyEnv!))\n .sort((a, b) => a.priority - b.priority);\n\n if (enabledProviders.length === 0) {\n throw new Error(\"NO_PROVIDERS_CONFIGURED\");\n }\n\n for (const prov of enabledProviders) {\n if (!checkBreaker(prov.name)) continue;\n const targetModel = savedModels[prov.name] || prov.fallbackModel!;\n\n try {\n const { message, latencyMs, modelUsed, provider } =\n await invokeProvider(\n prov,\n targetModel,\n messages,\n tools,\n toolChoice,\n temperature,\n maxTokens,\n );\n\n reportBreaker(provider.name, true);\n\n return { message, provider, model: modelUsed, latencyMs };\n } catch (e: any) {\n reportBreaker(prov.name, false);\n console.warn(\n `[SEVERED] ${prov.name} failed (${e.message}). Routing next...`,\n );\n }\n }\n throw new Error(\"ALL_PROVIDERS_EXHAUSTED_OR_OPEN\");\n } finally {\n inflight--;\n }\n}\n\nexport default async function handler(req: Request): Promise {\n const url = new URL(req.url);\n\n // CORS & Preflight\n if (req.method === \"OPTIONS\") {\n return new Response(null, {\n headers: {\n \"Access-Control-Allow-Origin\": \"*\",\n \"Access-Control-Allow-Headers\": \"*\",\n \"Access-Control-Allow-Methods\": \"POST, GET, OPTIONS\",\n },\n });\n }\n\n const init = await initDB();\n if (!init.ok) {\n return Response.json({ error: `DB init failed: ${init.error}` }, {\n status: 500,\n });\n }\n\n if (req.method === \"GET\") {\n if (url.pathname === \"/api/providers\") {\n const savedModels = await getSavedModels();\n const status = getProviderArray().map((p) => ({\n ...p,\n hasKey: !!Deno.env.get(p.keyEnv!),\n currentModel: savedModels[p.name] || p.fallbackModel,\n })).sort((a, b) => a.priority - b.priority);\n return Response.json(status);\n }\n\n if (url.pathname === \"/api/models\") {\n const pName = url.searchParams.get(\"provider\");\n const p = getProviderArray().find((x) => x.name === pName);\n if (!p) {\n return Response.json({ error: \"Provider not found\" }, { status: 404 });\n }\n const key = Deno.env.get(p.keyEnv!);\n if (!key) {\n return Response.json({ error: \"Missing API Key\" }, { status: 401 });\n }\n\n try {\n const res = await fetch(`${p.base}/models`, {\n headers: { \"Authorization\": `Bearer ${key}` },\n });\n if (!res.ok) throw new Error(`HTTP ${res.status}`);\n const data = await res.json();\n return Response.json(data.data || data);\n } catch (e: any) {\n return Response.json({ error: e.message, fallback: p.fallbackModel }, {\n status: 500,\n });\n }\n }\n\n return new Response(\n `\n \n \n \n \n \n Ziggyware Router Matrix\n \n \n \n \n \n \n \n

Invariant Lab

Multi‑provider claim graphs · invariants · disagreement spectra · ?mode=registry for JSON

\n \n

Technique

${TECHNIQUES[0].name}

${TECHNIQUES[0].goal}

Strata

Syntactic: ${\n TECHNIQUES[0].strata.syntactic\n }
Semantic: ${TECHNIQUES[0].strata.semantic}
Structural: ${\n TECHNIQUES[0].strata.structural\n }

Bayesian Δ & Invariants

${\n TECHNIQUES[0].bayesianDelta\n }

${x}

\n\n\n`;\n\n return new Response(html, {\n status: 200,\n headers: { \"Content-Type\": \"text/html; charset=utf-8\" },\n });\n}",[],[775],"cb8811d1-289c-458d-82f7-1683c0c29d43","README.md","da35d84a-5539-11f1-9b9a-ee650bb23af1",1334,["D",1788906328119],"# free-ai — omni router\n\nOpenAI-compatible endpoint that fans out across every configured provider with per-instance circuit breaking, model-level fallback, and live model discovery. Endpoint: `https://router.val.run`.\n\n## Call it\n\n```ts\nimport { omni } from \"https://esm.town/v/ziggyware/free-ai/omni-client.ts\";\nconst r = await omni.chat([{ role: \"user\", content: \"hi\" }], { model: \"coder\" });\nfor await (const tok of omni.stream(msgs)) process.stdout.write(tok);\n```\n\nOr any OpenAI SDK with `baseURL: \"https://router.val.run/v1\"`. Provenance comes back in `_omni_meta` (JSON) and `X-Omni-Provider` / `X-Omni-Model` headers (both modes).\n\n## `model` field\n\n| value | routes to |\n|---|---|\n| `auto` / `best` / empty | every free instance, **best model first** (catalog `QUALITY` prior; ties → vendor priority) |\n| `fast` | every instance in vendor priority (latency) order, catalog model order |\n| `coder` `reasoning` `long` `vision` | tagged vendors first, quality-ranked; `coder` boosts ids matching /coder/ |\n| `groq` | that vendor's instances (all keys) |\n| `groq#1` | one key slot |\n| `groq:openai/gpt-oss-120b` or `groq/openai/gpt-oss-120b` | that vendor, forced upstream id |\n\nUnknown values → 404, never silently rerouted.\n\nAll standard OpenAI params pass through (`tools`, `tool_choice`, `response_format`, `temperature`, `max_tokens`, `reasoning_effort`, `stop`, `top_p`, `seed`, …). Reasoning models (gpt-oss, qwen3.x) spend `max_tokens` on thinking first — send ≥256 or `reasoning_effort: \"low\"`, or you get `finish_reason: \"length\"` with empty content.\n\n## Keys (env / secrets)\n\nFor each vendor's `keyEnv` (see `catalog-free.ts`, `catalog-paid.ts`): `GROQ_API_KEY`, `GROQ_API_KEY1` … `GROQ_API_KEY9`, and any of those may hold `k1,k2,k3`. Every key becomes an instance (`groq`, `groq#1`, …) with its own cooldown. `cloudflare` also needs `CF_ACCOUNT_ID`.\n\n| env | effect |\n|---|---|\n| `OMNI_PROVIDERS` | JSON array of vendor rows, merged by `vendor` — add a vendor or override `models`/`priority`/`base` |\n| `OMNI_DISABLE` | `vendor,vendor` to skip |\n| `OMNI_QUALITY` | `{\"regex\":score}` — override/add quality scores (0–100) used by `auto` |\n| `OMNI_CLIENT_KEYS` | `k1,k2` — when set, callers must send `Authorization: Bearer k` (or `?key=`); `/` and `/health` stay open |\n\n## Failure policy\n\n| upstream | action |\n|---|---|\n| 404 / model-not-found / tier-not-allowed | mark that model dead 1 h, try next model; after the list, pick from live `/models` by the vendor's `prefer` regex and remember it |\n| 413 / \"Request too large\" / \"Limit N, Requested M\" | shrink `max_tokens` to fit and retry the same model; an output ceiling (\"OTPM\", \"max_tokens\") is remembered 15 min per model (`caps` in `/health`) |\n| 429 | cool the instance for `Retry-After` (≤15 min) or 60 s |\n| 401 / 403 | cool the instance 1 h |\n| 5xx / timeout (120 s) / network | breaker: 2 strikes → 25 s |\n\nAfter the first pass over every vendor, the router retries up to 2 more rounds — immediately for transient failures, or after waiting for the soonest cooldown when that fits the deadline. With `omni_deadline_ms` set, a vendor that cannot finish in the time left is skipped while a faster one is queued, and `max_tokens` is capped to what the vendor can stream before the deadline (a `finish_reason: \"length\"` reply beats a timeout — the client continues it).\n\nState lives in `omni_state` (SQLite) so it survives isolate recycling. `GET /health` shows what is cooling, dead, resolved, and capped.\n\n## Routes\n\n`GET /health` · `GET /v1/models` · `GET /api/providers` · `GET /api/models?provider=` · `POST /v1/chat/completions` (also `/`, `/chat/completions`) · `POST /api/update {provider, model}` binds a vendor's default · `GET /` matrix UI.\n",[],[783],["D",1777220541701],["D",1789508444194],{"_11":12,"_129":69},{"_11":12,"_125":-5,"_68":69,"_30":67,"_126":127,"_128":24},{"_39":116,"_13":16,"_33":36,"_117":79,"_118":-5,"_119":-5,"_120":-5,"_121":-5,"_122":-5,"_123":14,"_124":12},"ctx",{"_52":-5,"_149":828,"_829":830,"_831":832,"_833":24,"_834":24,"_835":24,"_836":147,"_837":-5,"_838":-7,"_839":-7,"_840":26,"_841":24,"_842":24,"_843":-5,"_844":24,"_845":24,"_846":24,"_847":-5},"ENV",{"_799":800,"_801":802,"_803":16,"_804":805,"_806":807,"_808":809,"_810":811,"_812":813,"_814":815,"_816":817,"_818":819,"_820":821,"_822":823,"_824":825,"_826":827},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

History · prompt-examples.ts