@tokenbuddy/tokenbuddy 1.0.38 → 1.0.40

package/dist/src/daemon.js

@@ -34,6 +34,9 @@ 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;
+const MANUAL_PROVIDER_PROBE_TIMEOUT_MS = 30_000;
+const RECONNECT_OPENCODE_PROTOCOLS = ["chat_completions", "responses", "messages"];
+const RECONNECT_PROVIDER_IDS = ["codex", "claude-code", "claude-desktop", "openclaw", "opencode", "hermes"];
 class BuyerPaymentSetupError extends Error {
     errorCode;
     statusCode;
@@ -143,6 +146,39 @@ function nonNegativeIntegerField(value) {
 function nonNegativeFiniteField(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
+function nonNegativeUsdMicrosField(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) && value >= 0 ? Math.round(value * 1_000_000) : undefined;
+    }
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim().replace(/^\$/, "");
+    if (!normalized) {
+        return undefined;
+    }
+    const parsed = Number(normalized);
+    return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed * 1_000_000) : undefined;
+}
+function extractUpstreamCostMicros(data, usage) {
+    const costDetails = usageRecord(data?.cost_details) ?? usageRecord(usage?.cost_details);
+    return nonNegativeIntegerField(usage?.cost_micros)
+        ?? nonNegativeIntegerField(usage?.costMicros)
+        ?? nonNegativeIntegerField(data?.cost_micros)
+        ?? nonNegativeIntegerField(data?.costMicros)
+        ?? nonNegativeUsdMicrosField(usage?.cost)
+        ?? nonNegativeUsdMicrosField(usage?.total_cost)
+        ?? nonNegativeUsdMicrosField(usage?.totalCost)
+        ?? nonNegativeUsdMicrosField(usage?.cost_usd)
+        ?? nonNegativeUsdMicrosField(usage?.costUsd)
+        ?? nonNegativeUsdMicrosField(data?.cost)
+        ?? nonNegativeUsdMicrosField(data?.total_cost)
+        ?? nonNegativeUsdMicrosField(data?.totalCost)
+        ?? nonNegativeUsdMicrosField(data?.cost_usd)
+        ?? nonNegativeUsdMicrosField(data?.costUsd)
+        ?? nonNegativeUsdMicrosField(costDetails?.upstream_inference_cost)
+        ?? nonNegativeUsdMicrosField(costDetails?.upstreamInferenceCost);
+}
 function usageRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
@@ -625,8 +661,19 @@ export class TokenbuddyDaemon {
         const fetchBootstrap = this.config.clawtipBootstrapFetcher || fetchClawtipBootstrap;
         const bootstrap = await fetchBootstrap(bootstrapUrl);
         const payment = normalizeClawtipActivationPayment(bootstrap);
-        const startBootstrap = this.config.clawtipWalletBootstrapStarter || startClawtipWalletBootstrap;
-        const activation = await startBootstrap(payment, { home: this.config.clawtipHomeDir });
+        let activation;
+        try {
+            activation = await this.startClawtipActivationWithRebindFallback(payment);
+        }
+        catch (error) {
+            if (isClawtipBalanceInsufficientError(error)) {
+                logger.info("control.payment.clawtip.activation_recharge_required", "ClawTip activation returned recharge QR after insufficient balance", {
+                    failureReason: error instanceof Error ? error.message : String(error)
+                });
+                return this.clawtipRechargeQr();
+            }
+            throw error;
+        }
         if (!activation.parsedOutput.mediaPath) {
             throw new Error("ClawTip activation did not return a QR image.");
         }
@@ -679,6 +726,34 @@ export class TokenbuddyDaemon {
             payCredentialWritten: Boolean(activation.payCredential)
         };
     }
+    async startClawtipActivationWithRebindFallback(payment) {
+        const startBootstrap = this.config.clawtipWalletBootstrapStarter || startClawtipWalletBootstrap;
+        try {
+            return await startBootstrap(payment, { home: this.config.clawtipHomeDir });
+        }
+        catch (error) {
+            if (isClawtipBalanceInsufficientError(error)) {
+                throw error;
+            }
+            const walletConfig = inspectOpenClawWalletConfig(this.config.clawtipHomeDir);
+            if (!walletConfig.exists) {
+                throw error;
+            }
+            const backupPath = backupOpenClawWalletConfigForRebind(walletConfig.expectedPath);
+            logger.info("control.payment.clawtip.rebind_retry", "ClawTip activation retrying with wallet rebind QR", {
+                walletConfigPath: walletConfig.expectedPath,
+                backupPath,
+                failureReason: error instanceof Error ? error.message : String(error)
+            });
+            try {
+                return await startBootstrap(payment, { home: this.config.clawtipHomeDir });
+            }
+            catch (retryError) {
+                restoreOpenClawWalletConfigBackup(walletConfig.expectedPath, backupPath);
+                throw retryError;
+            }
+        }
+    }
     scheduleClawtipActivationWait(clawtipId) {
         if (this.clawtipActivationWait) {
             return;
@@ -1107,6 +1182,322 @@ export class TokenbuddyDaemon {
             }
         };
     }
+    isReconnectProviderId(value) {
+        return typeof value === "string" && RECONNECT_PROVIDER_IDS.includes(value);
+    }
+    uniqueModelIds(modelIds) {
+        const seen = new Set();
+        const output = [];
+        for (const modelId of modelIds) {
+            const trimmed = modelId.trim();
+            if (!trimmed || seen.has(trimmed)) {
+                continue;
+            }
+            seen.add(trimmed);
+            output.push(trimmed);
+        }
+        return output;
+    }
+    reconnectProtocolForProvider(providerId) {
+        if (providerId === "codex") {
+            return "responses";
+        }
+        if (providerId === "claude-code" || providerId === "claude-desktop") {
+            return "messages";
+        }
+        return "chat_completions";
+    }
+    reconnectProtocolsForProvider(providerId) {
+        if (providerId === "opencode") {
+            return [...RECONNECT_OPENCODE_PROTOCOLS];
+        }
+        return [this.reconnectProtocolForProvider(providerId)];
+    }
+    catalogModelSupportsProtocol(model, protocol) {
+        if (protocol === "messages") {
+            return model.supportedProtocols.includes("messages") || model.supportedProtocols.includes("anthropic_messages");
+        }
+        return model.supportedProtocols.includes(protocol);
+    }
+    catalogModelsByProtocol(models, protocols) {
+        const result = {};
+        for (const protocol of protocols) {
+            const modelIds = this.uniqueModelIds(models
+                .filter((model) => this.catalogModelSupportsProtocol(model, protocol))
+                .map((model) => model.id));
+            if (modelIds.length > 0) {
+                result[protocol] = modelIds;
+            }
+        }
+        return result;
+    }
+    previousProviderDefaultModel(providerId) {
+        const runtime = this.tokenStore.getProviderRuntimeConfig(providerId)?.config;
+        if (!runtime) {
+            return undefined;
+        }
+        if (runtime.selectionKind === "claude-role-mapping") {
+            return runtime.fallbackModel ||
+                runtime.roles.sonnet?.upstreamModel ||
+                runtime.roles.opus?.upstreamModel ||
+                runtime.roles.haiku?.upstreamModel;
+        }
+        return runtime.defaultModel;
+    }
+    pickReconnectDefaultModel(providerId, models) {
+        const protocols = this.reconnectProtocolsForProvider(providerId);
+        const compatible = this.uniqueModelIds(models
+            .filter((model) => protocols.some((protocol) => this.catalogModelSupportsProtocol(model, protocol)))
+            .map((model) => model.id));
+        if (compatible.length === 0) {
+            return undefined;
+        }
+        const previous = this.previousProviderDefaultModel(providerId);
+        if (previous && compatible.includes(previous)) {
+            return previous;
+        }
+        return compatible.find((model) => model === "gpt-5.4") ||
+            compatible.find((model) => model.toLowerCase().includes("gpt")) ||
+            compatible[0];
+    }
+    reconnectProviderSelection(providerId, models) {
+        const defaultModel = this.pickReconnectDefaultModel(providerId, models);
+        if (!defaultModel) {
+            throw new Error(`no compatible models available for ${providerId}`);
+        }
+        if (providerId === "claude-code") {
+            return {
+                selectionKind: "claude-role-mapping",
+                protocolPreference: "messages",
+                fallbackModel: defaultModel,
+                roles: {
+                    sonnet: {
+                        upstreamModel: defaultModel,
+                        displayName: defaultModel,
+                        declareOneM: true
+                    },
+                    opus: {
+                        upstreamModel: defaultModel,
+                        displayName: defaultModel,
+                        declareOneM: true
+                    },
+                    haiku: {
+                        upstreamModel: defaultModel,
+                        displayName: defaultModel
+                    }
+                }
+            };
+        }
+        return {
+            selectionKind: "single-model",
+            protocolPreference: this.reconnectProtocolForProvider(providerId),
+            defaultModel,
+            availableModelsByProtocol: this.catalogModelsByProtocol(models, this.reconnectProtocolsForProvider(providerId))
+        };
+    }
+    reconnectProviderSelections(providerIds, models) {
+        const selections = {};
+        for (const providerId of providerIds) {
+            selections[providerId] = this.reconnectProviderSelection(providerId, models);
+        }
+        return selections;
+    }
+    manualProviderModelCatalog() {
+        const manualConfig = this.currentManualProviders();
+        const observations = new Map(this.currentManualProviderObservations().observations.map((entry) => [entry.providerId, entry]));
+        const providers = manualConfig.routing.policy === "locked"
+            ? manualConfig.providers.filter((provider) => provider.enabled && provider.id === manualConfig.routing.lockedProviderId)
+            : manualConfig.providers.filter((provider) => provider.enabled);
+        return {
+            models: providers.flatMap((provider) => provider.models.map((modelId) => ({
+                id: modelId,
+                sellerId: provider.id,
+                sellerName: provider.name,
+                sellerUrl: provider.baseUrl,
+                supportedProtocols: provider.supportedProtocols,
+                paymentMethods: ["provider_key"]
+            }))),
+            sellers: providers.map((provider) => {
+                const observation = observations.get(provider.id);
+                return {
+                    id: provider.id,
+                    name: provider.name,
+                    url: provider.baseUrl,
+                    status: observation?.status ?? "active",
+                    routeState: this.routeStateFromCatalogStatus(observation?.status ?? "active"),
+                    ttftMs: observation?.ttftMs,
+                    avgTokensPerSecond: observation?.avgTokensPerSecond
+                };
+            })
+        };
+    }
+    async discoverSellerModelCatalog() {
+        if (this.forceRegistrySnapshotForTest && this.lastRegistrySnapshot) {
+            const snapshot = catalogSnapshotFromRegistry(this.lastRegistrySnapshot);
+            return {
+                models: snapshot.models,
+                sellers: this.sellerCatalogWithRuntimeMetrics(snapshot.sellers)
+            };
+        }
+        try {
+            const catalog = await discoverSellerBackedModels(this.config.sellerRegistryUrl);
+            this.lastRegistrySnapshot = catalog.registry ?? sellerCatalogResultToRegistrySnapshot(catalog);
+            if (catalog.registry && catalog.registryJson && catalog.registryTrust) {
+                this.saveTrustedRegistryCache({
+                    registry: catalog.registry,
+                    registryJson: catalog.registryJson,
+                    trust: catalog.registryTrust
+                });
+            }
+            return {
+                models: catalog.models,
+                sellers: this.sellerCatalogWithRuntimeMetrics(catalog.sellers)
+            };
+        }
+        catch (error) {
+            const cached = this.loadTrustedRegistryCache(error);
+            if (!cached) {
+                throw error;
+            }
+            const snapshot = catalogSnapshotFromRegistry(cached);
+            return {
+                models: snapshot.models,
+                sellers: this.sellerCatalogWithRuntimeMetrics(snapshot.sellers)
+            };
+        }
+    }
+    async refreshEnabledManualProviderModels() {
+        const config = this.currentManualProviders();
+        const now = new Date().toISOString();
+        const refreshedProviders = [];
+        const warnings = [];
+        const providers = [];
+        for (const provider of config.providers) {
+            if (!provider.enabled) {
+                providers.push(provider);
+                continue;
+            }
+            try {
+                const probe = await this.probeManualProviderModels({
+                    baseUrl: provider.baseUrl,
+                    apiKey: this.manualProviderApiKey(provider)
+                });
+                providers.push({
+                    ...provider,
+                    models: probe.modelIds,
+                    supportedProtocols: probe.supportedProtocols,
+                    updatedAt: now
+                });
+                refreshedProviders.push(provider.id);
+                this.recordManualProviderProbeResult({
+                    providerId: provider.id,
+                    status: "healthy"
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                providers.push(provider);
+                warnings.push({
+                    code: "manual_provider_refresh_failed",
+                    providerId: provider.id,
+                    message: errorMessage
+                });
+                this.recordManualProviderProbeResult({
+                    providerId: provider.id,
+                    status: "unhealthy",
+                    errorClass: "models_refresh_failed",
+                    errorMessage
+                });
+            }
+        }
+        if (refreshedProviders.length > 0) {
+            this.saveManualProviders({
+                version: 1,
+                providers,
+                routing: config.routing,
+                updatedAt: now
+            });
+        }
+        return { refreshedProviders, warnings };
+    }
+    filterAutoEffectiveCatalog(catalog) {
+        const config = this.currentAutoProviderConfig();
+        const warnings = [];
+        if (!config.enabled) {
+            warnings.push({
+                code: "auto_provider_disabled",
+                message: "auto provider is disabled"
+            });
+            return {
+                mode: "auto",
+                source: "auto",
+                models: [],
+                sellers: [],
+                warnings,
+                refreshedProviders: [],
+                unavailableModelIds: config.modelIds
+            };
+        }
+        if (config.modelIds.length === 0) {
+            warnings.push({
+                code: "auto_provider_models_empty",
+                message: "auto provider has no selected models"
+            });
+            return {
+                mode: "auto",
+                source: "auto",
+                models: [],
+                sellers: [],
+                warnings,
+                refreshedProviders: [],
+                unavailableModelIds: []
+            };
+        }
+        const selectedModels = new Set(config.modelIds);
+        const selectedSellers = new Set(config.sellerIds);
+        const models = catalog.models.filter((model) => {
+            return selectedModels.has(model.id) &&
+                (config.range !== "custom" || selectedSellers.has(model.sellerId));
+        });
+        const sellerIds = new Set(models.map((model) => model.sellerId));
+        const sellers = catalog.sellers.filter((seller) => sellerIds.has(seller.id));
+        const availableModelIds = new Set(models.map((model) => model.id));
+        const unavailableModelIds = config.modelIds.filter((modelId) => !availableModelIds.has(modelId));
+        if (unavailableModelIds.length > 0) {
+            warnings.push({
+                code: "auto_provider_selected_models_unavailable",
+                message: `selected models unavailable in current auto provider catalog: ${unavailableModelIds.join(", ")}`
+            });
+        }
+        return {
+            mode: "auto",
+            source: "auto",
+            models,
+            sellers,
+            warnings,
+            refreshedProviders: [],
+            unavailableModelIds
+        };
+    }
+    async effectiveModelCatalog(options) {
+        const mode = this.currentProviderMode().mode;
+        if (mode === "manual") {
+            const refresh = options.refreshModels
+                ? await this.refreshEnabledManualProviderModels()
+                : { refreshedProviders: [], warnings: [] };
+            const catalog = this.manualProviderModelCatalog();
+            return {
+                mode,
+                source: "manual",
+                models: catalog.models,
+                sellers: catalog.sellers,
+                warnings: refresh.warnings,
+                refreshedProviders: refresh.refreshedProviders,
+                unavailableModelIds: []
+            };
+        }
+        return this.filterAutoEffectiveCatalog(await this.discoverSellerModelCatalog());
+    }
     clientToolsSummary() {
         const providerStatuses = detectProviders({ home: this.config.providerHomeDir }).map(clientToolStatusFromProvider);
         const clients = [
@@ -2041,6 +2432,8 @@ export class TokenbuddyDaemon {
             ?? nonNegativeIntegerField(usage?.cache_read_input_tokens)
             ?? nonNegativeIntegerField(usage?.cache_read_tokens)
             ?? 0;
+        const upstreamCostMicros = extractUpstreamCostMicros(data, usage);
+        const billablePromptTokens = Math.max(0, promptTokens - cacheReadTokens);
         const imageMetadata = endpoint === "/v1/images/generations"
             ? imageUsageMetadata(data, usageRecord(requestBody))
             : {};
@@ -2048,7 +2441,8 @@ export class TokenbuddyDaemon {
             promptTokens,
             completionTokens,
             cacheReadTokens,
-            billedMicros: (promptTokens + completionTokens) * 4,
+            billedMicros: upstreamCostMicros ?? (billablePromptTokens + completionTokens) * 4,
+            ...(upstreamCostMicros === undefined ? {} : { upstreamCostMicros }),
             ...imageMetadata
         };
     }
@@ -2674,10 +3068,13 @@ export class TokenbuddyDaemon {
     }
     manualProviderEndpointUrl(provider, endpoint) {
         const baseUrl = provider.baseUrl.replace(/\/+$/, "");
-        if (baseUrl.endsWith("/v1") && endpoint.startsWith("/v1/")) {
-            return `${baseUrl}${endpoint.slice(3)}`;
+        const upstreamEndpoint = endpoint === "/messages" && !baseUrl.endsWith("/v1")
+            ? "/v1/messages"
+            : endpoint;
+        if (baseUrl.endsWith("/v1") && upstreamEndpoint.startsWith("/v1/")) {
+            return `${baseUrl}${upstreamEndpoint.slice(3)}`;
         }
-        return `${baseUrl}${endpoint}`;
+        return `${baseUrl}${upstreamEndpoint}`;
     }
     manualProviderEndpointUrlFromBase(baseUrl, endpoint) {
         const normalized = baseUrl.replace(/\/+$/, "");
@@ -2702,7 +3099,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);
+        const timer = setTimeout(() => ac.abort(new Error("manual provider model probe timeout")), this.config.warmupProbeTimeoutMs ?? MANUAL_PROVIDER_PROBE_TIMEOUT_MS);
         let modelIds = [];
         try {
             const response = await fetch(this.manualProviderEndpointUrlFromBase(parsed.toString(), "/v1/models"), {
@@ -2752,9 +3149,10 @@ export class TokenbuddyDaemon {
         const protocols = [
             { protocol: "chat_completions", endpoint: "/v1/chat/completions" },
             { protocol: "responses", endpoint: "/v1/responses" },
+            { protocol: "messages", endpoint: "/v1/messages" },
             { protocol: "images_generations", endpoint: "/v1/images/generations" }
         ];
-        const timeoutMs = this.config.warmupProbeTimeoutMs ?? 3000;
+        const timeoutMs = this.config.warmupProbeTimeoutMs ?? MANUAL_PROVIDER_PROBE_TIMEOUT_MS;
         return Promise.all(protocols.map((protocol) => this.probeManualProviderProtocol(input, protocol, timeoutMs)));
     }
     async probeManualProviderProtocol(input, protocol, timeoutMs) {
@@ -2780,7 +3178,8 @@ export class TokenbuddyDaemon {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
-                    "Authorization": `Bearer ${input.apiKey}`
+                    "Authorization": `Bearer ${input.apiKey}`,
+                    ...(protocol.protocol === "messages" ? { "anthropic-version": "2023-06-01" } : {})
                 },
                 body: JSON.stringify(manualProviderProtocolProbeBody(protocol.protocol, modelId)),
                 signal: ac.signal
@@ -2983,6 +3382,7 @@ export class TokenbuddyDaemon {
                 headers: {
                     "Content-Type": "application/json",
                     "Authorization": `Bearer ${this.manualProviderApiKey(provider)}`,
+                    ...(this.endpointProtocol(endpoint) === "messages" ? { "anthropic-version": "2023-06-01" } : {}),
                     "X-Request-Id": attemptContext.requestId,
                     "Idempotency-Key": attemptContext.idempotencyKey,
                     "X-TokenBuddy-Deadline-Ms": String(deadlineMs)
@@ -4069,6 +4469,44 @@ export class TokenbuddyDaemon {
                 });
             }
         });
+        controlApp.post("/models/refresh", async (req, res) => {
+            try {
+                const catalog = await this.effectiveModelCatalog({ refreshModels: true });
+                logger.info("models.effective_refresh.succeeded", "effective provider model catalog refreshed", {
+                    mode: catalog.mode,
+                    source: catalog.source,
+                    sellerCount: catalog.sellers.length,
+                    modelCount: catalog.models.length,
+                    refreshedProviderCount: catalog.refreshedProviders.length,
+                    warningCount: catalog.warnings.length
+                });
+                res.status(200).json({
+                    ok: true,
+                    object: "list",
+                    mode: catalog.mode,
+                    source: catalog.source,
+                    registryUrl: this.config.sellerRegistryUrl,
+                    data: catalog.models,
+                    sellers: catalog.sellers,
+                    refreshedProviders: catalog.refreshedProviders,
+                    unavailableModelIds: catalog.unavailableModelIds,
+                    warnings: catalog.warnings
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.warn("models.effective_refresh.failed", "effective provider model catalog refresh failed", {
+                    registryUrl: this.config.sellerRegistryUrl,
+                    errorMessage
+                });
+                res.status(502).json({
+                    error: {
+                        code: "models_refresh_failed",
+                        message: errorMessage
+                    }
+                });
+            }
+        });
         controlApp.post("/providers/detect", (req, res) => {
             try {
                 const providers = detectProviders({ home: typeof req.body?.home === "string" ? req.body.home : this.config.providerHomeDir });
@@ -4110,6 +4548,98 @@ export class TokenbuddyDaemon {
                 });
             }
         });
+        controlApp.post("/providers/reconnect", async (req, res) => {
+            try {
+                const rawProviders = Array.isArray(req.body?.providers) ? req.body.providers : [];
+                if (rawProviders.length === 0) {
+                    res.status(400).json({
+                        error: {
+                            code: "provider_reconnect_failed",
+                            message: "providers must include at least one provider id"
+                        }
+                    });
+                    return;
+                }
+                const providerIds = [];
+                for (const provider of rawProviders) {
+                    if (!this.isReconnectProviderId(provider)) {
+                        res.status(400).json({
+                            error: {
+                                code: "provider_reconnect_failed",
+                                message: `unsupported provider: ${String(provider)}`
+                            }
+                        });
+                        return;
+                    }
+                    if (!providerIds.includes(provider)) {
+                        providerIds.push(provider);
+                    }
+                }
+                const catalog = await this.effectiveModelCatalog({ refreshModels: req.body?.refreshModels !== false });
+                if (catalog.models.length === 0) {
+                    res.status(409).json({
+                        error: {
+                            code: "provider_reconnect_no_models",
+                            message: `no models available for current ${catalog.mode} provider mode`
+                        },
+                        mode: catalog.mode,
+                        source: catalog.source,
+                        warnings: catalog.warnings,
+                        unavailableModelIds: catalog.unavailableModelIds
+                    });
+                    return;
+                }
+                const providerSelections = this.reconnectProviderSelections(providerIds, catalog.models);
+                const firstSelection = providerSelections[providerIds[0]];
+                const model = firstSelection?.selectionKind === "claude-role-mapping"
+                    ? firstSelection.fallbackModel
+                    : firstSelection?.defaultModel;
+                const proxyUrl = `http://127.0.0.1:${this.activeProxyPort()}`;
+                const applied = applyProviderInstall({
+                    providers: providerIds,
+                    proxyUrl,
+                    model,
+                    providerSelections,
+                    home: typeof req.body?.home === "string" ? req.body.home : this.config.providerHomeDir
+                }, this.tokenStore);
+                const protocolCounts = catalog.models.reduce((counts, entry) => {
+                    for (const protocol of entry.supportedProtocols) {
+                        counts[protocol] = (counts[protocol] ?? 0) + 1;
+                    }
+                    return counts;
+                }, {});
+                logger.info("provider.reconnect.applied", "provider reconnect applied with refreshed models", {
+                    providerCount: providerIds.length,
+                    changeCount: applied.length,
+                    mode: catalog.mode,
+                    source: catalog.source,
+                    modelCount: catalog.models.length,
+                    warningCount: catalog.warnings.length
+                });
+                res.status(200).json({
+                    ok: true,
+                    mode: catalog.mode,
+                    source: catalog.source,
+                    modelCount: catalog.models.length,
+                    sellerCount: catalog.sellers.length,
+                    protocolCounts,
+                    refreshedProviders: catalog.refreshedProviders,
+                    unavailableModelIds: catalog.unavailableModelIds,
+                    warnings: catalog.warnings,
+                    applied
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.warn("provider.reconnect.failed", "provider reconnect failed", { errorMessage });
+                res.status(400).json({
+                    error: {
+                        code: "provider_reconnect_failed",
+                        message: errorMessage
+                    }
+                });
+            }
+        });
         controlApp.post("/providers/install/preview", (req, res) => {
             try {
                 const changes = previewProviderInstall({
@@ -5176,6 +5706,37 @@ function safeQrExtension(filePath) {
 function safeStaticFileSegment(value) {
     return value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "clawtip";
 }
+function backupOpenClawWalletConfigForRebind(configPath) {
+    const backupPath = nextOpenClawWalletBackupPath(configPath);
+    fs.renameSync(configPath, backupPath);
+    return backupPath;
+}
+function restoreOpenClawWalletConfigBackup(configPath, backupPath) {
+    if (fs.existsSync(configPath) || !fs.existsSync(backupPath)) {
+        return;
+    }
+    fs.renameSync(backupPath, configPath);
+}
+function nextOpenClawWalletBackupPath(configPath) {
+    const stamp = new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
+    let candidate = `${configPath}.before-tokenbuddy-rebind-${stamp}`;
+    let counter = 1;
+    while (fs.existsSync(candidate)) {
+        counter += 1;
+        candidate = `${configPath}.before-tokenbuddy-rebind-${stamp}-${counter}`;
+    }
+    return candidate;
+}
+function isClawtipBalanceInsufficientError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const lower = message.toLowerCase();
+    return message.includes("余额不足")
+        || message.includes("余额不够")
+        || message.includes("账户余额")
+        || lower.includes("insufficient balance")
+        || lower.includes("not enough balance")
+        || lower.includes("not enough funds");
+}
 function readConfigString(config, key) {
     const value = config?.[key];
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
@@ -5313,6 +5874,9 @@ function manualProviderProbeModelCandidates(modelIds, protocol) {
     if (protocol === "images_generations") {
         return imageProbeModelCandidates(uniqueIds);
     }
+    if (protocol === "messages") {
+        return messagesProbeModelCandidates(uniqueIds);
+    }
     const preferredExactIds = [
         "openai/gpt-chat-latest",
         "openai/gpt-5.5",
@@ -5346,6 +5910,39 @@ function manualProviderProbeModelCandidates(modelIds, protocol) {
     }
     return candidates.slice(0, 6);
 }
+function messagesProbeModelCandidates(uniqueIds) {
+    const preferredExactIds = [
+        "claude-sonnet-4-6",
+        "claude-sonnet-4-5",
+        "claude-opus-4-7",
+        "claude-opus-4-6",
+        "claude-haiku-4-5",
+        "claude-3-7-sonnet-20250219",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022"
+    ];
+    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 (id.startsWith("claude-") || id.includes("/claude-")) {
+            push(id);
+        }
+    }
+    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",