@genkaku/protocol 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GenKaKu Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bridge.d.ts

@@ -0,0 +1,46 @@
+import type { Libp2p } from 'libp2p';
+import type { Hex } from 'viem';
+import type { ModeManager, RoleMode } from './modeManager.ts';
+import type { NetEnvironment } from './netconfig.ts';
+import { toWire } from './offer.ts';
+/** JSON served by GET /genkaku/status and rendered by GET /genkaku. */
+export type BridgeStatus = {
+    role: string;
+    workers: string[];
+    wallet: string;
+    offers: Array<{
+        addr: string;
+        offer: ReturnType<typeof toWire>;
+    }>;
+    url: string;
+};
+export type BridgeOptions = {
+    workers: string[];
+    port: number;
+    env: NetEnvironment;
+    modeManager: ModeManager;
+    getNode: () => Promise<Libp2p>;
+    userKey: () => Hex;
+    /** settle real escrows (Base Sepolia only); false = free/dev sessions */
+    settle: boolean;
+    log: (line: string) => void;
+    /** optional extra fields merged over the base status JSON (dashboard extension hook) */
+    status?: (base: BridgeStatus) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** optional live mode switch from POST /genkaku/mode */
+    onMode?: (mode: RoleMode) => void | Promise<void>;
+    /** P4.9h: derived credit per worker wallet (escrow events, not self-report).
+     *  Absent = offers keep whatever the worker claimed. */
+    credit?: (wallets: string[]) => Map<string, {
+        score: number;
+        sessions: number;
+    }> | Promise<Map<string, {
+        score: number;
+        sessions: number;
+    }>>;
+};
+export type BridgeHandle = {
+    url: string;
+    close: () => Promise<void>;
+};
+export declare function startOpenAiBridge(opts: BridgeOptions): Promise<BridgeHandle>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAa/B,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAgB,MAAM,EAAc,MAAM,YAAY,CAAA;AAI7D,uEAAuE;AACvE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,UAAU,CAAC,OAAO,MAAM,CAAC,CAAA;KAAE,CAAC,CAAA;IACjE,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,cAAc,CAAA;IACnB,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IAC9B,OAAO,EAAE,MAAM,GAAG,CAAA;IAClB,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAA;IACf,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3B,wFAAwF;IACxF,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAC3F,wDAAwD;IACxD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACjD;4DACwD;IACxD,MAAM,CAAC,EAAE,CACP,OAAO,EAAE,MAAM,EAAE,KACd,GAAG,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAA;CAClH,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B,CAAA;AA8ID,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAmblF"}

package/dist/bridge.js

@@ -0,0 +1,542 @@
+// GENKAKU for dsh: OpenAI-compatible bridge (user side).
+// The dsh agent loop talks plain OpenAI HTTP; this bridge dials a genkaku
+// worker over libp2p, meters the session with receipts, and settles the
+// escrow on Base Sepolia. No provider wire code leaks into dsh.
+import { appendFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { openEscrow, publicClientFor, readWorker, refundSession, settleSession, signReceiptPayload, walletAddress, walletClientFor, } from "./chain.js";
+import { dialWorker, fetchOffers, requestSettleCosign } from "./dial.js";
+import { dedupeOffers, toWire } from "./offer.js";
+import { bindingOf, peerIdOf } from "./registry.js";
+import { runUserSession } from "./userSession.js";
+const OFFERS_TTL_MS = 10_000;
+const SSE_TAIL = String.fromCharCode(10, 10);
+const SSE_DONE = 'data: ' + String.fromCharCode(91, 68, 79, 78, 69, 93) + SSE_TAIL;
+function textOf(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map(part => (typeof part === 'object' && part !== null && part.type === 'text'
+        ? String(part.text ?? '')
+        : ''))
+        .join('');
+}
+async function readJson(req) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of req) {
+        bytes += chunk.length;
+        if (bytes > 4 * 1024 * 1024)
+            throw new Error('request body too large');
+        chunks.push(chunk);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+}
+function json(res, status, body) {
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+/** Map a worker refusal to the HTTP status the caller should see. Payment
+ *  problems are 402 (retry after funding); verification/connectivity are 503
+ *  (retry shortly); anything else stays a generic failure. */
+function refusalStatus(code) {
+    switch (code) {
+        case 'payment-required':
+        case 'unknown-escrow':
+        case 'wrong-worker':
+        case 'closed-escrow':
+        case 'empty-escrow':
+        case 'bad-escrow':
+            return 402;
+        case 'chain-unavailable':
+        case 'paywall-error':
+            return 503;
+        default:
+            // No code means the worker itself was unreachable (dial/stream error).
+            return 502;
+    }
+}
+function failure(res, status, message) {
+    json(res, status, { error: { message, type: 'invalid_request_error' } });
+}
+const DEBUG_LOG = '/tmp/genkaku-bridge.log';
+/** Dev diagnostics: one line per request/error; logging never fails the request. */
+function debugLog(line) {
+    try {
+        appendFileSync(DEBUG_LOG, new Date().toISOString() + ' ' + line + String.fromCharCode(10));
+    }
+    catch {
+        // best effort
+    }
+}
+/** Self-contained status dashboard: no external assets, polls /genkaku/status. */
+const DASHBOARD_HTML = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>GENKAKU bridge</title>
+<style>
+body{font:14px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;margin:24px;background:#0b0d10;color:#d7dde5}
+h1{font-size:18px;margin:0 0 16px}
+.m{color:#7d8794;font-weight:400}
+.card{border:1px solid #222832;border-radius:8px;padding:12px;margin:12px 0;background:#11151b}
+b{color:#7d8794;font-weight:500;text-transform:uppercase;font-size:11px;letter-spacing:.08em;display:block;margin-bottom:4px}
+table{border-collapse:collapse;width:100%}
+td,th{text-align:left;padding:4px 8px;border-bottom:1px solid #1c222b}
+th{color:#7d8794;font-weight:500}
+.actions{display:flex;gap:8px;flex-wrap:wrap}
+button{background:#1b2330;color:#d7dde5;border:1px solid #2a323d;border-radius:4px;padding:4px 10px;cursor:pointer}
+</style>
+</head>
+<body>
+<h1>GENKAKU <span class="m">bridge</span></h1>
+<div id="root">loading...</div>
+<script>
+var e=function(v){return String(v==null?'':v).replace(/[&<>"']/g,function(c){return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]})};
+function usdc(v){var n=Number(v);return isFinite(n)?(n/1e6).toFixed(2):e(v)}
+function short(v){v=String(v||'');return v.length>12?v.slice(0,6)+'...'+v.slice(-4):v}
+function card(label,value){return '<div class="card"><b>'+label+'</b>'+e(value)+'</div>'}
+function switchMode(mode){
+  fetch('/genkaku/mode',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({mode:mode})})
+    .then(function(res){return res.json().then(function(body){return {ok:res.ok,body:body}})})
+    .then(function(r){
+      if(!r.ok||!r.body.ok){throw new Error((r.body.error&&r.body.error.message)||'mode switch failed')}
+      setTimeout(function(){location.reload()},2000);
+    })
+    .catch(function(err){alert('Mode switch failed: '+(err&&err.message?err.message:String(err)))});
+}
+function roleRow(role){
+  return '<div class="card"><b>role: '+e(role)+'</b><div class="actions">'
+    +'<button type="button" data-mode="user">user</button>'
+    +'<button type="button" data-mode="localPlusSharing">localPlusSharing</button>'
+    +'<button type="button" data-mode="workerDedicated">workerDedicated</button>'
+    +'</div></div>';
+}
+document.addEventListener('click',function(ev){
+  var t=ev.target;
+  if(t&&t.getAttribute&&t.getAttribute('data-mode')){switchMode(t.getAttribute('data-mode'))}
+});
+async function load(){
+  var root=document.getElementById('root');
+  try{
+    var res=await fetch('/genkaku/status',{cache:'no-store'});
+    var s=await res.json();
+    var rows=(s.offers||[]).map(function(r){var o=r.offer||{};return '<tr><td>'+e(o.model)+'</td><td>'+e(o.workerName)+'</td><td>'+usdc(o.pricePerHour)+'</td><td>'+e(o.creditScore)+'</td><td>'+e(short(o.workerWallet))+'</td><td>'+e(r.addr)+'</td></tr>'}).join('');
+    var table='<div class="card"><b>offers</b><table><tr><th>model</th><th>worker</th><th>USDC/hour</th><th>credit</th><th>wallet</th><th>peer</th></tr>'+(rows||'<tr><td colspan="6">no offers</td></tr>')+'</table></div>';
+    root.innerHTML=roleRow(s.role)+card('bridge url',s.url)+card('wallet',s.wallet)+card('workers',(s.workers||[]).join(', '))+table;
+  }catch(err){
+    root.innerHTML='<div class="card">status unavailable: '+e(err&&err.message?err.message:String(err))+'</div>';
+  }
+}
+load();
+setInterval(load,5000);
+</script>
+</body>
+</html>`;
+export async function startOpenAiBridge(opts) {
+    const cache = new Map();
+    let bridgeUrl = '';
+    async function offersOf(addr) {
+        const hit = cache.get(addr);
+        if (hit != null && Date.now() - hit.at < OFFERS_TTL_MS)
+            return hit.offers;
+        const node = await opts.getNode();
+        const offers = await fetchOffers(node, addr);
+        cache.set(addr, { at: Date.now(), offers });
+        return offers;
+    }
+    async function board() {
+        const rows = await Promise.all(opts.workers.map(async (addr) => {
+            try {
+                return (await offersOf(addr)).map(offer => ({ addr, offer }));
+            }
+            catch (error) {
+                opts.log(`offers: ${addr} unreachable (${error instanceof Error ? error.message : String(error)})`);
+                return [];
+            }
+        }));
+        return dedupeOffers(rows.flat());
+    }
+    /** P4.4 close-out: ask the worker to co-sign the held max-cumulative receipt,
+     *  then settle the escrow with that signature. Refused/failed settlements are
+     *  logged but never fail the HTTP response — the tokens already flowed. */
+    async function settle(args) {
+        let cosign;
+        try {
+            cosign = await requestSettleCosign(args.node, args.addr, {
+                jobId: args.jobId,
+                escrowId: args.escrowId,
+                receiptHash: args.receiptHash,
+                spend: args.spend,
+            });
+        }
+        catch (error) {
+            const message = `settle ${args.jobId}: co-sign unreachable (${error instanceof Error ? error.message : String(error)})`;
+            debugLog(message);
+            opts.log(message);
+            return;
+        }
+        if (!cosign.ok || cosign.sig == null) {
+            debugLog(`settle ${args.jobId}: worker refused (${cosign.reason ?? 'no reason'})`);
+            opts.log(`settle ${args.jobId}: worker refused (${cosign.reason ?? 'no reason'})`);
+            return;
+        }
+        try {
+            const txHash = await settleSession(args.walletC, opts.env, {
+                escrowId: BigInt(args.escrowId),
+                receiptHash: args.receiptHash,
+                spend: args.spend,
+                workerSig: cosign.sig,
+            });
+            debugLog(`settle ${args.jobId}: escrow ${args.escrowId}, spend ${args.spend}, tx ${txHash}`);
+            opts.log(`settle ${args.jobId}: escrow ${args.escrowId}, spend ${args.spend}, tx ${txHash}`);
+        }
+        catch (error) {
+            const message = `settle ${args.jobId}: tx failed (${error instanceof Error ? error.message : String(error)})`;
+            debugLog(message);
+            opts.log(message);
+        }
+    }
+    const models = async (res) => {
+        const rows = await board();
+        const seen = new Set();
+        const data = [];
+        for (const { offer } of rows) {
+            if (seen.has(offer.model))
+                continue;
+            seen.add(offer.model);
+            data.push({ id: offer.model, object: 'model', owned_by: 'genkaku' });
+        }
+        json(res, 200, { object: 'list', data });
+    };
+    const status = async (res) => {
+        const { mode } = opts.modeManager.current();
+        const rows = await board();
+        const wallets = rows
+            .map(row => row.offer.workerWallet)
+            .filter((w) => w != null && w.startsWith('0x'));
+        const credits = opts.credit == null || wallets.length === 0 ? null : await opts.credit(wallets);
+        const offers = rows.map((row) => {
+            const score = row.offer.workerWallet == null ? undefined : credits?.get(row.offer.workerWallet.toLowerCase());
+            const offer = score == null
+                ? row.offer
+                : { ...row.offer, creditScore: score.score, sessionsServed: score.sessions, creditSource: 'chain' };
+            return { addr: row.addr, offer: toWire(offer) };
+        });
+        const base = {
+            role: mode,
+            workers: opts.workers,
+            wallet: walletAddress(opts.userKey()),
+            offers,
+            url: bridgeUrl,
+        };
+        const extra = opts.status == null ? undefined : await opts.status(base);
+        json(res, 200, extra == null ? base : { ...base, ...extra });
+    };
+    const dashboard = (res) => {
+        res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+        res.end(DASHBOARD_HTML);
+    };
+    const chat = async (req, res) => {
+        const body = await readJson(req);
+        debugLog('chat body=' + JSON.stringify(body));
+        const model = typeof body.model === 'string' ? body.model : '';
+        debugLog('chat model=' + (model === '' ? '(none)' : model));
+        const messages = Array.isArray(body.messages) ? body.messages : [];
+        const system = textOf(messages.find(m => m.role === 'system')?.content);
+        const prompt = messages
+            .filter(m => m.role === 'user')
+            .map(m => textOf(m.content))
+            .filter(text => text !== '')
+            .join('\n');
+        if (prompt === '')
+            return failure(res, 400, 'no user message');
+        const rows = await board();
+        const picked = rows.find(row => row.offer.model === model) ?? (rows.length === 1 ? rows[0] : undefined);
+        if (picked == null)
+            return failure(res, 404, `model "${model}" is not offered by any configured worker`);
+        if (picked.offer.workerWallet?.startsWith('0x')) {
+            const wallet = picked.offer.workerWallet;
+            const peerId = peerIdOf(picked.addr);
+            const proven = picked.offer.walletVerified === true;
+            try {
+                const record = await readWorker(publicClientFor(opts.env), opts.env, wallet);
+                const binding = peerId == null ? 'absent' : bindingOf(record, peerId);
+                if (binding === 'mismatch') {
+                    opts.log(`registry: ${wallet} is bound to a different peer than ${picked.addr}`);
+                    return failure(res, 403, `worker wallet ${wallet} is not bound to ${picked.addr}; refusing to start the session`);
+                }
+                // P4.9e: the hello handshake proves key possession directly. Without
+                // it the on-chain binding is the only evidence — and it is a claim the
+                // wallet made, not proof that this peer holds the key. A paid session
+                // (real escrow) requires one of the two.
+                if (binding !== 'bound' && !proven && opts.settle) {
+                    opts.log(`identity: ${wallet} at ${picked.addr} is neither proven nor bound — refusing a paid session`);
+                    return failure(res, 403, `could not verify that ${picked.addr} controls wallet ${wallet}`);
+                }
+                if (binding !== 'bound' && !proven) {
+                    opts.log(`registry: ${wallet} has no active binding yet — continuing under testnet grace (unpaid)`);
+                    debugLog('registry absent wallet=' + wallet + ' addr=' + picked.addr);
+                }
+                debugLog(`identity: wallet=${wallet} proven=${proven} binding=${binding}`);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                opts.log(`registry: ${wallet} check failed (${message}) — continuing under testnet grace`);
+            }
+        }
+        const node = await opts.getNode();
+        const transport = await dialWorker(node, picked.addr);
+        const jobId = `dsh-${Date.now().toString(36)}`;
+        const created = Math.floor(Date.now() / 1000);
+        const id = `chatcmpl-${jobId}`;
+        const sse = body.stream !== false;
+        const maxTokens = Math.min(typeof body.max_tokens === 'number' ? body.max_tokens
+            : typeof body.max_completion_tokens === 'number' ? body.max_completion_tokens
+                : 256, 96);
+        let escrowId = '0';
+        let walletC = null;
+        if (opts.settle && picked.offer.workerWallet?.startsWith('0x')) {
+            walletC = walletClientFor(opts.env, opts.userKey());
+            const opened = await openEscrow(publicClientFor(opts.env), walletC, opts.env, picked.offer.workerWallet, picked.offer.pricePerHour);
+            escrowId = opened.escrowId.toString();
+        }
+        // Headers are written lazily, on the first byte the worker actually sends:
+        // a paywall refusal must be an HTTP error with a JSON body, not a 200 SSE
+        // stream that ends with no content (P4.9d).
+        let streamStarted = false;
+        const startStream = () => {
+            if (!sse || streamStarted || res.destroyed)
+                return;
+            streamStarted = true;
+            res.writeHead(200, {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache',
+                connection: 'keep-alive',
+            });
+            res.write(`data: ${JSON.stringify({
+                id, object: 'chat.completion.chunk', created, model: picked.offer.model,
+                choices: [{ index: 0, delta: { role: 'assistant', content: '' }, finish_reason: null }],
+            })}\n\n`);
+        };
+        const writeChunk = (delta, finish, usage) => {
+            if (!sse || res.destroyed)
+                return;
+            startStream();
+            const chunk = {
+                id, object: 'chat.completion.chunk', created, model: picked.offer.model,
+                choices: [{ index: 0, delta, finish_reason: finish }],
+            };
+            if (usage != null)
+                chunk.usage = usage;
+            res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+        };
+        let receiptHash = null;
+        let content = '';
+        const abort = () => { if (!res.writableEnded)
+            void transport.close(); };
+        // res, not req: IncomingMessage 'close' fires once the body is consumed.
+        res.on('close', abort);
+        try {
+            const result = await runUserSession({
+                jobId,
+                offer: picked.offer,
+                prompt,
+                system: system === '' ? undefined : system,
+                maxTokens,
+                transport,
+                modeManager: opts.modeManager,
+                escrowId,
+                env: opts.env,
+                signReceipt: async (receipt) => await signReceiptPayload(opts.userKey(), receipt),
+                emit: (event) => {
+                    if (event.type === 'token') {
+                        content += event.delta;
+                        writeChunk({ content: event.delta }, null);
+                    }
+                    else if (event.type === 'receipt-sent') {
+                        receiptHash = event.receiptHash;
+                    }
+                    else if (event.type === 'session-error') {
+                        opts.log(`session ${jobId}: ${event.message}`);
+                    }
+                },
+            });
+            if (result.failure != null) {
+                // The worker refused before answering (paywall, closed escrow, …).
+                // Nothing has been streamed yet, so this is still a clean HTTP error.
+                failure(res, refusalStatus(result.failure.code), result.failure.message);
+                return;
+            }
+            const usage = {
+                prompt_tokens: Math.ceil(prompt.length / 4),
+                completion_tokens: result.tokens,
+                total_tokens: Math.ceil(prompt.length / 4) + result.tokens,
+            };
+            if (sse) {
+                writeChunk({}, 'stop', usage); // finish
+                res.write(SSE_DONE);
+                res.end();
+            }
+            else {
+                json(res, 200, {
+                    id,
+                    object: 'chat.completion',
+                    created,
+                    model: picked.offer.model,
+                    choices: [{ index: 0, message: { role: 'assistant', content }, finish_reason: 'stop' }],
+                    usage,
+                });
+            }
+            if (opts.settle && walletC != null && escrowId !== '0') {
+                if (receiptHash != null && result.billed > 0n) {
+                    // The commitment the money is bound to — re-derive it offline from
+                    // the prompt/answer to audit a settle (P4.9f commit-challenge).
+                    debugLog(`receipt ${jobId}: hash=${receiptHash} billed=${result.billed} tokens=${result.tokens}`);
+                    await settle({
+                        node,
+                        addr: picked.addr,
+                        walletC,
+                        jobId,
+                        escrowId,
+                        receiptHash,
+                        spend: result.billed,
+                    });
+                }
+                else {
+                    // Nothing was billed (a session shorter than one started minute).
+                    // Return the escrow instead of leaving the user's money parked.
+                    try {
+                        const tx = await refundSession(walletC, opts.env, BigInt(escrowId));
+                        debugLog(`escrow ${escrowId}: nothing billed, refunded (tx ${tx})`);
+                        opts.log(`escrow ${escrowId}: nothing billed, refunded (tx ${tx})`);
+                    }
+                    catch (error) {
+                        const message = `escrow ${escrowId}: refund failed (${error instanceof Error ? error.message : String(error)})`;
+                        debugLog(message);
+                        opts.log(message);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const code = error instanceof Error ? error.code : undefined;
+            debugLog('chat error: ' + message);
+            opts.log('session ' + jobId + ': ' + message);
+            // The escrow was opened before the session; if anything threw before a
+            // settlement, the funds must go back instead of sitting in the contract
+            // (a non-technical user would never find the manual refund).
+            if (opts.settle && walletC != null && escrowId !== '0') {
+                try {
+                    const tx = await refundSession(walletC, opts.env, BigInt(escrowId));
+                    debugLog(`escrow ${escrowId}: session failed before settle, refunded (tx ${tx})`);
+                    opts.log(`escrow ${escrowId}: refunded after a failed session (tx ${tx})`);
+                }
+                catch (refundError) {
+                    debugLog(`escrow ${escrowId}: refund after failure failed (${refundError instanceof Error ? refundError.message : String(refundError)})`);
+                }
+            }
+            if (!res.headersSent) {
+                failure(res, refusalStatus(code), message);
+            }
+            else if (!res.writableEnded) {
+                res.end();
+            }
+        }
+        finally {
+            res.off('close', abort);
+        }
+    };
+    const server = createServer((req, res) => {
+        void (async () => {
+            try {
+                const path = (req.url ?? '/').split('?')[0] ?? '/';
+                if (req.method === 'GET' || req.method === 'POST' || req.method === 'OPTIONS') {
+                    res.setHeader('access-control-allow-origin', '*');
+                    res.setHeader('access-control-allow-methods', 'GET, POST, OPTIONS');
+                    res.setHeader('access-control-allow-headers', 'content-type');
+                }
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                if (req.method === 'POST' && (path === '/genkaku/mode' || path === '/genkaku/mode/')) {
+                    if (opts.onMode == null) {
+                        failure(res, 501, 'mode switching is not enabled');
+                        return;
+                    }
+                    let body;
+                    try {
+                        body = await readJson(req);
+                    }
+                    catch {
+                        failure(res, 400, 'invalid JSON body');
+                        return;
+                    }
+                    const mode = body.mode;
+                    if (mode !== 'user' && mode !== 'localPlusSharing' && mode !== 'workerDedicated') {
+                        failure(res, 400, 'mode must be one of user, localPlusSharing, workerDedicated');
+                        return;
+                    }
+                    await opts.onMode(mode);
+                    json(res, 200, { ok: true });
+                    return;
+                }
+                if (req.method === 'GET' && (path === '/genkaku/status' || path === '/genkaku/status/')) {
+                    await status(res);
+                    return;
+                }
+                if (req.method === 'GET' && (path === '/genkaku' || path === '/genkaku/')) {
+                    dashboard(res);
+                    return;
+                }
+                if (req.method === 'GET' && (path === '/v1/models' || path === '/models')) {
+                    await models(res);
+                    return;
+                }
+                if (req.method === 'POST' && (path === '/v1/chat/completions' || path === '/chat/completions')) {
+                    await chat(req, res);
+                    return;
+                }
+                failure(res, 404, 'unknown route: ' + (req.method ?? 'GET') + ' ' + path);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                debugLog('bridge error: ' + message);
+                opts.log('bridge: ' + message);
+                if (!res.headersSent) {
+                    failure(res, 500, message);
+                }
+                else if (!res.writableEnded) {
+                    res.end();
+                }
+            }
+        })();
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once('error', onError);
+        server.listen(opts.port, '127.0.0.1', () => {
+            server.off('error', onError);
+            resolve();
+        });
+    });
+    const bound = server.address();
+    const port = typeof bound === 'object' && bound !== null ? bound.port : opts.port;
+    bridgeUrl = 'http://127.0.0.1:' + port + '/v1';
+    return {
+        url: bridgeUrl,
+        close: async () => {
+            await new Promise((resolve, reject) => {
+                server.close(error => (error == null ? resolve() : reject(error)));
+                server.closeAllConnections();
+            });
+        },
+    };
+}
+//# sourceMappingURL=bridge.js.map