@tokenbuddy/tokenbuddy 1.0.5 → 1.0.6

package/dist/src/daemon.js

@@ -4,20 +4,220 @@ 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";
+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)}`;
+    }
+}
 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 +228,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 +268,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;
+    }
+    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
+        };
     }
-    manifestModelIds(manifest) {
-        return (manifest.models || []).map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0);
+    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 +334,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 +353,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 +415,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) {
@@ -286,7 +469,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 +644,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 +725,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 +734,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,15 +754,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
-                    };
+                    }, modelId);
                     logger.info("proxy.upstream_fetch.started", "proxy upstream fetch started", {
                         requestId,
                         sellerKey,
@@ -634,13 +819,30 @@ export class TokenbuddyDaemon {
                             return;
                         }
                         let bytes = 0;
+                        const decoder = new TextDecoder();
+                        const responsesStreamNormalizer = new ResponsesStreamNormalizer();
                         while (true) {
                             const { done, value } = await reader.read();
                             if (done) {
                                 break;
                             }
                             bytes += value.byteLength;
-                            res.write(Buffer.from(value));
+                            if (endpoint === "/v1/responses") {
+                                const chunk = decoder.decode(value, { stream: true });
+                                const normalized = responsesStreamNormalizer.push(chunk);
+                                if (normalized.length > 0) {
+                                    res.write(`${normalized}\n\n`);
+                                }
+                            }
+                            else {
+                                res.write(Buffer.from(value));
+                            }
+                        }
+                        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);
@@ -867,7 +1069,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 +1098,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", {