@tokcalc/mcp-server 0.2.0-alpha.2 → 0.2.1

package/dist/index.js

@@ -12858,6 +12858,7 @@ function datetime2(params) {
 }
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
 var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
@@ -13031,6 +13032,7 @@ var InitializeRequestSchema = RequestSchema.extend({
   method: literal("initialize"),
   params: InitializeRequestParamsSchema
 });
+var isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
 var ServerCapabilitiesSchema = object({
   experimental: record(string2(), AssertObjectSchema).optional(),
   logging: AssertObjectSchema.optional(),
@@ -20402,7 +20404,7 @@ function calculate(input) {
   const computeCeiling = prefillTokensPerSec;
   const batchCrossover = quant.bytesPerParam * gpuFlops * 1000 * ETA_COMPUTE / (2 * gpu.memBandwidthGbps * ETA_MEM * quantEff * (tp > 1 ? multiGpuEfficiency : 1));
   const memoryBoundAggregate = decodeTokensPerSec * input.batchSize * continuousBatchingMultiplier;
-  const aggregateTokensPerSec = vramFits ? Math.min(memoryBoundAggregate, computeCeiling) : 0;
+  const aggregateTokensPerSec = vramFits ? Math.min(memoryBoundAggregate, computeCeiling) * tp : 0;
   const cachePrefixTokens = input.cachePrefixTokens ?? 0;
   const cacheHitRate = input.cacheHitRate ?? 0;
   const cacheTTL = input.cacheTTL ?? "none";
@@ -20866,7 +20868,8 @@ var CompareGpusSchema = object({
   promptTokens: number2().int().min(1).max(2000000).default(500),
   outputTokens: number2().int().min(1).max(200000).default(200),
   sortBy: _enum(["lowest_cost", "highest_throughput", "best_value"]).default("best_value"),
-  limit: number2().int().min(1).max(30).default(10)
+  limit: number2().int().min(1).max(30).default(10),
+  gpus: array(string2()).optional().describe("Restrict comparison to specific GPU IDs (e.g. ['h100-sxm','h200-sxm']). Use list_gpus first to find IDs.")
 });
 var RecommendTopologySchema = object({
   model: ModelIdSchema,
@@ -20971,7 +20974,25 @@ function handleCompareGpus(input) {
   const quant = QUANT_MAP[input.quantization];
   if (!model || !quant)
     return { error: "Unknown model or quantization", models: Object.keys(MODEL_MAP).slice(0, 10) };
-  const candidates = GPUS.filter((g) => g.vramGb * input.gpuCount >= model.activeParamsB * quant.bytesPerParam);
+  let candidatePool = GPUS;
+  if (input.gpus && input.gpus.length > 0) {
+    const requested = new Set(input.gpus);
+    candidatePool = GPUS.filter((g) => requested.has(g.id));
+    if (candidatePool.length === 0) {
+      return {
+        error: `No GPUs matched gpus=[${input.gpus.join(", ")}]. Call list_gpus to find valid IDs.`,
+        validGpuIds: GPUS.slice(0, 10).map((g) => g.id)
+      };
+    }
+  }
+  const skippedNoPrice = [];
+  const candidates = candidatePool.filter((g) => {
+    const fitsMemory = g.vramGb * input.gpuCount >= model.activeParamsB * quant.bytesPerParam;
+    const hasPrice = g.usdPerHour !== null && g.usdPerHour !== undefined && g.usdPerHour > 0;
+    if (!hasPrice)
+      skippedNoPrice.push(g.id);
+    return fitsMemory && hasPrice;
+  });
   const results = candidates.map((g) => {
     const r = calculate({
       modelId: input.model,
@@ -21004,10 +21025,11 @@ function handleCompareGpus(input) {
     return b.aggregateTokensPerSecond / Math.max(b.costPerMillionTokens, 0.001) - a.aggregateTokensPerSecond / Math.max(a.costPerMillionTokens, 0.001);
   }).slice(0, input.limit);
   return {
-    summary: `Compared ${results.length} GPUs for ${model.name} (${quant.label}). Cheapest: ${sorted[0]?.gpuName} at $${sorted[0]?.costPerMillionTokens}/M tokens.`,
+    summary: `Compared ${results.length} GPUs for ${model.name} (${quant.label}). Cheapest: ${sorted[0]?.gpuName} at $${sorted[0]?.costPerMillionTokens.toLocaleString("en-US")}/M tokens.`,
     comparisons: sorted,
     totalCandidates: results.length,
     sortBy: input.sortBy,
+    skippedNoPrice: skippedNoPrice.length > 0 ? skippedNoPrice : undefined,
     assumptions: [`Region: us-east-1 (default)`, `On-demand pricing`, `η_mem = 0.65`, `Catalog version: 0.3.0`]
   };
 }
@@ -21016,10 +21038,10 @@ function handleRecommendTopology(input) {
   const quant = QUANT_MAP[input.quantization];
   if (!model || !quant)
     return { error: "Unknown model or quantization" };
+  const kvPerRequest = computeKVCacheGb(model, input.contextTokens, input.batchSize);
   const results = GPUS.map((g) => {
     const rec = recommendTopology(model, g, input.contextTokens, input.batchSize, quant.bytesPerParam);
-    const maxConcurrent = computeMaxConcurrency(model, g, 1, input.contextTokens, quant.bytesPerParam);
-    const kvPerRequest = computeKVCacheGb(model, input.contextTokens, 1);
+    const maxConcurrent = computeMaxConcurrency(model, g, input.batchSize, input.contextTokens, quant.bytesPerParam);
     return {
       gpuId: g.id,
       gpuName: g.name,
@@ -21033,12 +21055,12 @@ function handleRecommendTopology(input) {
     };
   }).filter((r) => r.fits).slice(0, 5);
   return {
-    summary: `For ${model.name} at ${fmtContext(input.contextTokens)} context: ${results.length} feasible topology options across ${GPUS.length} GPUs.`,
+    summary: `For ${model.name} at ${fmtContext(input.contextTokens)} context (batch=${input.batchSize}): ${results.length} feasible topology options across ${GPUS.length} GPUs.`,
     model: { name: model.name, paramsB: model.paramsB, activeParamsB: model.activeParamsB, isMoE: model.isMoE },
-    context: { tokens: input.contextTokens, label: fmtContext(input.contextTokens) },
+    context: { tokens: input.contextTokens, label: fmtContext(input.contextTokens), batchSize: input.batchSize },
     recommendations: results,
-    formula: `KV per request = 2 × ${model.layers} layers × ${model.kvHeads} KV heads × ${model.headDim} head_dim × 2 bytes × ${input.contextTokens} tokens = ${computeKVCacheGb(model, input.contextTokens, 1).toFixed(2)} GB`,
-    assumptions: [`Single GPU unless TP needed`, `KV cache in FP16`, `Model weights + KV must fit in total VRAM`, `Catalog version: 0.3.0`]
+    formula: `KV per batch = 2 × ${model.layers} layers × ${model.kvHeads} KV heads × ${model.headDim} head_dim × 2 bytes × ${input.contextTokens} tokens × ${input.batchSize} batch = ${kvPerRequest.toFixed(2)} GB`,
+    assumptions: [`Single GPU unless TP needed`, `KV cache in FP16`, `Model weights + KV × batchSize must fit in total VRAM`, `Catalog version: 0.3.0`]
   };
 }
 function handleEstimateApiVsSelfHost(input) {
@@ -21120,8 +21142,10 @@ function handleListGpus(input) {
     filtered = filtered.filter((g) => g.vendor === input.vendor);
   if (input.category)
     filtered = filtered.filter((g) => g.category === input.category);
-  if (input.minVramGb !== undefined)
-    filtered = filtered.filter((g) => g.vramGb >= input.minVramGb);
+  if (input.minVramGb !== undefined) {
+    const minVram = input.minVramGb;
+    filtered = filtered.filter((g) => g.vramGb >= minVram);
+  }
   return {
     count: filtered.length,
     gpus: filtered.map((g) => ({
@@ -21212,7 +21236,7 @@ var TOOL_DEFINITIONS = [
   }
 ];
 function createMcpServer() {
-  const server = new Server({ name: "tokcalc", version: "0.2.0-alpha.1" }, {
+  const server = new Server({ name: "tokcalc", version: "0.2.0" }, {
     capabilities: {
       tools: {}
     }