routstrd 0.4.10 → 0.4.12

package/src/daemon/models.ts

@@ -1,4 +1,11 @@
-import { ModelManager, ProviderManager, type SdkStore } from "@routstr/sdk";
+import {
+  canonicalIdForModel,
+  findModelForId,
+  ModelManager,
+  ProviderManager,
+  type Model,
+  type SdkStore,
+} from "@routstr/sdk";
 import type { ExposedModel } from "./types";
 import { logger } from "../utils/logger";
 
@@ -66,13 +73,16 @@ export function createModelService(
 
       for (const model of models as PricedModel[]) {
         if (!model.sats_pricing) continue;
-        const existing = bestById.get(model.id);
+        // Group by canonical id so providers serving the same model under a
+        // mapped variant id or alias fold into one aggregate entry.
+        const canonicalId = canonicalIdForModel(model as Model);
+        const existing = bestById.get(canonicalId);
         if (
           !existing ||
           (model.sats_pricing.completion ?? 0) <
             (existing.sats_pricing?.completion ?? 0)
         ) {
-          bestById.set(model.id, model);
+          bestById.set(canonicalId, model);
         }
       }
     }
@@ -155,11 +165,19 @@ export function createModelService(
       );
     }
 
-    const modelsById = new Map(discoveredModels.map((model) => [model.id, model]));
-
+    // Resolve each routstr21 id against the aggregated provider models. The
+    // aggregation folds providers' mapped variant ids/aliases into one entry
+    // per canonical id, but the surviving entry is the provider's raw model,
+    // whose `.id` may be the variant (e.g. z-ai-glm-5-3-flash) — while still
+    // carrying the full metadata (context_length, architecture, reasoning).
+    // A plain id map would miss and degrade the entry to a bare stub, so
+    // resolve through the SDK's model mappings (exact native id wins, same as
+    // getModelProviders) and always expose the requested canonical id.
     return routstr21ModelIds.map((modelId) => {
-      const model = modelsById.get(modelId);
-      return model || { id: modelId, name: modelId };
+      const model = findModelForId(discoveredModels as Model[], modelId);
+      return model
+        ? { ...model, id: modelId }
+        : { id: modelId, name: modelId };
     });
   };
 
@@ -201,18 +219,35 @@ export function createModelService(
       return null;
     }
 
-    // Get model metadata from first (cheapest) provider
+    // Get model metadata. Prefer a provider that serves the requested
+    // canonical id natively (nicest name/description); fall back to the
+    // cheapest provider matched through the SDK's model mappings, since it
+    // may only know the model under a mapped variant id or alias.
     const cheapest = providers[0]!;
     const allModels = modelManager.getAllCachedModels();
-    const firstProvider = allModels[cheapest.baseUrl];
-    const modelInfo = firstProvider?.find((m: { id: string }) => m.id === modelId);
+    let modelInfo: Model | undefined;
+    for (const p of providers) {
+      const exact = (allModels[p.baseUrl] as Model[] | undefined)?.find(
+        (m) => m.id === modelId,
+      );
+      if (exact) {
+        modelInfo = exact;
+        break;
+      }
+    }
+    if (!modelInfo) {
+      const firstProvider = allModels[cheapest.baseUrl];
+      modelInfo = firstProvider
+        ? findModelForId(firstProvider as Model[], modelId)
+        : undefined;
+    }
 
     if (!modelInfo) {
       return null;
     }
 
     return {
-      id: modelInfo.id,
+      id: modelId,
       name: modelInfo.name,
       description: modelInfo.description,
       context_length: modelInfo.context_length,

package/src/daemon/wallet/auto-refill.ts

@@ -4,7 +4,7 @@
 //
 // Uses applesauce-wallet-connect (same approach as nwc_integration/pay_invoice.mts).
 
-import type { CocodClient } from "./cocod-client";
+import type { WalletClient } from "./wallet-client";
 import type { WalletConnect } from "applesauce-wallet-connect";
 import { logger } from "../../utils/logger";
 
@@ -33,10 +33,19 @@ function isFatalError(message: string): boolean {
 }
 
 export function startAutoRefillLoop(
-  cocod: CocodClient,
+  walletClient: WalletClient,
   getWallet: () => WalletConnect | undefined,
   getConfig: () => AutoRefillConfig | undefined,
   intervalMs: number = 5000,
+  payInvoice: (
+    invoice: string,
+  ) => Promise<{ preimage?: string; fees_paid?: number }> = (invoice) => {
+    const wallet = getWallet();
+    if (!wallet?.service) {
+      return Promise.reject(new Error("NWC not connected"));
+    }
+    return wallet.payInvoice(invoice);
+  },
 ): () => void {
   let lastRefillAt = 0;
   let lastAttemptAt = 0; // tracks last attempt (success or failure) for backoff
@@ -79,7 +88,7 @@ export function startAutoRefillLoop(
     checkInProgress = true;
 
     try {
-      const balances = await cocod.getBalances();
+      const balances = await walletClient.getBalances();
       const totalBalance = Object.values(balances).reduce<number>(
         (sum, b) => sum + (typeof b === "number" ? b : 0),
         0,
@@ -94,17 +103,20 @@ export function startAutoRefillLoop(
         `[auto-refill] Balance ${totalBalance} sats < threshold ${config.threshold}. Refilling ${config.amount} sats...`,
       );
 
-      const mintUrl = await cocod.getDefaultMint();
+      const mintUrl = await walletClient.getDefaultMint();
       if (!mintUrl) {
         logger.error("[auto-refill] No default mint configured");
         return;
       }
 
-      // Step 1: Create a BOLT-11 invoice via cocod to fund the Cashu wallet
+      // Step 1: Create a BOLT-11 invoice via the wallet to fund the Cashu wallet
       logger.log(
         `[auto-refill] Creating BOLT-11 invoice for ${config.amount} sats via ${mintUrl}...`,
       );
-      const { invoice } = await cocod.receiveBolt11(config.amount, mintUrl);
+      const { invoice } = await walletClient.receiveBolt11(
+        config.amount,
+        mintUrl,
+      );
 
       // Step 2: Pay the invoice via NWC (applesauce)
       logger.log(`[auto-refill] Paying invoice via NWC...`);
@@ -113,10 +125,10 @@ export function startAutoRefillLoop(
         logger.log("[auto-refill] Wallet disconnected during refill check");
         return;
       }
-      const payment = await currentWallet.payInvoice(invoice);
+      const payment = await payInvoice(invoice);
 
       // Step 3: The Cashu mint should automatically detect the paid invoice
-      // and issue tokens. We don't need to explicitly mint here; cocod
+      // and issue tokens. We don't need to explicitly mint here; the wallet
       // handles this on its end when the mint sees the payment.
       const preimage = payment.preimage;
       if (preimage) {

package/src/daemon/wallet/cleanup.ts

@@ -64,8 +64,8 @@ export interface CleanupSelection<
  *   can have happened before expiry while the daemon was down, leaving no
  *   local observation. Callers that fail quotes automatically at startup must
  *   therefore confirm UNPAID with the mint first (see
- *   settleExpiredMintQuotes in coco-client.ts); only the explicit,
- *   user-invoked cleanup command may fail candidates purely locally.
+ *   failExpiredMintQuoteIfUnpaid in coco-client.ts). Explicit cleanup follows
+ *   the same rule unless the operator opts into unsafe `--force` behaviour.
  * - Pending sends are reclaimed (rolled back) only when they are older than
  *   `minAgeMs`, so we never roll back a token that a receiver might still
  *   legitimately claim.
@@ -102,3 +102,17 @@ export function selectCleanupOperations<
 
   return { mintsToFail, sendsToReclaim, meltsToCancel };
 }
+
+/** Keep a local-only dry-run preview distinct from mint-confirmed outcomes. */
+export function summarizeMintCleanup(input: {
+  dryRun: boolean;
+  candidates: number;
+  failed: number;
+  leftForRecovery: number;
+}) {
+  return {
+    mintQuoteCandidates: input.candidates,
+    failedMintQuotes: input.dryRun ? 0 : input.failed,
+    leftForRecovery: input.dryRun ? 0 : input.leftForRecovery,
+  };
+}