@tokenbuddy/tokenbuddy 1.0.35 → 1.0.37

package/dist/src/daemon.js

@@ -9,7 +9,7 @@ import { BuyerStore } from "./buyer-store.js";
 import { DEFAULT_CLAWTIP_BOOTSTRAP_URL, fetchClawtipBootstrap } from "./clawtip-bootstrap.js";
 import { inspectOpenClawWalletConfig, } from "./init-payment-options.js";
 import { startClawtipWalletBootstrap, waitForClawtipActivationConfirmation, } from "./init-clawtip-activation.js";
-import { applyProviderInstall, detectProviders, previewProviderInstall, rollbackProviderInstall, } from "./provider-install.js";
+import { applyProviderInstall, detectProviders, previewProviderInstall, PROXY_ACCESS_TOKEN_PLACEHOLDER, rollbackProviderInstall, } from "./provider-install.js";
 import { discoverSellerBackedModels, fetchSellerRegistryWithTrust, isBuyerVisibleRegistrySeller, normalizeSellerUrl, RegistryTooLargeError, } from "./seller-catalog.js";
 import { shouldVerifyRegistry, verifyTrustedRegistrySignature } from "./registry-trust.js";
 import { ModelIndex } from "./model-index.js";
@@ -33,6 +33,28 @@ const SELLER_CAPACITY_BLOCK_MS = 2_000;
 const CLAWTIP_STATIC_ROUTE = "/static/clawtip";
 const CLAWTIP_RECHARGE_QR_FILE = "recharge.png";
 const MANUAL_PROVIDER_SECRET_CONFIG_KEY = "manual-provider-secrets";
+const USER_INFERENCE_TEST_TIMEOUT_MS = 60_000;
+class BuyerPaymentSetupError extends Error {
+    errorCode;
+    statusCode;
+    constructor(message, errorCode = ErrorCode.PaymentMethodNotReady, statusCode = 402) {
+        super(message);
+        this.name = "BuyerPaymentSetupError";
+        this.errorCode = errorCode;
+        this.statusCode = statusCode;
+    }
+}
+const NON_FAILOVER_PURCHASE_ERROR_CODES = new Set([
+    ErrorCode.PaymentRequired,
+    ErrorCode.PaymentAccountInsufficient,
+    ErrorCode.PaymentMethodNotReady,
+    ErrorCode.PaymentAuthorizationRequired,
+    ErrorCode.PaymentCancelled,
+    ErrorCode.PaymentTimeout,
+    ErrorCode.PaymentProviderFailed,
+    ErrorCode.ClawtipCredentialInvalid,
+    ErrorCode.ClawtipOrderMismatch
+]);
 function currentModuleDir() {
     if (typeof __dirname !== "undefined") {
         return __dirname;
@@ -73,7 +95,7 @@ function buildCustomClientToolStatus(proxyPort) {
         manualConfig: {
             openaiBaseUrl,
             anthropicBaseUrl,
-            apiKey: "TOKENBUDDY_PROXY",
+            apiKey: PROXY_ACCESS_TOKEN_PLACEHOLDER,
         },
     };
 }
@@ -202,6 +224,20 @@ function imageCostMicrosPerImage(totalMicros, imageCount) {
     }
     return Math.ceil(totalMicros / imageCount);
 }
+function averageOutputTokensPerSecond(completionTokens, durationMs, ttftMs) {
+    if (!Number.isFinite(completionTokens) || !Number.isFinite(durationMs) || !Number.isFinite(ttftMs)) {
+        return undefined;
+    }
+    const outputTokens = completionTokens;
+    const outputWindowMs = durationMs - ttftMs;
+    if (outputWindowMs <= 0) {
+        return undefined;
+    }
+    if (outputTokens <= 0) {
+        return 0;
+    }
+    return outputTokens / (outputWindowMs / 1000);
+}
 function purchasePaymentSummaryFromQuote(value) {
     const quote = usageRecord(value);
     if (!quote)
@@ -388,6 +424,16 @@ function reorderDefaultSellerFirst(sellers, defaultSellerId) {
         ...sellers.filter((seller) => seller.id !== defaultSellerId)
     ];
 }
+function purchaseResponsePaymentSetupError(response, data, fallbackMessage) {
+    const errorCode = typeof data.error?.code === "string" ? data.error.code : undefined;
+    if (errorCode && NON_FAILOVER_PURCHASE_ERROR_CODES.has(errorCode)) {
+        return new BuyerPaymentSetupError(data.error?.message || fallbackMessage, errorCode, response.status || 402);
+    }
+    if (response.status === 402) {
+        return new BuyerPaymentSetupError(data.error?.message || fallbackMessage, ErrorCode.PaymentMethodNotReady, 402);
+    }
+    return undefined;
+}
 /**
  * buyer 端守护进程。
  * 负责启动两个 Express 服务：控制接口（healthz + 控制路由）+ 反向代理（OpenAI / Anthropic 协议入口）。
@@ -719,6 +765,14 @@ export class TokenbuddyDaemon {
     lastRegistrySnapshot = null;
     forceRegistrySnapshotForTest = false;
     async fetchRegistry() {
+        if (this.forceRegistrySnapshotForTest && this.lastRegistrySnapshot) {
+            this.modelIndex.rebuild(this.lastRegistrySnapshot.sellers, {
+                registryVersion: this.lastRegistrySnapshot.version,
+                defaultSellerId: this.lastRegistrySnapshot.defaultSeller
+            });
+            this.sellerPool.sync();
+            return this.lastRegistrySnapshot;
+        }
         try {
             const fetched = await fetchSellerRegistryWithTrust(this.config.sellerRegistryUrl);
             const registry = fetched.registry;
@@ -1375,6 +1429,19 @@ export class TokenbuddyDaemon {
         }
         return nextBody;
     }
+    withOpenAiStreamUsage(endpoint, body) {
+        if (endpoint !== "/v1/chat/completions" || body.stream !== true) {
+            return body;
+        }
+        const streamOptions = usageRecord(body.stream_options);
+        return {
+            ...body,
+            stream_options: {
+                ...(streamOptions ?? {}),
+                include_usage: true
+            }
+        };
+    }
     defaultPaymentMethod() {
         const payments = this.tokenStore.listPayments().filter((payment) => payment.enabled);
         return payments.find((payment) => payment.isDefault)?.method || payments.find((payment) => payment.method === "mock")?.method;
@@ -1806,6 +1873,7 @@ export class TokenbuddyDaemon {
                         name: provider.name,
                         url: provider.baseUrl,
                         status: observation?.status ?? "active",
+                        routeState: this.routeStateFromCatalogStatus(observation?.status ?? "active"),
                         ttftMs: observation?.ttftMs,
                         avgTokensPerSecond: observation?.avgTokensPerSecond
                     };
@@ -1841,10 +1909,21 @@ export class TokenbuddyDaemon {
     }
     sellerCatalogWithRuntimeMetrics(sellers) {
         const runtimeBySellerId = new Map(this.sellerPool.snapshot().map((entry) => [entry.sellerId, entry]));
+        const concurrencySnapshot = this.sellerConcurrencyLimiter.snapshot();
+        const activeBySellerId = new Map(concurrencySnapshot.active.map((entry) => [entry.sellerId, entry.activeCount]));
         return sellers.map((seller) => {
             const runtime = runtimeBySellerId.get(seller.id);
+            const concurrency = concurrencySnapshot.enabled
+                ? {
+                    localConcurrencyActive: activeBySellerId.get(seller.id) ?? 0,
+                    localConcurrencyLimit: concurrencySnapshot.maxInFlightPerSeller
+                }
+                : undefined;
             return {
                 ...seller,
+                routeState: runtime
+                    ? this.routeStateFromPoolEntry(runtime, concurrency)
+                    : seller.routeState ?? this.routeStateFromCatalogStatus(seller.status),
                 ttftMs: runtime?.ttftMs ?? seller.ttftMs,
                 avgTokensPerSecond: runtime?.avgTokensPerSecond ?? seller.avgTokensPerSecond
             };
@@ -1872,9 +1951,67 @@ export class TokenbuddyDaemon {
             discountRatio: metadata?.discountRatio,
             circuit: entry.circuit,
             capacityBlockedUntil: entry.capacityBlockedUntil,
+            routeState: this.routeStateFromPoolEntry(entry, concurrency),
             ...(concurrency ?? {})
         };
     }
+    routeStateFromPoolEntry(entry, concurrency) {
+        if (concurrency &&
+            Number.isFinite(concurrency.localConcurrencyActive) &&
+            Number.isFinite(concurrency.localConcurrencyLimit) &&
+            concurrency.localConcurrencyActive >= concurrency.localConcurrencyLimit) {
+            return "full";
+        }
+        if (Number.isFinite(entry.capacityBlockedUntil) && entry.capacityBlockedUntil > Date.now()) {
+            return "full";
+        }
+        if (entry.circuit === "open" || entry.circuit === "half_open") {
+            return "cooldown";
+        }
+        if (entry.upstreamStatus === "unhealthy") {
+            return "error";
+        }
+        if (entry.upstreamStatus === "degraded") {
+            return "degraded";
+        }
+        if (Number.isFinite(entry.healthScore)) {
+            if (entry.healthScore < 40) {
+                return "error";
+            }
+            if (entry.healthScore < 70) {
+                return "degraded";
+            }
+        }
+        if (entry.lastFailAt > 0 && entry.lastFailAt >= entry.lastSuccessAt) {
+            return "degraded";
+        }
+        if (entry.lastSuccessAt <= 0 && entry.lastProbeAt <= 0) {
+            return "unknown";
+        }
+        return "ok";
+    }
+    routeStateFromCatalogStatus(status) {
+        const normalized = status?.trim().toLowerCase();
+        if (!normalized) {
+            return "unknown";
+        }
+        if (normalized === "ok" || normalized === "active" || normalized === "healthy" || normalized === "online") {
+            return "ok";
+        }
+        if (normalized === "degraded") {
+            return "degraded";
+        }
+        if (normalized === "cooldown" || normalized === "cooling_down" || normalized === "half_open") {
+            return "cooldown";
+        }
+        if (normalized === "full" || normalized === "busy_capacity" || normalized === "capacity_full") {
+            return "full";
+        }
+        if (normalized === "error" || normalized === "failed" || normalized === "manifest_unavailable" || normalized === "unhealthy" || normalized === "offline") {
+            return "error";
+        }
+        return "unknown";
+    }
     readUsage(bodyText, endpoint, requestBody) {
         const fallback = {
             promptTokens: 0,
@@ -1887,30 +2024,54 @@ export class TokenbuddyDaemon {
         }
         try {
             const data = usageRecord(JSON.parse(bodyText));
-            const usage = usageRecord(data?.usage) ?? usageRecord(usageRecord(data?.response)?.usage);
-            const promptDetails = usageRecord(usage?.prompt_tokens_details);
-            const inputDetails = usageRecord(usage?.input_tokens_details);
-            const promptTokens = nonNegativeIntegerField(usage?.prompt_tokens) ?? nonNegativeIntegerField(usage?.input_tokens) ?? 0;
-            const completionTokens = nonNegativeIntegerField(usage?.completion_tokens) ?? nonNegativeIntegerField(usage?.output_tokens) ?? 0;
-            const cacheReadTokens = nonNegativeIntegerField(promptDetails?.cached_tokens)
-                ?? nonNegativeIntegerField(inputDetails?.cached_tokens)
-                ?? nonNegativeIntegerField(usage?.cache_read_input_tokens)
-                ?? nonNegativeIntegerField(usage?.cache_read_tokens)
-                ?? 0;
-            const imageMetadata = endpoint === "/v1/images/generations"
-                ? imageUsageMetadata(data, usageRecord(requestBody))
-                : {};
-            return {
-                promptTokens,
-                completionTokens,
-                cacheReadTokens,
-                billedMicros: (promptTokens + completionTokens) * 4,
-                ...imageMetadata
-            };
+            return this.usageSummaryFromData(data, endpoint, requestBody);
         }
         catch {
-            return fallback;
+            return this.readUsageFromSse(bodyText, endpoint, requestBody) ?? fallback;
+        }
+    }
+    usageSummaryFromData(data, endpoint, requestBody) {
+        const usage = usageRecord(data?.usage) ?? usageRecord(usageRecord(data?.response)?.usage);
+        const promptDetails = usageRecord(usage?.prompt_tokens_details);
+        const inputDetails = usageRecord(usage?.input_tokens_details);
+        const promptTokens = nonNegativeIntegerField(usage?.prompt_tokens) ?? nonNegativeIntegerField(usage?.input_tokens) ?? 0;
+        const completionTokens = nonNegativeIntegerField(usage?.completion_tokens) ?? nonNegativeIntegerField(usage?.output_tokens) ?? 0;
+        const cacheReadTokens = nonNegativeIntegerField(promptDetails?.cached_tokens)
+            ?? nonNegativeIntegerField(inputDetails?.cached_tokens)
+            ?? nonNegativeIntegerField(usage?.cache_read_input_tokens)
+            ?? nonNegativeIntegerField(usage?.cache_read_tokens)
+            ?? 0;
+        const imageMetadata = endpoint === "/v1/images/generations"
+            ? imageUsageMetadata(data, usageRecord(requestBody))
+            : {};
+        return {
+            promptTokens,
+            completionTokens,
+            cacheReadTokens,
+            billedMicros: (promptTokens + completionTokens) * 4,
+            ...imageMetadata
+        };
+    }
+    readUsageFromSse(bodyText, endpoint, requestBody) {
+        let latestUsageData;
+        for (const line of bodyText.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data:"))
+                continue;
+            const payload = trimmed.slice("data:".length).trim();
+            if (!payload || payload === "[DONE]")
+                continue;
+            try {
+                const data = usageRecord(JSON.parse(payload));
+                const usage = usageRecord(data?.usage) ?? usageRecord(usageRecord(data?.response)?.usage);
+                if (usage)
+                    latestUsageData = data;
+            }
+            catch {
+                continue;
+            }
         }
+        return latestUsageData ? this.usageSummaryFromData(latestUsageData, endpoint, requestBody) : undefined;
     }
     parseSellerSettlementSummary(headers) {
         const raw = headers.get("x-tokenbuddy-settlement");
@@ -1935,6 +2096,7 @@ export class TokenbuddyDaemon {
             ? settlement.requestId
             : undefined;
         const billingBreakdown = settlement?.billingBreakdown;
+        const avgOutputTokensPerSecond = nonNegativeFiniteField(extras?.avgOutputTokensPerSecond);
         this.tokenStore.recordInferenceLedger({
             requestId,
             sellerKey: route.seller.id,
@@ -1976,6 +2138,7 @@ export class TokenbuddyDaemon {
             falloverChain: extras?.falloverChain,
             upstreamStatus: extras?.upstreamStatus,
             durationMs: extras?.durationMs,
+            avgOutputTokensPerSecond,
             paymentMethod: extras?.paymentMethod
         });
         logger.info("inference.ledger.recorded", "safe inference ledger recorded", {
@@ -2002,6 +2165,7 @@ export class TokenbuddyDaemon {
             falloverChain: extras?.falloverChain,
             upstreamStatus: extras?.upstreamStatus,
             durationMs: extras?.durationMs,
+            avgOutputTokensPerSecond,
             paymentMethod: extras?.paymentMethod
         });
     }
@@ -2119,6 +2283,13 @@ export class TokenbuddyDaemon {
         }
         return parsed;
     }
+    userInferenceTestTimeoutMs() {
+        const warmupTimeoutMs = this.config.warmupProbeTimeoutMs;
+        if (!Number.isFinite(warmupTimeoutMs)) {
+            return USER_INFERENCE_TEST_TIMEOUT_MS;
+        }
+        return Math.max(warmupTimeoutMs ?? 0, USER_INFERENCE_TEST_TIMEOUT_MS);
+    }
     /**
      * Safety margin subtracted from the cached token's `expiresAt` before
      * deciding to reuse it. Buying a new token 60s before expiry gives the
@@ -2212,14 +2383,19 @@ export class TokenbuddyDaemon {
                 });
                 const createData = await createRes.json();
                 if (!createRes.ok) {
+                    const paymentSetupError = purchaseResponsePaymentSetupError(createRes, createData, "purchase/create failed");
                     logger.warn("purchase.create.failed", "seller purchase create failed", {
                         sellerKey,
                         model: modelId,
                         requestId,
                         status: createRes.status,
+                        errorCode: createData.error?.code,
                         errorMessage: createData.error?.message || "purchase/create failed",
                         durationMs: Date.now() - startedAt
                     });
+                    if (paymentSetupError) {
+                        throw paymentSetupError;
+                    }
                     throw new Error(createData.error?.message || "purchase/create failed");
                 }
                 const purchaseId = createData.purchaseId || createData.purchase_id;
@@ -2273,15 +2449,20 @@ export class TokenbuddyDaemon {
                 });
                 const completeData = await completeRes.json();
                 if (!completeRes.ok) {
+                    const paymentSetupError = purchaseResponsePaymentSetupError(completeRes, completeData, "purchase/complete failed");
                     logger.warn("purchase.complete.failed", "seller purchase complete failed", {
                         sellerKey,
                         model: modelId,
                         requestId,
                         purchaseId,
                         status: completeRes.status,
+                        errorCode: completeData.error?.code,
                         errorMessage: completeData.error?.message || "purchase/complete failed",
                         durationMs: Date.now() - startedAt
                     });
+                    if (paymentSetupError) {
+                        throw paymentSetupError;
+                    }
                     throw new Error(completeData.error?.message || "purchase/complete failed");
                 }
                 const token = completeData.accessToken || completeData.access_token;
@@ -2360,7 +2541,7 @@ export class TokenbuddyDaemon {
             return "mock-proof-data";
         }
         if (route.paymentMethod !== "clawtip") {
-            throw new Error(`unsupported payment method for auto purchase: ${route.paymentMethod}`);
+            throw new BuyerPaymentSetupError(`unsupported payment method for auto purchase: ${route.paymentMethod}`, ErrorCode.PaymentMethodNotReady);
         }
         const proofCommand = process.env.TB_PROXYD_CLAWTIP_PROOF_COMMAND;
         if (proofCommand?.trim()) {
@@ -2379,7 +2560,7 @@ export class TokenbuddyDaemon {
             this.logPaymentProofResolved(route, "env", requestId);
             return proof.trim();
         }
-        throw new Error("clawtip auto purchase requires TB_PROXYD_CLAWTIP_PROOF_COMMAND or a ClawTip proof env/file");
+        throw new BuyerPaymentSetupError("clawtip auto purchase requires TB_PROXYD_CLAWTIP_PROOF_COMMAND or a ClawTip proof env/file", ErrorCode.PaymentMethodNotReady);
     }
     runClawtipProofCommand(route, createData, commandPath, requestId) {
         const timeoutMs = this.clawtipProofTimeoutMs();
@@ -2416,7 +2597,7 @@ export class TokenbuddyDaemon {
                 }
                 settled = true;
                 child.kill("SIGTERM");
-                reject(new Error("clawtip proof provider timed out"));
+                reject(new BuyerPaymentSetupError("clawtip proof provider timed out", ErrorCode.PaymentTimeout));
             }, timeoutMs);
             child.stdout.on("data", (chunk) => {
                 stdout += chunk.toString("utf8");
@@ -2433,7 +2614,7 @@ export class TokenbuddyDaemon {
                 }
                 settled = true;
                 clearTimeout(timer);
-                reject(error);
+                reject(new BuyerPaymentSetupError(`clawtip proof provider failed: ${error.message}`, ErrorCode.PaymentProviderFailed));
             });
             child.on("close", (code) => {
                 if (settled) {
@@ -2443,7 +2624,7 @@ export class TokenbuddyDaemon {
                 clearTimeout(timer);
                 const proof = stdout.trim();
                 if (code !== 0 || !proof) {
-                    reject(new Error(`clawtip proof provider failed with exit ${code}: ${stderr.trim() || "empty proof"}`));
+                    reject(new BuyerPaymentSetupError(`clawtip proof provider failed with exit ${code}: ${stderr.trim() || "empty proof"}`, ErrorCode.PaymentProviderFailed));
                     return;
                 }
                 logger.info("purchase.clawtip_proof.succeeded", "clawtip proof provider succeeded", {
@@ -2522,6 +2703,7 @@ export class TokenbuddyDaemon {
         const startedAt = Date.now();
         const ac = new AbortController();
         const timer = setTimeout(() => ac.abort(new Error("manual provider model probe timeout")), this.config.warmupProbeTimeoutMs ?? 3000);
+        let modelIds = [];
         try {
             const response = await fetch(this.manualProviderEndpointUrlFromBase(parsed.toString(), "/v1/models"), {
                 method: "GET",
@@ -2540,19 +2722,234 @@ export class TokenbuddyDaemon {
                 throw new Error(`manual provider model probe returned HTTP ${response.status}`);
             }
             const body = await response.json().catch(() => undefined);
-            const modelIds = parseOpenAiModelIds(body);
+            modelIds = parseOpenAiModelIds(body);
             if (modelIds.length === 0) {
                 throw new Error("manual provider model list is empty");
             }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const protocolProbes = await this.probeManualProviderProtocols({
+            baseUrl: parsed.toString(),
+            apiKey: input.apiKey.trim(),
+            modelIds
+        });
+        const supportedProtocols = protocolProbes
+            .filter((probe) => probe.supported)
+            .map((probe) => probe.protocol);
+        if (supportedProtocols.length === 0) {
+            throw new Error("manual provider has models but no supported inference protocols were detected");
+        }
+        return {
+            modelIds,
+            supportedProtocols,
+            protocolProbes,
+            elapsedMs: Date.now() - startedAt
+        };
+    }
+    async probeManualProviderProtocols(input) {
+        const protocols = [
+            { protocol: "chat_completions", endpoint: "/v1/chat/completions" },
+            { protocol: "responses", endpoint: "/v1/responses" },
+            { protocol: "images_generations", endpoint: "/v1/images/generations" }
+        ];
+        const timeoutMs = this.config.warmupProbeTimeoutMs ?? 3000;
+        return Promise.all(protocols.map((protocol) => this.probeManualProviderProtocol(input, protocol, timeoutMs)));
+    }
+    async probeManualProviderProtocol(input, protocol, timeoutMs) {
+        let lastResult;
+        for (const modelId of manualProviderProbeModelCandidates(input.modelIds, protocol.protocol)) {
+            const result = await this.probeManualProviderProtocolModel(input, protocol, modelId, timeoutMs);
+            if (result.supported) {
+                return result;
+            }
+            lastResult = result;
+        }
+        return lastResult ?? {
+            protocol: protocol.protocol,
+            supported: false,
+            errorMessage: "missing model for capability probe"
+        };
+    }
+    async probeManualProviderProtocolModel(input, protocol, modelId, timeoutMs) {
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(new Error("manual provider protocol probe timeout")), timeoutMs);
+        try {
+            const response = await fetch(this.manualProviderEndpointUrlFromBase(input.baseUrl, protocol.endpoint), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${input.apiKey}`
+                },
+                body: JSON.stringify(manualProviderProtocolProbeBody(protocol.protocol, modelId)),
+                signal: ac.signal
+            });
+            const responseText = await readResponseText(response);
+            if (protocol.protocol === "images_generations" && imageValidationProbeSupported(response.status, responseText)) {
+                return {
+                    protocol: protocol.protocol,
+                    supported: true,
+                    modelId,
+                    httpStatus: response.status
+                };
+            }
+            return {
+                protocol: protocol.protocol,
+                supported: response.ok,
+                modelId,
+                httpStatus: response.status,
+                ...(response.ok ? {} : { errorMessage: `probe returned HTTP ${response.status}` })
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
             return {
-                modelIds,
-                elapsedMs: Date.now() - startedAt
+                protocol: protocol.protocol,
+                supported: false,
+                modelId,
+                errorMessage
             };
         }
         finally {
             clearTimeout(timer);
         }
     }
+    async testManualProviderInference(provider) {
+        const modelId = provider.models[0];
+        if (!modelId) {
+            throw new Error(`manual provider has no models: ${provider.id}`);
+        }
+        const startedAt = Date.now();
+        const timeoutMs = this.userInferenceTestTimeoutMs();
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(new Error("manual provider inference probe timeout")), timeoutMs);
+        try {
+            const response = await fetch(this.manualProviderEndpointUrl(provider, "/v1/chat/completions"), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${this.manualProviderApiKey(provider)}`
+                },
+                body: JSON.stringify({
+                    model: modelId,
+                    messages: [{ role: "user", content: "say hi" }],
+                    max_tokens: 8,
+                    temperature: 0,
+                    stream: false
+                }),
+                signal: ac.signal
+            });
+            const elapsedMs = Date.now() - startedAt;
+            if (!response.ok) {
+                const body = await response.text().catch(() => "");
+                throw new Error(`manual provider inference probe returned HTTP ${response.status}${body ? `: ${body.slice(0, 240)}` : ""}`);
+            }
+            const body = await response.json().catch(() => undefined);
+            if (!hasOpenAiChatChoice(body)) {
+                throw new Error("manual provider inference probe returned an invalid chat completion");
+            }
+            return { modelId, elapsedMs };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async testSellerInference(sellerId) {
+        const registry = await this.fetchRegistry();
+        const seller = registry.sellers.find((entry) => entry.id === sellerId);
+        if (!seller) {
+            throw new Error(`seller not found: ${sellerId}`);
+        }
+        if (!isBuyerVisibleRegistrySeller(seller)) {
+            throw new Error(`seller is not active: ${sellerId}`);
+        }
+        if (!(seller.supportedProtocols ?? []).includes("chat_completions")) {
+            throw new Error(`seller does not support chat_completions: ${sellerId}`);
+        }
+        const modelId = seller.models?.[0];
+        if (!modelId) {
+            throw new Error(`seller has no models: ${sellerId}`);
+        }
+        const paymentMethod = this.defaultPaymentMethod();
+        if (!paymentMethod || !(seller.paymentMethods ?? []).includes(paymentMethod)) {
+            throw new Error(`seller does not support the active payment method: ${sellerId}`);
+        }
+        const startedAt = Date.now();
+        const requestId = `seller_test_${crypto.randomBytes(8).toString("hex")}`;
+        const route = {
+            seller,
+            transport: "tokenbuddy_seller",
+            manifest: null,
+            protocol: "chat_completions",
+            modelId,
+            paymentMethod,
+            planSource: "registry_fallback",
+            planReason: "manual_seller_test",
+            planSellerCount: 1
+        };
+        const token = await this.getOrPurchaseToken(route, requestId);
+        const sellerUrl = normalizeSellerUrl(seller);
+        const timeoutMs = this.userInferenceTestTimeoutMs();
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(new Error("seller inference test timeout")), timeoutMs);
+        try {
+            const response = await fetch(`${sellerUrl}/v1/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${token}`,
+                    "X-Request-Id": requestId,
+                    "Idempotency-Key": `idem_${crypto.randomBytes(12).toString("hex")}`,
+                    "X-TokenBuddy-Deadline-Ms": String(timeoutMs)
+                },
+                body: JSON.stringify({
+                    model: modelId,
+                    messages: [{ role: "user", content: "say hi" }],
+                    max_tokens: 8,
+                    temperature: 0,
+                    stream: false,
+                    requestId
+                }),
+                signal: ac.signal
+            });
+            const elapsedMs = Date.now() - startedAt;
+            if (!response.ok) {
+                const body = await response.text().catch(() => "");
+                throw new Error(`seller inference test returned HTTP ${response.status}${body ? `: ${body.slice(0, 240)}` : ""}`);
+            }
+            const body = await response.json().catch(() => undefined);
+            if (!hasOpenAiChatChoice(body)) {
+                throw new Error("seller inference test returned an invalid chat completion");
+            }
+            this.sellerPool.recordRuntimeMetrics(seller.id, { ttftMs: elapsedMs });
+            logger.info("seller.inference_test.succeeded", "seller inference test succeeded", {
+                sellerId,
+                model: modelId,
+                elapsedMs
+            });
+            return {
+                sellerId,
+                sellerName: seller.name,
+                modelId,
+                elapsedMs
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    recordManualProviderProbeResult(input) {
+        const existing = this.currentManualProviderObservations().observations.find((entry) => entry.providerId === input.providerId);
+        this.recordManualProviderObservation({
+            providerId: input.providerId,
+            current: existing?.current ?? false,
+            status: input.status,
+            ttftMs: input.ttftMs,
+            errorClass: input.errorClass,
+            errorMessage: input.errorMessage
+        });
+    }
     manualProviderErrorClass(status) {
         if (status === 401 || status === 403) {
             return "auth_failed";
@@ -2609,10 +3006,17 @@ export class TokenbuddyDaemon {
         }
         const sellerKey = route.seller.id;
         const attemptStartedAt = Date.now();
-        const upstreamBody = this.applyResolvedModelToBody(endpoint, {
+        let firstByteAt;
+        const markManualFirstByte = () => {
+            if (firstByteAt === undefined) {
+                firstByteAt = Date.now();
+            }
+            markFirstByte();
+        };
+        const upstreamBody = this.withOpenAiStreamUsage(endpoint, this.applyResolvedModelToBody(endpoint, {
             ...reqBody,
             requestId
-        }, modelId);
+        }, modelId));
         logger.info("manual_provider.request.started", "manual provider request started", {
             requestId,
             providerId: provider.id,
@@ -2699,6 +3103,7 @@ export class TokenbuddyDaemon {
                 return true;
             }
             let bytes = 0;
+            let responseBody = "";
             const decoder = new TextDecoder();
             while (true) {
                 const { done, value } = await reader.read();
@@ -2708,24 +3113,32 @@ export class TokenbuddyDaemon {
                 bytes += value.byteLength;
                 const chunk = decoder.decode(value, { stream: true });
                 if (chunk.length > 0) {
-                    markFirstByte();
+                    responseBody += chunk;
+                    markManualFirstByte();
                     res.write(chunk);
                 }
             }
             const decoderTail = decoder.decode();
             if (decoderTail.length > 0) {
-                markFirstByte();
+                responseBody += decoderTail;
+                markManualFirstByte();
                 res.write(decoderTail);
             }
             res.end();
+            const usage = this.readUsage(responseBody, endpoint, upstreamBody);
             const durationMs = Date.now() - startedAt;
-            const ttftMs = durationMs > 0 ? Date.now() - attemptStartedAt : undefined;
+            const ttftMs = firstByteAt !== undefined ? firstByteAt - startedAt : undefined;
+            const billedMicros = usage.billedMicros > 0 ? usage.billedMicros : Math.max(1, bytes);
+            const completionTokens = usage.completionTokens;
+            const avgTokensPerSecond = completionTokens > 0
+                ? averageOutputTokensPerSecond(completionTokens, durationMs, ttftMs)
+                : undefined;
             this.recordManualProviderObservation({
                 providerId: provider.id,
                 current: true,
                 status: "healthy",
                 ttftMs,
-                avgTokensPerSecond: undefined
+                avgTokensPerSecond
             });
             this.tokenStore.recordInferenceLedger({
                 requestId,
@@ -2733,11 +3146,11 @@ export class TokenbuddyDaemon {
                 modelId,
                 endpoint,
                 status: "ok",
-                promptTokens: 0,
-                completionTokens: 0,
-                cacheReadTokens: 0,
-                billedMicros: Math.max(1, bytes),
-                estimatedMicros: Math.max(1, bytes),
+                promptTokens: usage.promptTokens,
+                completionTokens: usage.completionTokens,
+                cacheReadTokens: usage.cacheReadTokens,
+                billedMicros,
+                estimatedMicros: billedMicros,
                 priceVersion: `local-provider:${provider.id}`,
                 billingUnit: endpoint === "/v1/images/generations" ? "images" : "tokens",
                 balanceSource: "self_funded_provider",
@@ -2748,24 +3161,22 @@ export class TokenbuddyDaemon {
                 falloverChain: routes.slice(0, routeIndex + 1).map((entry) => entry.seller.id),
                 upstreamStatus: "healthy",
                 durationMs,
+                avgOutputTokensPerSecond: avgTokensPerSecond,
                 paymentMethod
             });
             return true;
         }
+        markManualFirstByte();
         const responseBody = await response.text();
-        markFirstByte();
         res.send(responseBody);
         const usage = this.readUsage(responseBody, endpoint, reqBody);
         const durationMs = Date.now() - startedAt;
-        const ttftMs = Date.now() - attemptStartedAt;
-        const completionTokens = usage.completionTokens;
-        const avgTokensPerSecond = durationMs > 0 && completionTokens > 0 ? completionTokens / (durationMs / 1000) : undefined;
+        const ttftMs = firstByteAt !== undefined ? firstByteAt - startedAt : undefined;
         this.recordManualProviderObservation({
             providerId: provider.id,
             current: true,
             status: "healthy",
-            ttftMs,
-            avgTokensPerSecond
+            ttftMs
         });
         this.tokenStore.recordInferenceLedger({
             requestId,
@@ -2957,6 +3368,23 @@ export class TokenbuddyDaemon {
                                 token = await this.getOrPurchaseToken(route, requestId);
                             }
                             catch (purchaseError) {
+                                if (purchaseError instanceof BuyerPaymentSetupError) {
+                                    logger.warn("purchase.payment_setup_failed", "buyer payment setup failed; refusing seller failover", {
+                                        requestId,
+                                        sellerKey,
+                                        model: modelId,
+                                        endpoint,
+                                        errorCode: purchaseError.errorCode,
+                                        errorMessage: purchaseError.message
+                                    });
+                                    res.status(purchaseError.statusCode).json({
+                                        error: {
+                                            code: purchaseError.errorCode,
+                                            message: purchaseError.message
+                                        }
+                                    });
+                                    return;
+                                }
                                 logger.warn("purchase.failed", "seller auto-purchase failed; failing over without retry", {
                                     requestId,
                                     sellerKey,
@@ -3119,6 +3547,7 @@ export class TokenbuddyDaemon {
                                     return;
                                 }
                                 let bytes = 0;
+                                let responseBody = "";
                                 const decoder = new TextDecoder();
                                 const settlementExtractor = new SellerSettlementStreamExtractor();
                                 while (true) {
@@ -3135,6 +3564,7 @@ export class TokenbuddyDaemon {
                                     // 缺 event: 行）由卖方修，buyer 不兜底。
                                     const sellerChunk = settlementExtractor.push(chunk);
                                     if (sellerChunk.length > 0) {
+                                        responseBody += sellerChunk;
                                         markFirstByte();
                                         res.write(sellerChunk);
                                     }
@@ -3147,31 +3577,47 @@ export class TokenbuddyDaemon {
                                 if (decoderTail.length > 0) {
                                     const sellerTail = settlementExtractor.push(decoderTail);
                                     if (sellerTail.length > 0) {
+                                        responseBody += sellerTail;
                                         markFirstByte();
                                         res.write(sellerTail);
                                     }
                                 }
                                 const settlementTrailing = settlementExtractor.finish();
                                 if (settlementTrailing.downstream.length > 0) {
+                                    responseBody += settlementTrailing.downstream;
                                     markFirstByte();
                                     res.write(settlementTrailing.downstream);
                                 }
                                 res.end();
                                 void this.refreshSellerRuntimeMetrics(route, requestId);
-                                this.recordReconciledInference(route, endpoint, requestId, { promptTokens: 0, completionTokens: 0, cacheReadTokens: 0, billedMicros: Math.max(1, bytes) }, this.parseSellerSettlementSummary(upstreamResponse.headers) ?? settlementTrailing.settlement ?? settlementExtractor.current(), this.inferPromptForHash(body), undefined, {
-                                    ttftMs: firstByteAt ? firstByteAt - startedAt : undefined,
+                                const streamUsage = this.readUsage(responseBody, endpoint, body);
+                                const hasStreamUsage = streamUsage.promptTokens > 0 ||
+                                    streamUsage.completionTokens > 0 ||
+                                    streamUsage.cacheReadTokens > 0 ||
+                                    streamUsage.billedMicros > 0;
+                                const usage = hasStreamUsage
+                                    ? streamUsage
+                                    : { ...streamUsage, billedMicros: Math.max(1, bytes) };
+                                const durationMs = Date.now() - startedAt;
+                                const ttftMs = firstByteAt ? firstByteAt - startedAt : undefined;
+                                const avgOutputTokensPerSecond = usage.completionTokens > 0
+                                    ? averageOutputTokensPerSecond(usage.completionTokens, durationMs, ttftMs)
+                                    : undefined;
+                                this.recordReconciledInference(route, endpoint, requestId, usage, this.parseSellerSettlementSummary(upstreamResponse.headers) ?? settlementTrailing.settlement ?? settlementExtractor.current(), this.inferPromptForHash(body), undefined, {
+                                    ttftMs,
                                     fallbackCount: routeIndex,
                                     routeReason: plan.reason,
                                     falloverChain: routes.slice(0, routeIndex + 1).map((r) => r.seller.id),
                                     upstreamStatus: upstreamStatusFromHeaders(upstreamResponse.headers),
-                                    durationMs: Date.now() - startedAt,
+                                    durationMs,
+                                    avgOutputTokensPerSecond,
                                     paymentMethod
                                 });
                                 return;
                             }
+                            markFirstByte();
                             const responseBody = await upstreamResponse.text();
                             lease.refresh();
-                            markFirstByte();
                             res.send(responseBody);
                             const usage = this.readUsage(responseBody, endpoint, body);
                             void this.refreshSellerRuntimeMetrics(route, requestId);
@@ -3243,9 +3689,10 @@ export class TokenbuddyDaemon {
                 durationMs: Date.now() - startedAt
             });
             if (!res.headersSent) {
-                res.status(502).json({
+                const buyerPaymentError = error instanceof BuyerPaymentSetupError ? error : undefined;
+                res.status(buyerPaymentError?.statusCode ?? 502).json({
                     error: {
-                        code: "proxy_request_failed",
+                        code: buyerPaymentError?.errorCode ?? "proxy_request_failed",
                         message: error instanceof Error ? error.message : String(error)
                     }
                 });
@@ -3568,6 +4015,32 @@ export class TokenbuddyDaemon {
                 });
             }
         });
+        controlApp.post("/sellers/:id/test", async (req, res) => {
+            const sellerId = req.params.id;
+            try {
+                const result = await this.testSellerInference(sellerId);
+                res.status(200).json({
+                    ok: true,
+                    sellerId: result.sellerId,
+                    sellerName: result.sellerName,
+                    modelId: result.modelId,
+                    elapsedMs: result.elapsedMs
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.warn("seller.inference_test.failed", "seller inference test failed", {
+                    sellerId,
+                    errorMessage
+                });
+                res.status(400).json({
+                    error: {
+                        code: "seller_inference_test_failed",
+                        message: errorMessage
+                    }
+                });
+            }
+        });
         controlApp.get("/models", async (req, res) => {
             try {
                 const { models, sellers } = await this.listSellerBackedModels();
@@ -3598,7 +4071,7 @@ export class TokenbuddyDaemon {
         });
         controlApp.post("/providers/detect", (req, res) => {
             try {
-                const providers = detectProviders({ home: typeof req.body?.home === "string" ? req.body.home : undefined });
+                const providers = detectProviders({ home: typeof req.body?.home === "string" ? req.body.home : this.config.providerHomeDir });
                 logger.info("provider.detect.succeeded", "provider detection succeeded", {
                     providerCount: providers.length,
                     detectedCount: providers.filter((provider) => provider.detected).length
@@ -3644,7 +4117,7 @@ export class TokenbuddyDaemon {
                     proxyUrl: String(req.body?.proxyUrl || ""),
                     model: typeof req.body?.model === "string" ? req.body.model : undefined,
                     providerSelections: req.body?.providerSelections,
-                    home: typeof req.body?.home === "string" ? req.body.home : undefined
+                    home: typeof req.body?.home === "string" ? req.body.home : this.config.providerHomeDir
                 });
                 logger.info("provider.install.previewed", "provider install previewed", {
                     providerCount: new Set(changes.map((change) => change.providerId)).size,
@@ -3672,7 +4145,7 @@ export class TokenbuddyDaemon {
                     proxyUrl: String(req.body?.proxyUrl || ""),
                     model: typeof req.body?.model === "string" ? req.body.model : undefined,
                     providerSelections: req.body?.providerSelections,
-                    home: typeof req.body?.home === "string" ? req.body.home : undefined
+                    home: typeof req.body?.home === "string" ? req.body.home : this.config.providerHomeDir
                 }, this.tokenStore);
                 logger.info("provider.install.applied", "provider install applied", {
                     providerCount: new Set(applied.map((entry) => entry.providerId)).size,
@@ -3695,7 +4168,7 @@ export class TokenbuddyDaemon {
             try {
                 const rolledBack = rollbackProviderInstall({
                     providers: Array.isArray(req.body?.providers) ? req.body.providers : [],
-                    home: typeof req.body?.home === "string" ? req.body.home : undefined
+                    home: typeof req.body?.home === "string" ? req.body.home : this.config.providerHomeDir
                 }, this.tokenStore);
                 logger.info("provider.install.rolled_back", "provider install rolled back", {
                     providerCount: new Set(rolledBack.map((entry) => entry.providerId)).size,
@@ -3808,11 +4281,14 @@ export class TokenbuddyDaemon {
                 const result = await this.probeManualProviderModels({ baseUrl, apiKey });
                 logger.info("routing.manual_provider.probed", "manual provider model probe succeeded", {
                     modelCount: result.modelIds.length,
+                    supportedProtocols: result.supportedProtocols,
                     elapsedMs: result.elapsedMs
                 });
                 res.status(200).json({
                     ok: true,
                     modelIds: result.modelIds,
+                    supportedProtocols: result.supportedProtocols,
+                    protocolProbes: result.protocolProbes,
                     elapsedMs: result.elapsedMs
                 });
             }
@@ -3822,6 +4298,116 @@ export class TokenbuddyDaemon {
                 res.status(400).json({ error: { code: "manual_provider_probe_failed", message: errorMessage } });
             }
         });
+        controlApp.post("/routing/manual-providers/:id/test", async (req, res) => {
+            const providerId = req.params.id;
+            let providerFound = false;
+            try {
+                const config = this.currentManualProviders();
+                const provider = config.providers.find((entry) => entry.id === providerId);
+                if (!provider) {
+                    res.status(404).json({ error: { code: "manual_provider_not_found", message: `manual provider not found: ${providerId}` } });
+                    return;
+                }
+                providerFound = true;
+                const result = await this.testManualProviderInference(provider);
+                this.recordManualProviderProbeResult({
+                    providerId,
+                    status: "healthy",
+                    ttftMs: result.elapsedMs
+                });
+                logger.info("routing.manual_provider.inference_test_succeeded", "manual provider inference test succeeded", {
+                    providerId,
+                    model: result.modelId,
+                    elapsedMs: result.elapsedMs
+                });
+                const observations = new Map(this.currentManualProviderObservations().observations.map((entry) => [entry.providerId, entry]));
+                res.status(200).json({
+                    ok: true,
+                    providerId,
+                    modelId: result.modelId,
+                    elapsedMs: result.elapsedMs,
+                    provider: publicManualProviderConfig(provider, observations.get(provider.id))
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (providerFound) {
+                    this.recordManualProviderProbeResult({
+                        providerId,
+                        status: "unhealthy",
+                        errorClass: "inference_probe_failed",
+                        errorMessage
+                    });
+                }
+                logger.warn("routing.manual_provider.inference_test_failed", "manual provider inference test failed", { providerId, errorMessage });
+                res.status(400).json({ error: { code: "manual_provider_inference_test_failed", message: errorMessage } });
+            }
+        });
+        controlApp.post("/routing/manual-providers/:id/models/refresh", async (req, res) => {
+            const providerId = req.params.id;
+            let providerFound = false;
+            try {
+                const config = this.currentManualProviders();
+                const provider = config.providers.find((entry) => entry.id === providerId);
+                if (!provider) {
+                    res.status(404).json({ error: { code: "manual_provider_not_found", message: `manual provider not found: ${providerId}` } });
+                    return;
+                }
+                providerFound = true;
+                const probe = await this.probeManualProviderModels({
+                    baseUrl: provider.baseUrl,
+                    apiKey: this.manualProviderApiKey(provider)
+                });
+                const updatedProvider = {
+                    ...provider,
+                    models: probe.modelIds,
+                    supportedProtocols: probe.supportedProtocols,
+                    updatedAt: new Date().toISOString()
+                };
+                const nextConfig = {
+                    version: 1,
+                    providers: config.providers.map((entry) => entry.id === providerId ? updatedProvider : entry),
+                    routing: config.routing,
+                    updatedAt: new Date().toISOString()
+                };
+                this.saveManualProviders(nextConfig);
+                this.recordManualProviderProbeResult({
+                    providerId,
+                    status: "healthy"
+                });
+                logger.info("routing.manual_provider.models_refresh_succeeded", "manual provider models refreshed", {
+                    providerId,
+                    modelCount: probe.modelIds.length,
+                    supportedProtocols: probe.supportedProtocols,
+                    elapsedMs: probe.elapsedMs
+                });
+                const observations = new Map(this.currentManualProviderObservations().observations.map((entry) => [entry.providerId, entry]));
+                res.status(200).json({
+                    ok: true,
+                    providerId,
+                    modelIds: probe.modelIds,
+                    supportedProtocols: probe.supportedProtocols,
+                    protocolProbes: probe.protocolProbes,
+                    elapsedMs: probe.elapsedMs,
+                    provider: publicManualProviderConfig(updatedProvider, observations.get(providerId)),
+                    routing: nextConfig.routing,
+                    providers: nextConfig.providers.map((entry) => publicManualProviderConfig(entry, observations.get(entry.id)))
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (providerFound) {
+                    this.recordManualProviderProbeResult({
+                        providerId,
+                        status: "unhealthy",
+                        errorClass: "models_refresh_failed",
+                        errorMessage
+                    });
+                }
+                logger.warn("routing.manual_provider.models_refresh_failed", "manual provider models refresh failed", { providerId, errorMessage });
+                res.status(400).json({ error: { code: "manual_provider_models_refresh_failed", message: errorMessage } });
+            }
+        });
         controlApp.post("/routing/manual-providers/local", async (req, res) => {
             try {
                 const body = (req.body ?? {});
@@ -3844,7 +4430,7 @@ export class TokenbuddyDaemon {
                     apiKeyEnv: undefined,
                     secretRef,
                     models: probe.modelIds,
-                    supportedProtocols: Array.isArray(body.supportedProtocols) ? body.supportedProtocols : ["chat_completions"],
+                    supportedProtocols: probe.supportedProtocols,
                     enabled: body.enabled === undefined ? true : body.enabled
                 };
                 delete providerInput.apiKey;
@@ -3863,6 +4449,7 @@ export class TokenbuddyDaemon {
                 logger.info("routing.manual_provider.local_created", "local manual provider created", {
                     providerId: provider.id,
                     modelCount: provider.models.length,
+                    supportedProtocols: provider.supportedProtocols,
                     enabled: provider.enabled,
                     keyRefKind: "secret"
                 });
@@ -3936,7 +4523,7 @@ export class TokenbuddyDaemon {
                     baseUrl,
                     secretRef,
                     models: probe.modelIds,
-                    supportedProtocols: provider.supportedProtocols.length > 0 ? provider.supportedProtocols : ["chat_completions"],
+                    supportedProtocols: probe.supportedProtocols,
                     enabled: body.enabled === undefined ? provider.enabled : body.enabled,
                     updatedAt: new Date().toISOString()
                 }, {
@@ -3956,6 +4543,7 @@ export class TokenbuddyDaemon {
                 logger.info("routing.manual_provider.local_updated", "local manual provider updated", {
                     providerId: updatedProvider.id,
                     modelCount: updatedProvider.models.length,
+                    supportedProtocols: updatedProvider.supportedProtocols,
                     enabled: updatedProvider.enabled,
                     keyRefKind: "secret"
                 });
@@ -4465,6 +5053,8 @@ export class TokenbuddyDaemon {
         await this.refreshSellerRouteMetadata(registrySellers);
         this.sellerPool.ensureRegistrySellers(registrySellers);
         const poolById = new Map(this.sellerPool.snapshot().map((entry) => [entry.sellerId, entry]));
+        const concurrencySnapshot = this.sellerConcurrencyLimiter.snapshot();
+        const localConcurrencyBySellerId = new Map(concurrencySnapshot.active.map((entry) => [entry.sellerId, entry.activeCount]));
         const plan = planSellerRouteSet({
             modelId,
             protocol,
@@ -4472,7 +5062,12 @@ export class TokenbuddyDaemon {
             registrySellers,
             routing: resolvedRouting,
             prewarmCandidates: this.prewarmCache.get(modelId, protocol, paymentMethod)?.candidates,
-            sellerMetrics: Array.from(poolById.values()).map((entry) => this.routeMetricFromPoolEntry(entry)),
+            sellerMetrics: Array.from(poolById.values()).map((entry) => this.routeMetricFromPoolEntry(entry, concurrencySnapshot.enabled
+                ? {
+                    localConcurrencyActive: localConcurrencyBySellerId.get(entry.sellerId) ?? 0,
+                    localConcurrencyLimit: concurrencySnapshot.maxInFlightPerSeller
+                }
+                : undefined)),
             now: Date.now()
         });
         return { modelId, protocol, paymentMethod, plan };
@@ -4673,6 +5268,141 @@ function parseOpenAiModelIds(value) {
     })
         .filter((id, index, all) => all.indexOf(id) === index);
 }
+function hasOpenAiChatChoice(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const choices = value.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return false;
+    }
+    return choices.some((choice) => {
+        if (!choice || typeof choice !== "object" || Array.isArray(choice)) {
+            return false;
+        }
+        const message = choice.message;
+        return Boolean(message && typeof message === "object" && !Array.isArray(message));
+    });
+}
+function manualProviderProtocolProbeBody(protocol, modelId) {
+    if (protocol === "responses") {
+        return {
+            model: modelId,
+            input: "ping",
+            max_output_tokens: 1,
+            stream: false
+        };
+    }
+    if (protocol === "images_generations") {
+        return {
+            model: modelId,
+            prompt: "ping",
+            n: 0,
+            size: "1024x1024"
+        };
+    }
+    return {
+        model: modelId,
+        messages: [{ role: "user", content: "ping" }],
+        max_tokens: 1,
+        stream: false
+    };
+}
+function manualProviderProbeModelCandidates(modelIds, protocol) {
+    const uniqueIds = modelIds.filter((id, index) => Boolean(id) && modelIds.indexOf(id) === index);
+    if (protocol === "images_generations") {
+        return imageProbeModelCandidates(uniqueIds);
+    }
+    const preferredExactIds = [
+        "openai/gpt-chat-latest",
+        "openai/gpt-5.5",
+        "openai/gpt-5.4",
+        "gpt-5.5",
+        "gpt-5.4",
+        "gpt-5.2",
+        "gpt-4o",
+        "gpt-4.1",
+        "minimax/minimax-m3",
+        "deepseek/deepseek-v4-pro"
+    ];
+    const preferredPrefixes = ["openai/", "qwen/", "google/", "minimax/", "deepseek/"];
+    const candidates = [];
+    const push = (id) => {
+        if (id && !candidates.includes(id)) {
+            candidates.push(id);
+        }
+    };
+    for (const id of preferredExactIds) {
+        push(uniqueIds.find((candidate) => candidate === id));
+    }
+    for (const prefix of preferredPrefixes) {
+        push(uniqueIds.find((candidate) => candidate.startsWith(prefix)));
+    }
+    for (const id of uniqueIds) {
+        push(id);
+        if (candidates.length >= 6) {
+            break;
+        }
+    }
+    return candidates.slice(0, 6);
+}
+function imageProbeModelCandidates(uniqueIds) {
+    const preferredExactIds = [
+        "gpt-image-2",
+        "gpt-image-1.5",
+        "gpt-image-1",
+        "openai/gpt-image-2",
+        "openai/gpt-image-1.5",
+        "openai/gpt-image-1"
+    ];
+    const candidates = [];
+    const push = (id) => {
+        if (id && !candidates.includes(id)) {
+            candidates.push(id);
+        }
+    };
+    for (const id of preferredExactIds) {
+        push(uniqueIds.find((candidate) => candidate === id));
+    }
+    for (const id of uniqueIds) {
+        if (/(^|\/)gpt-image/i.test(id)) {
+            push(id);
+        }
+    }
+    for (const id of uniqueIds) {
+        push(id);
+        if (candidates.length >= 6) {
+            break;
+        }
+    }
+    return candidates.slice(0, 6);
+}
+async function readResponseText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return "";
+    }
+}
+function imageValidationProbeSupported(httpStatus, responseText) {
+    if (httpStatus !== 400) {
+        return false;
+    }
+    const message = imageProbeErrorMessage(responseText).toLowerCase();
+    return message.includes("n must be greater than 0") ||
+        message.includes("n must be at least 1") ||
+        message.includes("greater than or equal to 1");
+}
+function imageProbeErrorMessage(responseText) {
+    try {
+        const parsed = JSON.parse(responseText);
+        return typeof parsed.error?.message === "string" ? parsed.error.message : "";
+    }
+    catch {
+        return "";
+    }
+}
 function normalizeTrustedRegistryCache(value) {
     if (!value || typeof value !== "object") {
         return undefined;