routstrd 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "routstrd",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "module": "src/index.ts",
   "type": "module",
   "private": false,
@@ -24,7 +24,7 @@
   },
   "dependencies": {
     "@cashu/cashu-ts": "^3.1.1",
-    "@routstr/sdk": "^0.2.8",
+    "@routstr/sdk": "^0.2.9",
     "applesauce-core": "^5.1.0",
     "applesauce-relay": "^5.1.0",
     "commander": "^14.0.2",

package/src/cli.ts

@@ -365,9 +365,59 @@ program
   .command("models")
   .description("List available routstr21 models")
   .option("-r, --refresh", "Force refresh routstr21 models from Nostr", false)
-  .action(async (options: { refresh: boolean }) => {
+  .option("-m, --model <id>", "Show providers for a specific model")
+  .action(async (options: { refresh: boolean; model?: string }) => {
     await ensureDaemonRunning();
 
+    if (options.model) {
+      // Show providers for specific model
+      const result = await callDaemon(`/models/${encodeURIComponent(options.model)}/providers`);
+      if (result.error) {
+        console.log(result.error);
+        process.exit(1);
+      }
+
+      const modelData = result.output as {
+        id: string;
+        name?: string;
+        description?: string;
+        context_length?: number;
+        providers: Array<{
+          baseUrl: string;
+          pricing: {
+            prompt: number;
+            completion: number;
+            request: number;
+            max_cost: number;
+          };
+        }>;
+      } | undefined;
+
+      if (!modelData) {
+        console.log("Model not found");
+        process.exit(1);
+      }
+
+      console.log(`\n${modelData.name || modelData.id}`);
+      if (modelData.description) {
+        console.log(`  ${modelData.description}`);
+      }
+      if (modelData.context_length) {
+        console.log(`  Context: ${modelData.context_length.toLocaleString()} tokens`);
+      }
+      console.log(`\n  Providers (${modelData.providers.length}):`);
+      for (const provider of modelData.providers) {
+        console.log(`\n    ${provider.baseUrl}`);
+        console.log(`      Prompt:     ${(provider.pricing.prompt * 1000000).toFixed(2)} sats/M tokens`);
+        console.log(`      Completion: ${(provider.pricing.completion * 1000000).toFixed(2)} sats/M tokens`);
+        console.log(`      Request:    ${provider.pricing.request.toFixed(2)} sats`);
+        console.log(`      Max cost:   ${provider.pricing.max_cost.toFixed(2)} sats`);
+      }
+      console.log("");
+      return;
+    }
+
+    // List all models with interactive selection
     const result = await callDaemon(
       options.refresh ? "/models?refresh=true" : "/models",
     );
@@ -386,6 +436,7 @@ program
         console.log("No routstr21 models found");
       } else {
         console.log(`\nFound ${models.length} routstr21 models:`);
+        console.log("(Use 'routstrd models -m <model_id>' to see providers and pricing)\n");
         models.forEach((model, i) => {
           const details = [
             model.name && model.name !== model.id ? model.name : null,
@@ -393,8 +444,9 @@ program
           ]
             .filter(Boolean)
             .join(" - ");
-          console.log(`${i + 1}. ${model.id}${details ? ` (${details})` : ""}`);
+          console.log(`  ${String(i + 1).padStart(2)}. ${model.id}${details ? ` (${details})` : ""}`);
         });
+        console.log("");
       }
     }
   });

package/src/daemon/http/index.ts

@@ -37,6 +37,7 @@ type DaemonDeps = {
   modelManager: any;
   ensureProvidersBootstrapped: () => Promise<void>;
   getRoutstr21Models: (forceRefresh?: boolean) => Promise<any[]>;
+  getModelProviders: (modelId: string) => Promise<any>;
   mode?: ClientMode;
   providerManager: ProviderManager;
 };
@@ -277,6 +278,7 @@ export function createDaemonRequestHandler(deps: {
   modelManager: any;
   ensureProvidersBootstrapped: () => Promise<void>;
   getRoutstr21Models: (forceRefresh?: boolean) => Promise<any[]>;
+  getModelProviders: (modelId: string) => Promise<any>;
   mode?: "xcashu" | "apikeys";
   usageTrackingDriver: UsageTrackingDriver;
   providerManager: ProviderManager;
@@ -423,6 +425,23 @@ export function createDaemonRequestHandler(deps: {
       return;
     }
 
+    // Get providers for a specific model
+    const modelProvidersMatch = url.pathname.match(/^\/models\/([^\/]+)\/providers$/);
+    if (req.method === "GET" && modelProvidersMatch && modelProvidersMatch[1]) {
+      try {
+        const modelId = decodeURIComponent(modelProvidersMatch[1]);
+        const modelWithProviders = await deps.getModelProviders(modelId);
+        if (!modelWithProviders) {
+          sendJson(res, 404, { error: `Model '${modelId}' not found` });
+          return;
+        }
+        sendJson(res, 200, { output: modelWithProviders });
+      } catch (error) {
+        sendJson(res, 500, { error: toErrorMessage(error) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/v1/models") {
       try {
         const forceRefresh =

package/src/daemon/index.ts

@@ -50,7 +50,7 @@ async function main(): Promise<void> {
   const modelManager = new ModelManager(discoveryAdapter);
   // Create shared ProviderManager for consistent failure tracking across all requests
   const providerManager = new ProviderManager(providerRegistry, store);
-  const { ensureProvidersBootstrapped, getRoutstr21Models } =
+  const { ensureProvidersBootstrapped, getRoutstr21Models, getModelProviders } =
     createModelService(modelManager);
 
   const walletClient = createCocodClient({ cocodPath: config.cocodPath });
@@ -74,6 +74,7 @@ async function main(): Promise<void> {
       modelManager,
       ensureProvidersBootstrapped,
       getRoutstr21Models,
+      getModelProviders,
       mode: config.mode || "apikeys",
       usageTrackingDriver,
       providerManager,

package/src/daemon/models.ts

@@ -2,6 +2,20 @@ import { ModelManager } from "@routstr/sdk";
 import type { ExposedModel } from "./types";
 import { logger } from "../utils/logger";
 
+export type ModelProviderInfo = {
+  baseUrl: string;
+  pricing: {
+    prompt: number;
+    completion: number;
+    request: number;
+    max_cost: number;
+  };
+};
+
+export type ModelWithProviders = ExposedModel & {
+  providers: ModelProviderInfo[];
+};
+
 export function createModelService(modelManager: ModelManager) {
   let providerBootstrapPromise: Promise<void> | null = null;
 
@@ -42,8 +56,57 @@ export function createModelService(modelManager: ModelManager) {
     });
   };
 
+  const getModelProviders = async (
+    modelId: string,
+  ): Promise<ModelWithProviders | null> => {
+    await ensureProvidersBootstrapped();
+
+    const allModels = modelManager.getAllCachedModels();
+    const providers: ModelProviderInfo[] = [];
+
+    for (const [baseUrl, models] of Object.entries(allModels)) {
+      const model = models.find((m) => m.id === modelId);
+      if (model && model.sats_pricing) {
+        providers.push({
+          baseUrl,
+          pricing: {
+            prompt: model.sats_pricing.prompt,
+            completion: model.sats_pricing.completion,
+            request: model.sats_pricing.request,
+            max_cost: model.sats_pricing.max_cost,
+          },
+        });
+      }
+    }
+
+    // Sort by max_cost (cheapest first)
+    providers.sort((a, b) => a.pricing.max_cost - b.pricing.max_cost);
+
+    if (providers.length === 0) {
+      return null;
+    }
+
+    // Get model metadata from first provider that has it
+    const cheapest = providers[0]!;
+    const firstProvider = allModels[cheapest.baseUrl];
+    const modelInfo = firstProvider?.find((m: { id: string }) => m.id === modelId);
+
+    if (!modelInfo) {
+      return null;
+    }
+
+    return {
+      id: modelInfo.id,
+      name: modelInfo.name,
+      description: modelInfo.description,
+      context_length: modelInfo.context_length,
+      providers,
+    };
+  };
+
   return {
     ensureProvidersBootstrapped,
     getRoutstr21Models,
+    getModelProviders,
   };
 }