@tokenbuddy/tokenbuddy 1.0.5 → 1.0.7

package/dist/src/daemon.js

@@ -4,20 +4,302 @@ import { spawn } from "child_process";
 import * as fs from "fs";
 import { createModuleLogger } from "@tokenbuddy/logging";
 import { BuyerStore } from "./buyer-store.js";
-import { applyProviderInstall, detectProviders, previewProviderInstall, rollbackProviderInstall } from "./provider-install.js";
+import { applyProviderInstall, detectProviders, previewProviderInstall, rollbackProviderInstall, } from "./provider-install.js";
+import { discoverSellerBackedModels, fetchSellerManifest, fetchSellerRegistry, manifestModelIds, manifestPaymentMethods, manifestProtocols, normalizeSellerUrl, } from "./seller-catalog.js";
 const logger = createModuleLogger("tb-proxyd");
 const PROXY_JSON_BODY_LIMIT = "10mb";
+function numericHeaderField(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+class ResponsesStreamNormalizer {
+    pending = "";
+    state = new Map();
+    push(chunk) {
+        this.pending += chunk;
+        const blocks = this.pending.split("\n\n");
+        this.pending = blocks.pop() || "";
+        return blocks
+            .map((block) => this.normalizeBlock(block))
+            .filter((block) => block.length > 0)
+            .join("\n\n");
+    }
+    finish() {
+        if (!this.pending.trim()) {
+            return "";
+        }
+        const block = this.normalizeBlock(this.pending);
+        this.pending = "";
+        return block;
+    }
+    normalizeBlock(block) {
+        if (!block.trim()) {
+            return "";
+        }
+        // Each \n\n separates an event in SSE format
+        const subBlocks = block.split("\n\n");
+        const output = [];
+        for (const sub of subBlocks) {
+            if (!sub.trim() || sub.trim() === "data: [DONE]") {
+                if (sub.trim())
+                    output.push(sub);
+                continue;
+            }
+            const lines = sub.split("\n");
+            const eventLine = lines.find((l) => l.startsWith("event:"));
+            const dataLine = lines.find((l) => l.startsWith("data:"));
+            if (!dataLine) {
+                output.push(sub);
+                continue;
+            }
+            const rawData = dataLine.replace(/^data:\s?/, "");
+            if (rawData === "[DONE]") {
+                output.push(sub);
+                continue;
+            }
+            let payload;
+            try {
+                payload = JSON.parse(rawData);
+            }
+            catch {
+                output.push(sub);
+                continue;
+            }
+            const eventName = (eventLine?.replace(/^event:\s?/, "") || payload?.type);
+            if (!eventName || !eventName.startsWith("response.")) {
+                output.push(sub);
+                continue;
+            }
+            // When upstream already sends content_part.added, record it in state
+            if (eventName === "response.content_part.added" &&
+                payload?.item_id) {
+                const current = this.state.get(payload.item_id);
+                if (current)
+                    current.contentPartStarted = true;
+                output.push(sub);
+                continue;
+            }
+            // response.output_item.added: inject content_part.added only if upstream hasn't
+            if (eventName === "response.output_item.added" &&
+                payload?.item?.type === "message" &&
+                payload?.item?.id) {
+                const itemId = payload.item.id;
+                const current = this.getState(itemId);
+                const item = { ...payload.item };
+                item.content = [{ type: "output_text", text: "", annotations: [] }];
+                output.push(this.serializeEvent(eventName, {
+                    ...payload,
+                    output_index: payload.output_index ?? 0,
+                    item
+                }));
+                if (!current.contentPartStarted) {
+                    current.contentPartStarted = true;
+                    output.push(this.serializeEvent("response.content_part.added", {
+                        type: "response.content_part.added",
+                        item_id: itemId,
+                        output_index: payload.output_index ?? 0,
+                        content_index: 0,
+                        part: { type: "output_text", text: "", annotations: [] }
+                    }));
+                }
+                continue;
+            }
+            // response.output_text.delta: inject content_part.added if missing
+            if (eventName === "response.output_text.delta" && payload?.item_id) {
+                const itemId = payload.item_id;
+                const current = this.getState(itemId);
+                if (!current.contentPartStarted) {
+                    current.contentPartStarted = true;
+                    output.push(this.serializeEvent("response.content_part.added", {
+                        type: "response.content_part.added",
+                        item_id: itemId,
+                        output_index: payload.output_index ?? 0,
+                        content_index: payload.content_index ?? 0,
+                        part: { type: "output_text", text: "", annotations: [] }
+                    }));
+                }
+                const deltaText = typeof payload.delta === "string"
+                    ? payload.delta
+                    : typeof payload.delta?.text === "string"
+                        ? payload.delta.text
+                        : "";
+                current.text += deltaText;
+                output.push(this.serializeEvent(eventName, {
+                    ...payload,
+                    output_index: payload.output_index ?? 0,
+                    content_index: payload.content_index ?? 0
+                }));
+                continue;
+            }
+            // response.output_text.done: also emit content_part.done
+            if (eventName === "response.output_text.done" && payload?.item_id) {
+                const itemId = payload.item_id;
+                const current = this.getState(itemId);
+                output.push(this.serializeEvent(eventName, {
+                    ...payload,
+                    output_index: payload.output_index ?? 0,
+                    content_index: payload.content_index ?? 0
+                }));
+                output.push(this.serializeEvent("response.content_part.done", {
+                    type: "response.content_part.done",
+                    item_id: itemId,
+                    output_index: payload.output_index ?? 0,
+                    content_index: payload.content_index ?? 0,
+                    part: { type: "output_text", text: current.text, annotations: [] }
+                }));
+                continue;
+            }
+            // response.output_item.done: normalize content to output_text type
+            if (eventName === "response.output_item.done" &&
+                payload?.item?.type === "message" &&
+                payload?.item?.id) {
+                const itemId = payload.item.id;
+                const current = this.getState(itemId);
+                const item = {
+                    ...payload.item,
+                    content: [{ type: "output_text", text: current.text, annotations: [] }]
+                };
+                output.push(this.serializeEvent(eventName, {
+                    ...payload,
+                    output_index: payload.output_index ?? 0,
+                    item
+                }));
+                continue;
+            }
+            // response.completed: patch output if empty
+            if (eventName === "response.completed" && payload?.response) {
+                const response = { ...payload.response };
+                if (!Array.isArray(response.output) || response.output.length === 0) {
+                    const first = this.state.values().next()
+                        .value;
+                    if (first) {
+                        response.output = [{
+                                id: first.itemId,
+                                type: "message",
+                                status: "completed",
+                                role: "assistant",
+                                content: [{ type: "output_text", text: first.text, annotations: [] }]
+                            }];
+                        response.output_text = first.text;
+                    }
+                }
+                output.push(this.serializeEvent(eventName, { ...payload, response }));
+                continue;
+            }
+            // All other events: pass through unchanged
+            output.push(sub);
+        }
+        return output.join("\n\n");
+    }
+    getState(itemId) {
+        const current = this.state.get(itemId);
+        if (current)
+            return current;
+        const created = { itemId, text: "", contentPartStarted: false };
+        this.state.set(itemId, created);
+        return created;
+    }
+    serializeEvent(name, data) {
+        return `event: ${name}\ndata: ${JSON.stringify(data)}`;
+    }
+}
+class SellerSettlementStreamExtractor {
+    pending = "";
+    settlement;
+    push(chunk) {
+        this.pending += chunk;
+        const blocks = this.pending.split("\n\n");
+        this.pending = blocks.pop() || "";
+        return blocks
+            .map((block) => this.processBlock(block))
+            .filter((block) => block.length > 0)
+            .join("\n\n");
+    }
+    finish() {
+        const downstream = this.pending.trim() ? this.processBlock(this.pending) : "";
+        this.pending = "";
+        return { downstream, settlement: this.settlement };
+    }
+    current() {
+        return this.settlement;
+    }
+    processBlock(block) {
+        if (!block.trim()) {
+            return "";
+        }
+        const lines = block.split("\n");
+        const eventLine = lines.find((line) => line.startsWith("event:"));
+        const eventName = eventLine?.replace(/^event:\s?/, "").trim();
+        if (eventName !== "tokenbuddy.settlement") {
+            return block;
+        }
+        const dataLine = lines.find((line) => line.startsWith("data:"));
+        if (!dataLine) {
+            return "";
+        }
+        const parsed = parseSellerSettlementObject(dataLine.replace(/^data:\s?/, ""));
+        if (parsed) {
+            this.settlement = parsed;
+        }
+        return "";
+    }
+}
+function parseSellerSettlementObject(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        const requestId = typeof parsed.requestId === "string"
+            ? parsed.requestId
+            : typeof parsed.request_id === "string"
+                ? parsed.request_id
+                : undefined;
+        const settledMicros = numericHeaderField(parsed.settledMicros ?? parsed.settled_micros);
+        const remainingCreditMicros = numericHeaderField(parsed.remainingCreditMicros ?? parsed.remaining_credit_micros);
+        if (!requestId || settledMicros === undefined || remainingCreditMicros === undefined) {
+            return undefined;
+        }
+        return {
+            requestId,
+            settledMicros,
+            settledUsdMicros: numericHeaderField(parsed.settledUsdMicros ?? parsed.settled_usd_micros),
+            remainingCreditMicros,
+            reservedBalanceMicros: numericHeaderField(parsed.reservedBalanceMicros ?? parsed.reserved_balance_micros),
+            spentMicros: numericHeaderField(parsed.spentMicros ?? parsed.spent_micros),
+            priceVersion: typeof parsed.priceVersion === "string"
+                ? parsed.priceVersion
+                : typeof parsed.price_version === "string"
+                    ? parsed.price_version
+                    : undefined
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 export class TokenbuddyDaemon {
     config;
     tokenStore;
     controlServer;
     proxyServer;
     selectionMode;
+    selectedSellerId;
     activePurchases = new Map();
     constructor(config) {
-        this.config = config;
-        this.selectionMode = config.selectionMode || "auto";
         this.tokenStore = new BuyerStore({ dbPath: config.dbPath });
+        const routingPreference = this.tokenStore.getDaemonRuntimeConfig("routing")
+            ?.config;
+        this.config = config;
+        this.selectionMode =
+            config.selectionMode ||
+                (routingPreference?.mode === "fixed" ? "manual" : routingPreference?.mode) ||
+                "auto";
+        this.selectedSellerId =
+            config.selectedSellerId || routingPreference?.sellerId;
     }
     activeControlPort() {
         const address = this.controlServer?.address?.();
@@ -28,39 +310,23 @@ export class TokenbuddyDaemon {
         return typeof address === "object" && address ? address.port : this.config.proxyPort;
     }
     async fetchRegistry() {
-        const response = await fetch(this.config.sellerRegistryUrl);
-        if (!response.ok) {
-            throw new Error(`registry returned ${response.status}`);
-        }
-        const data = await response.json();
-        if (!data || !Array.isArray(data.sellers)) {
-            throw new Error("registry response missing sellers");
-        }
-        return data;
-    }
-    async fetchSellerManifest(seller) {
-        const baseUrl = seller.url.replace(/\/+$/, "");
-        const response = await fetch(`${baseUrl}/manifest`);
-        if (!response.ok) {
-            throw new Error(`manifest returned ${response.status}`);
-        }
-        return await response.json();
+        return await fetchSellerRegistry(this.config.sellerRegistryUrl);
     }
     runtimeSummary() {
+        const sellerRoutingMode = this.selectedSellerId ? "fixed" : this.selectionMode;
         return {
             status: "running",
             pid: process.pid,
             controlPort: this.activeControlPort(),
             proxyPort: this.activeProxyPort(),
             selectionMode: this.selectionMode,
+            sellerRoutingMode,
+            selectedSellerId: this.selectedSellerId,
             dbPath: this.config.dbPath,
             sellerRegistryUrl: this.config.sellerRegistryUrl,
             store: this.tokenStore.summary()
         };
     }
-    normalizeSellerUrl(seller) {
-        return seller.url.replace(/\/+$/, "");
-    }
     endpointProtocol(endpoint) {
         if (endpoint === "/v1/chat/completions") {
             return "chat_completions";
@@ -84,17 +350,55 @@ export class TokenbuddyDaemon {
         }
         return undefined;
     }
-    manifestProtocols(manifest, seller) {
-        const protocols = manifest.supportedProtocols || manifest.supported_protocols || seller.supportedProtocols || [];
-        return protocols.includes("anthropic_messages") && !protocols.includes("messages")
-            ? [...protocols, "messages"]
-            : protocols;
+    stripLocalClaudeOneMMarker(modelId) {
+        const trimmed = modelId.trimEnd();
+        return trimmed.toLowerCase().endsWith("[1m]")
+            ? trimmed.slice(0, -4).trimEnd()
+            : trimmed;
     }
-    manifestPaymentMethods(manifest, seller) {
-        return manifest.paymentMethods || manifest.payment_methods || seller.paymentMethods || [];
+    resolveClaudeRoleModel(modelId) {
+        const runtimeConfig = this.tokenStore.getProviderRuntimeConfig("claude-code")?.config;
+        const stripped = this.stripLocalClaudeOneMMarker(modelId);
+        if (!runtimeConfig || runtimeConfig.selectionKind !== "claude-role-mapping") {
+            return stripped;
+        }
+        const lowered = stripped.toLowerCase();
+        if (lowered === "haiku" || lowered.startsWith("claude-haiku")) {
+            return runtimeConfig.roles.haiku?.upstreamModel || runtimeConfig.fallbackModel || stripped;
+        }
+        if (lowered === "sonnet" || lowered.startsWith("claude-sonnet")) {
+            return runtimeConfig.roles.sonnet?.upstreamModel || runtimeConfig.fallbackModel || stripped;
+        }
+        if (lowered === "opus" || lowered.startsWith("claude-opus")) {
+            return runtimeConfig.roles.opus?.upstreamModel || runtimeConfig.fallbackModel || stripped;
+        }
+        return runtimeConfig.fallbackModel || stripped;
     }
-    manifestModelIds(manifest) {
-        return (manifest.models || []).map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0);
+    resolveRouteModelId(endpoint, body) {
+        const requestedModelId = this.extractModelId(endpoint, body);
+        if (!requestedModelId) {
+            return {};
+        }
+        if (this.endpointProtocol(endpoint) === "messages") {
+            return {
+                requestedModelId,
+                resolvedModelId: this.resolveClaudeRoleModel(requestedModelId)
+            };
+        }
+        return {
+            requestedModelId,
+            resolvedModelId: requestedModelId
+        };
+    }
+    applyResolvedModelToBody(endpoint, body, resolvedModelId) {
+        const nextBody = { ...body };
+        if ("model" in nextBody) {
+            nextBody.model = resolvedModelId;
+        }
+        if (endpoint === "/v1/responses" && "model_id" in nextBody) {
+            nextBody.model_id = resolvedModelId;
+        }
+        return nextBody;
     }
     defaultPaymentMethod() {
         const payments = this.tokenStore.listPayments().filter((payment) => payment.enabled);
@@ -112,12 +416,15 @@ export class TokenbuddyDaemon {
         const registry = await this.fetchRegistry();
         const defaultSellers = registry.sellers.filter((seller) => seller.id === registry.defaultSeller);
         const backupSellers = registry.sellers.filter((seller) => seller.id !== registry.defaultSeller);
-        const sellers = this.selectionMode === "manual" ? defaultSellers : [...defaultSellers, ...backupSellers];
+        const manualSellers = this.selectedSellerId
+            ? registry.sellers.filter((seller) => seller.id === this.selectedSellerId)
+            : defaultSellers;
+        const sellers = this.selectionMode === "manual" ? manualSellers : [...defaultSellers, ...backupSellers];
         const routes = [];
         for (const seller of sellers) {
             let manifest;
             try {
-                manifest = await this.fetchSellerManifest(seller);
+                manifest = await fetchSellerManifest(seller);
             }
             catch (error) {
                 logger.warn("route.manifest.failed", "seller manifest unavailable during route selection", {
@@ -128,9 +435,9 @@ export class TokenbuddyDaemon {
                 });
                 continue;
             }
-            const protocols = this.manifestProtocols(manifest, seller);
-            const paymentMethods = this.manifestPaymentMethods(manifest, seller);
-            const modelIds = this.manifestModelIds(manifest);
+            const protocols = manifestProtocols(manifest, seller);
+            const paymentMethods = manifestPaymentMethods(manifest, seller);
+            const modelIds = manifestModelIds(manifest);
             if (!protocols.includes(protocol) || !paymentMethods.includes(paymentMethod) || !modelIds.includes(modelId)) {
                 continue;
             }
@@ -190,52 +497,10 @@ export class TokenbuddyDaemon {
         return route;
     }
     async listSellerBackedModels() {
-        const registry = await this.fetchRegistry();
-        const sellerResults = await Promise.all(registry.sellers.map(async (seller) => {
-            try {
-                const manifest = await this.fetchSellerManifest(seller);
-                const protocols = this.manifestProtocols(manifest, seller);
-                const paymentMethods = this.manifestPaymentMethods(manifest, seller);
-                const models = (manifest.models || []).map((model) => ({
-                    id: model.id,
-                    sellerId: seller.id,
-                    sellerName: seller.name,
-                    sellerUrl: seller.url,
-                    supportedProtocols: protocols,
-                    paymentMethods
-                }));
-                return {
-                    seller: {
-                        id: seller.id,
-                        name: seller.name,
-                        url: seller.url,
-                        status: "ok",
-                        manifestSellerId: manifest.sellerId || manifest.seller_id || seller.id
-                    },
-                    models
-                };
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.warn("models.refresh.seller_failed", "seller manifest refresh failed", {
-                    sellerId: seller.id,
-                    errorMessage
-                });
-                return {
-                    seller: {
-                        id: seller.id,
-                        name: seller.name,
-                        url: seller.url,
-                        status: "failed",
-                        errorMessage
-                    },
-                    models: []
-                };
-            }
-        }));
+        const catalog = await discoverSellerBackedModels(this.config.sellerRegistryUrl);
         return {
-            models: sellerResults.flatMap((result) => result.models),
-            sellers: sellerResults.map((result) => result.seller)
+            models: catalog.models,
+            sellers: catalog.sellers
         };
     }
     readUsage(bodyText) {
@@ -261,6 +526,125 @@ export class TokenbuddyDaemon {
             return fallback;
         }
     }
+    parseSellerSettlementSummary(headers) {
+        const raw = headers.get("x-tokenbuddy-settlement");
+        if (!raw) {
+            return undefined;
+        }
+        return parseSellerSettlementObject(raw);
+    }
+    recordReconciledInference(route, endpoint, requestId, usage, settlement, prompt, response) {
+        if (settlement) {
+            this.tokenStore.reconcileTokenBalance({
+                sellerKey: route.seller.id,
+                balanceMicros: settlement.remainingCreditMicros,
+                reservedMicros: settlement.reservedBalanceMicros ?? 0,
+                spentMicros: settlement.spentMicros ?? 0,
+                balanceSource: "seller_settlement_summary"
+            });
+        }
+        const settledMicros = settlement?.settledMicros;
+        this.tokenStore.recordInferenceLedger({
+            requestId: settlement?.requestId || requestId,
+            sellerKey: route.seller.id,
+            modelId: route.modelId,
+            endpoint,
+            status: settlement ? "settled" : "estimated",
+            promptTokens: usage.promptTokens,
+            completionTokens: usage.completionTokens,
+            billedMicros: settledMicros ?? usage.billedMicros,
+            estimatedMicros: usage.billedMicros,
+            settledMicros,
+            settledUsdMicros: settlement?.settledUsdMicros,
+            priceVersion: settlement?.priceVersion,
+            balanceSnapshotMicros: settlement?.remainingCreditMicros,
+            balanceSource: settlement ? "seller_authoritative" : "estimated",
+            prompt,
+            response
+        });
+        logger.info("inference.ledger.recorded", "safe inference ledger recorded", {
+            requestId: settlement?.requestId || requestId,
+            sellerKey: route.seller.id,
+            model: route.modelId,
+            endpoint,
+            status: settlement ? "settled" : "estimated",
+            estimatedMicros: usage.billedMicros,
+            settledMicros,
+            balanceSource: settlement ? "seller_authoritative" : "estimated"
+        });
+    }
+    async refreshSellerBalance(route, token, balanceSource) {
+        const sellerKey = route.seller.id;
+        const sellerUrl = normalizeSellerUrl(route.seller);
+        const response = await fetch(`${sellerUrl}/v1/balance`, {
+            headers: { "Authorization": `Bearer ${token}` }
+        });
+        if (!response.ok) {
+            logger.warn("token.balance_refresh.failed", "seller balance refresh failed", {
+                sellerKey,
+                model: route.modelId,
+                status: response.status
+            });
+            return undefined;
+        }
+        const data = await response.json();
+        const creditMicros = numericHeaderField(data.creditMicros ?? data.credit_micros) ?? 0;
+        const reservedMicros = numericHeaderField(data.reservedMicros ?? data.reserved_micros) ?? 0;
+        const spentMicros = numericHeaderField(data.spentMicros ?? data.spent_micros) ?? 0;
+        const snapshot = {
+            creditMicros,
+            reservedMicros,
+            spentMicros,
+            availableMicros: Math.max(0, creditMicros - reservedMicros)
+        };
+        this.tokenStore.reconcileTokenBalance({
+            sellerKey,
+            balanceMicros: snapshot.availableMicros,
+            reservedMicros,
+            spentMicros,
+            balanceSource
+        });
+        logger.info("token.balance_refresh.succeeded", "seller balance refreshed", {
+            sellerKey,
+            model: route.modelId,
+            availableMicros: snapshot.availableMicros,
+            reservedMicros,
+            spentMicros,
+            balanceSource
+        });
+        return snapshot;
+    }
+    isInsufficientFundsResponse(status, bodyText) {
+        if (status !== 402) {
+            return false;
+        }
+        try {
+            const parsed = JSON.parse(bodyText);
+            const code = parsed.error?.code || "";
+            const message = parsed.error?.message || "";
+            return code === "insufficient_funds" || /insufficient funds/i.test(message);
+        }
+        catch {
+            return /insufficient funds/i.test(bodyText);
+        }
+    }
+    async recoverFromInsufficientFunds(route, token) {
+        const sellerKey = route.seller.id;
+        this.tokenStore.markTokenStale(sellerKey);
+        const snapshot = await this.refreshSellerBalance(route, token, "seller_402_refresh");
+        const rebuyMinBalanceMicros = this.tokenRebuyMinBalanceMicros();
+        if (!snapshot || snapshot.availableMicros <= rebuyMinBalanceMicros) {
+            logger.info("purchase.retry_after_402.started", "seller 402 triggered one-shot auto purchase retry", {
+                sellerKey,
+                model: route.modelId,
+                availableMicros: snapshot?.availableMicros ?? 0,
+                rebuyMinBalanceMicros
+            });
+            return await this.getOrPurchaseToken(route);
+        }
+        const cached = this.tokenStore.getToken(sellerKey);
+        return cached?.token || token;
+    }
     inferPromptForHash(body) {
         if (!body || typeof body !== "object") {
             return undefined;
@@ -286,7 +670,7 @@ export class TokenbuddyDaemon {
     }
     async getOrPurchaseToken(route) {
         const sellerKey = route.seller.id;
-        const sellerUrl = this.normalizeSellerUrl(route.seller);
+        const sellerUrl = normalizeSellerUrl(route.seller);
         const { modelId, paymentMethod } = route;
         const cached = this.tokenStore.getToken(sellerKey);
         const rebuyMinBalanceMicros = this.tokenRebuyMinBalanceMicros();
@@ -461,7 +845,7 @@ export class TokenbuddyDaemon {
         const timeoutMs = this.clawtipProofTimeoutMs();
         const payload = JSON.stringify({
             sellerKey: route.seller.id,
-            sellerUrl: this.normalizeSellerUrl(route.seller),
+            sellerUrl: normalizeSellerUrl(route.seller),
             modelId: route.modelId,
             purchase: createData,
             paymentInstructions: createData.paymentInstructions || createData.payment_instructions,
@@ -542,7 +926,7 @@ export class TokenbuddyDaemon {
     copyUpstreamHeaders(upstreamResponse, res) {
         upstreamResponse.headers.forEach((value, key) => {
             const lowerKey = key.toLowerCase();
-            if (["connection", "keep-alive", "transfer-encoding", "upgrade"].includes(lowerKey)) {
+            if (["connection", "content-encoding", "content-length", "keep-alive", "transfer-encoding", "upgrade"].includes(lowerKey)) {
                 return;
             }
             res.setHeader(key, value);
@@ -551,7 +935,8 @@ export class TokenbuddyDaemon {
     async forwardProxyRequest(endpoint, req, res) {
         const startedAt = Date.now();
         const body = req.body || {};
-        const modelId = this.extractModelId(endpoint, body);
+        const { requestedModelId, resolvedModelId } = this.resolveRouteModelId(endpoint, body);
+        const modelId = resolvedModelId;
         const requestId = req.header("x-request-id") || (body && typeof body === "object" ? body.requestId : undefined) || `proxy_req_${crypto.randomBytes(8).toString("hex")}`;
         const idempotencyKey = req.header("idempotency-key") || `idem_${crypto.randomBytes(12).toString("hex")}`;
         if (!modelId) {
@@ -570,23 +955,16 @@ export class TokenbuddyDaemon {
                         requestId,
                         sellerKey,
                         model: modelId,
+                        requestedModel: requestedModelId,
                         endpoint,
                         stream: Boolean(body.stream)
                     });
-                    const token = await this.getOrPurchaseToken(route);
-                    const sellerUrl = this.normalizeSellerUrl(route.seller);
-                    const upstreamBody = {
+                    const sellerUrl = normalizeSellerUrl(route.seller);
+                    const upstreamBody = this.applyResolvedModelToBody(endpoint, {
                         ...body,
                         requestId
-                    };
-                    logger.info("proxy.upstream_fetch.started", "proxy upstream fetch started", {
-                        requestId,
-                        sellerKey,
-                        model: modelId,
-                        endpoint,
-                        stream: Boolean(body.stream)
-                    });
-                    const upstreamResponse = await fetch(`${sellerUrl}${endpoint}`, {
+                    }, modelId);
+                    const sendSellerRequest = async (token) => fetch(`${sellerUrl}${endpoint}`, {
                         method: "POST",
                         headers: {
                             "Content-Type": "application/json",
@@ -596,25 +974,64 @@ export class TokenbuddyDaemon {
                         },
                         body: JSON.stringify(upstreamBody)
                     });
+                    logger.info("proxy.upstream_fetch.started", "proxy upstream fetch started", {
+                        requestId,
+                        sellerKey,
+                        model: modelId,
+                        endpoint,
+                        stream: Boolean(body.stream)
+                    });
+                    let token = await this.getOrPurchaseToken(route);
+                    let upstreamResponse = await sendSellerRequest(token);
                     if (!upstreamResponse.ok) {
                         const errorBody = await upstreamResponse.text();
-                        logger.warn("proxy.upstream_fetch.failed", "proxy upstream fetch returned non-ok status", {
-                            requestId,
-                            sellerKey,
-                            model: modelId,
-                            endpoint,
-                            status: upstreamResponse.status,
-                            durationMs: Date.now() - startedAt
-                        });
-                        if (this.shouldFailoverStatus(upstreamResponse.status) && routeIndex < routes.length - 1) {
-                            lastError = new Error(`seller ${sellerKey} returned ${upstreamResponse.status}`);
-                            this.logFailover(route, endpoint, routeIndex, "upstream_status", upstreamResponse.status);
-                            continue;
+                        if (this.isInsufficientFundsResponse(upstreamResponse.status, errorBody)) {
+                            token = await this.recoverFromInsufficientFunds(route, token);
+                            upstreamResponse = await sendSellerRequest(token);
+                            if (upstreamResponse.ok) {
+                                logger.info("proxy.retry_after_402.succeeded", "seller request succeeded after one-shot auto purchase retry", {
+                                    requestId,
+                                    sellerKey,
+                                    model: modelId,
+                                    endpoint,
+                                    durationMs: Date.now() - startedAt
+                                });
+                            }
+                            else {
+                                const retryErrorBody = await upstreamResponse.text();
+                                logger.warn("proxy.retry_after_402.failed", "seller request still failed after one-shot auto purchase retry", {
+                                    requestId,
+                                    sellerKey,
+                                    model: modelId,
+                                    endpoint,
+                                    status: upstreamResponse.status,
+                                    durationMs: Date.now() - startedAt
+                                });
+                                this.copyUpstreamHeaders(upstreamResponse, res);
+                                res.status(upstreamResponse.status);
+                                res.send(retryErrorBody);
+                                return;
+                            }
+                        }
+                        else {
+                            logger.warn("proxy.upstream_fetch.failed", "proxy upstream fetch returned non-ok status", {
+                                requestId,
+                                sellerKey,
+                                model: modelId,
+                                endpoint,
+                                status: upstreamResponse.status,
+                                durationMs: Date.now() - startedAt
+                            });
+                            if (this.shouldFailoverStatus(upstreamResponse.status) && routeIndex < routes.length - 1) {
+                                lastError = new Error(`seller ${sellerKey} returned ${upstreamResponse.status}`);
+                                this.logFailover(route, endpoint, routeIndex, "upstream_status", upstreamResponse.status);
+                                continue;
+                            }
+                            this.copyUpstreamHeaders(upstreamResponse, res);
+                            res.status(upstreamResponse.status);
+                            res.send(errorBody);
+                            return;
                         }
-                        this.copyUpstreamHeaders(upstreamResponse, res);
-                        res.status(upstreamResponse.status);
-                        res.send(errorBody);
-                        return;
                     }
                     this.copyUpstreamHeaders(upstreamResponse, res);
                     res.status(upstreamResponse.status);
@@ -634,64 +1051,56 @@ export class TokenbuddyDaemon {
                             return;
                         }
                         let bytes = 0;
+                        const decoder = new TextDecoder();
+                        const responsesStreamNormalizer = new ResponsesStreamNormalizer();
+                        const settlementExtractor = new SellerSettlementStreamExtractor();
                         while (true) {
                             const { done, value } = await reader.read();
                             if (done) {
                                 break;
                             }
                             bytes += value.byteLength;
-                            res.write(Buffer.from(value));
+                            const chunk = decoder.decode(value, { stream: true });
+                            const sellerChunk = settlementExtractor.push(chunk);
+                            if (sellerChunk.length === 0) {
+                                continue;
+                            }
+                            if (endpoint === "/v1/responses") {
+                                const normalized = responsesStreamNormalizer.push(sellerChunk);
+                                if (normalized.length > 0) {
+                                    res.write(`${normalized}\n\n`);
+                                }
+                            }
+                            else {
+                                res.write(sellerChunk);
+                            }
+                        }
+                        const settlementTrailing = settlementExtractor.finish();
+                        if (settlementTrailing.downstream.length > 0) {
+                            if (endpoint === "/v1/responses") {
+                                const normalized = responsesStreamNormalizer.push(settlementTrailing.downstream);
+                                if (normalized.length > 0) {
+                                    res.write(`${normalized}\n\n`);
+                                }
+                            }
+                            else {
+                                res.write(settlementTrailing.downstream);
+                            }
+                        }
+                        if (endpoint === "/v1/responses") {
+                            const trailing = responsesStreamNormalizer.finish();
+                            if (trailing.length > 0) {
+                                res.write(`${trailing}\n\n`);
+                            }
                         }
                         res.end();
-                        const billedMicros = Math.max(1, bytes);
-                        this.tokenStore.deductBalance(sellerKey, billedMicros);
-                        this.tokenStore.recordInferenceLedger({
-                            requestId,
-                            sellerKey,
-                            modelId,
-                            endpoint,
-                            status: "settled",
-                            promptTokens: 0,
-                            completionTokens: 0,
-                            billedMicros,
-                            prompt: this.inferPromptForHash(body)
-                        });
-                        logger.info("inference.ledger.recorded", "safe inference ledger recorded", {
-                            requestId,
-                            sellerKey,
-                            model: modelId,
-                            endpoint,
-                            status: "settled",
-                            billedMicros
-                        });
+                        this.recordReconciledInference(route, endpoint, requestId, { promptTokens: 0, completionTokens: 0, billedMicros: Math.max(1, bytes) }, this.parseSellerSettlementSummary(upstreamResponse.headers) ?? settlementTrailing.settlement ?? settlementExtractor.current(), this.inferPromptForHash(body));
                         return;
                     }
                     const responseBody = await upstreamResponse.text();
                     res.send(responseBody);
                     const usage = this.readUsage(responseBody);
-                    this.tokenStore.deductBalance(sellerKey, usage.billedMicros);
-                    this.tokenStore.recordInferenceLedger({
-                        requestId,
-                        sellerKey,
-                        modelId,
-                        endpoint,
-                        status: "settled",
-                        promptTokens: usage.promptTokens,
-                        completionTokens: usage.completionTokens,
-                        billedMicros: usage.billedMicros,
-                        prompt: this.inferPromptForHash(body),
-                        response: responseBody
-                    });
-                    logger.info("inference.ledger.recorded", "safe inference ledger recorded", {
-                        requestId,
-                        sellerKey,
-                        model: modelId,
-                        endpoint,
-                        status: "settled",
-                        promptTokens: usage.promptTokens,
-                        completionTokens: usage.completionTokens,
-                        billedMicros: usage.billedMicros
-                    });
+                    this.recordReconciledInference(route, endpoint, requestId, usage, this.parseSellerSettlementSummary(upstreamResponse.headers), this.inferPromptForHash(body), responseBody);
                     return;
                 }
                 catch (routeError) {
@@ -867,7 +1276,9 @@ export class TokenbuddyDaemon {
                 const changes = previewProviderInstall({
                     providers: Array.isArray(req.body?.providers) ? req.body.providers : [],
                     proxyUrl: String(req.body?.proxyUrl || ""),
-                    model: String(req.body?.model || ""),
+                    model: typeof req.body?.model === "string" ? req.body.model : undefined,
+                    providerSelections: req.body?.providerSelections,
+                    sellerRouting: req.body?.sellerRouting,
                     home: typeof req.body?.home === "string" ? req.body.home : undefined
                 });
                 logger.info("provider.install.previewed", "provider install previewed", {
@@ -894,7 +1305,9 @@ export class TokenbuddyDaemon {
                 const applied = applyProviderInstall({
                     providers: Array.isArray(req.body?.providers) ? req.body.providers : [],
                     proxyUrl: String(req.body?.proxyUrl || ""),
-                    model: String(req.body?.model || ""),
+                    model: typeof req.body?.model === "string" ? req.body.model : undefined,
+                    providerSelections: req.body?.providerSelections,
+                    sellerRouting: req.body?.sellerRouting,
                     home: typeof req.body?.home === "string" ? req.body.home : undefined
                 }, this.tokenStore);
                 logger.info("provider.install.applied", "provider install applied", {