opencode-token-tracker 1.5.6 → 1.5.7

package/dist/bin/opencode-tokens.js

@@ -325,17 +325,29 @@ function cmdModels() {
     console.log(`  ${padRight("Model", modelWidth)}  ${padRight("Provider", providerWidth)}  ${padLeft("Msgs", countWidth)}  ${padRight("Pricing", statusWidth)}`);
     console.log(`  ${"-".repeat(modelWidth)}  ${"-".repeat(providerWidth)}  ${"-".repeat(countWidth)}  ${"-".repeat(statusWidth)}`);
     for (const { model, provider, count } of sorted) {
-        let status = "built-in";
+        let status;
+        // Mirror the runtime pricing resolution order (getModelPricing in index.ts)
         if (config.providers?.[provider]) {
             status = "provider cfg";
         }
-        else if (findModelConfigPricing(config.models, model, provider)) {
+        else if (findModelConfigPricing(config.models, model, provider, false)) {
             status = "model cfg";
         }
-        else if (!BUILTIN_PRICING[model]) {
-            // Check partial match
-            const hasMatch = Object.keys(BUILTIN_PRICING).some(k => k !== "_default" && model.toLowerCase().includes(k.toLowerCase()));
-            status = hasMatch ? "built-in" : "default";
+        else if (BUILTIN_PRICING[model]) {
+            status = "built-in";
+        }
+        else {
+            const modelLower = model.toLowerCase();
+            const hasBuiltinPartial = Object.keys(BUILTIN_PRICING).some(k => k !== "_default" && modelLower.includes(k.toLowerCase()));
+            if (hasBuiltinPartial) {
+                status = "built-in";
+            }
+            else if (findModelConfigPricing(config.models, model, provider, true)) {
+                status = "model cfg";
+            }
+            else {
+                status = "default";
+            }
         }
         console.log(`  ${padRight(model, modelWidth)}  ${padRight(provider, providerWidth)}  ${padLeft(count.toString(), countWidth)}  ${padRight(status, statusWidth)}`);
     }

package/dist/index.js

@@ -58,8 +58,8 @@ function getModelPricing(model, provider) {
     if (config.providers[provider]) {
         return config.providers[provider];
     }
-    // 2. Check user-defined model pricing
-    const configuredPricing = findModelConfigPricing(config.models, model, provider);
+    // 2. Check user-defined model pricing (exact match only)
+    const configuredPricing = findModelConfigPricing(config.models, model, provider, false);
     if (configuredPricing) {
         return configuredPricing;
     }
@@ -69,12 +69,17 @@ function getModelPricing(model, provider) {
     }
     // 4. Try partial match in built-in pricing
     const modelLower = model.toLowerCase();
-    for (const [key, pricing] of Object.entries(BUILTIN_PRICING)) {
+    for (const [key, pricing] of Object.entries(BUILTIN_PRICING).sort(([a], [b]) => b.length - a.length)) {
         if (key !== "_default" && modelLower.includes(key.toLowerCase())) {
             return pricing;
         }
     }
-    // 5. Fallback to default
+    // 5. Try partial match in user config
+    const partialUserPricing = findModelConfigPricing(config.models, model, provider, true);
+    if (partialUserPricing) {
+        return partialUserPricing;
+    }
+    // 6. Fallback to default
     return BUILTIN_PRICING["_default"];
 }
 export function getProviderFamily(model, provider) {

package/dist/lib/shared.d.ts

@@ -45,4 +45,4 @@ export interface ConfigValidationResult {
  * Invalid fields are silently corrected to defaults with warnings.
  */
 export declare function validateConfig(raw: unknown): ConfigValidationResult;
-export declare function findModelConfigPricing(models: TrackerConfig["models"], model: string, provider: string): ModelPricing | undefined;
+export declare function findModelConfigPricing(models: TrackerConfig["models"], model: string, provider: string, partial?: boolean): ModelPricing | undefined;

package/dist/lib/shared.js

@@ -174,6 +174,12 @@ function validatePricingMap(raw, section, warnings, allowProviderModels = false)
             warnings.push(`${entryPath} should be a pricing object, ignoring`);
             continue;
         }
+        // If the structure looks like flat pricing (has pricing field keys),
+        // don't fall through to nested provider pricing — validatePricingObject
+        // already issued the relevant warning for malformed flat pricing.
+        if (hasFlatPricingStructure(value)) {
+            continue;
+        }
         const providerPricing = validateNestedPricingMap(value, entryPath, warnings);
         if (Object.keys(providerPricing).length > 0) {
             result[key] = providerPricing;
@@ -246,11 +252,7 @@ function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isDirectModelPricing(value) {
-    return hasFlatPricingStructure(value)
-        && isFiniteNumber(value.input)
-        && isFiniteNumber(value.output)
-        && (value.cacheRead === undefined || isFiniteNumber(value.cacheRead))
-        && (value.cacheWrite === undefined || isFiniteNumber(value.cacheWrite));
+    return hasFlatPricingStructure(value);
 }
 function resolveModelConfigEntry(entry, provider) {
     if (!entry)
@@ -259,13 +261,17 @@ function resolveModelConfigEntry(entry, provider) {
         return entry;
     return entry[provider];
 }
-export function findModelConfigPricing(models, model, provider) {
+export function findModelConfigPricing(models, model, provider, partial = true) {
     const exactMatch = resolveModelConfigEntry(models[model], provider);
     if (exactMatch) {
         return exactMatch;
     }
+    if (!partial)
+        return undefined;
     const modelLower = model.toLowerCase();
-    for (const [key, entry] of Object.entries(models)) {
+    // Sort by key length descending so longer (more specific) keys are checked first
+    const sorted = Object.entries(models).sort(([a], [b]) => b.length - a.length);
+    for (const [key, entry] of sorted) {
         if (modelLower.includes(key.toLowerCase())) {
             const partialMatch = resolveModelConfigEntry(entry, provider);
             if (partialMatch) {

package/dist/test/shared.test.js

@@ -237,6 +237,16 @@ describe("validateConfig", () => {
         assert.equal(result.config.models["not-object"], undefined);
         assert.ok(result.warnings.length >= 4);
     });
+    it("should produce one clear warning for malformed flat pricing (not nested fallthrough noise)", () => {
+        const result = validateConfig({
+            models: {
+                "my-model": { input: "free", output: 2 },
+            },
+        });
+        assert.equal(result.config.models["my-model"], undefined);
+        assert.equal(result.warnings.length, 1);
+        assert.ok(result.warnings[0].includes("input should be a non-negative number"));
+    });
     it("should warn and ignore invalid cacheRead/cacheWrite but keep entry", () => {
         const result = validateConfig({
             models: {
@@ -376,6 +386,40 @@ describe("findModelConfigPricing", () => {
         });
         assert.deepEqual(findModelConfigPricing(result.config.models, "prefix/my-model", "any-provider"), { input: 1, output: 2 });
     });
+    it("should prefer longer key over shorter key in partial matches (longest-first)", () => {
+        const result = validateConfig({
+            models: {
+                "gpt-4.1": { input: 3, output: 12 },
+                "gpt-4.1-mini": { input: 0.8, output: 3.2 },
+            },
+        });
+        assert.deepEqual(findModelConfigPricing(result.config.models, "gpt-4.1-mini-2025", "openai"), { input: 0.8, output: 3.2 });
+    });
+    it("should prefer longer key regardless of insertion order (longest-first)", () => {
+        const result = validateConfig({
+            models: {
+                "gpt-4.1-mini": { input: 0.8, output: 3.2 },
+                "gpt-4.1": { input: 3, output: 12 },
+            },
+        });
+        assert.deepEqual(findModelConfigPricing(result.config.models, "gpt-4.1-mini-2025", "openai"), { input: 0.8, output: 3.2 });
+    });
+    it("should not match partial keys when partial=false (exact-only mode)", () => {
+        const result = validateConfig({
+            models: {
+                "claude": { input: 0, output: 0 },
+            },
+        });
+        assert.equal(findModelConfigPricing(result.config.models, "claude-opus-4.6", "anthropic", false), undefined);
+    });
+    it("should match partial keys when partial=true (backward compatible)", () => {
+        const result = validateConfig({
+            models: {
+                "claude": { input: 0, output: 0 },
+            },
+        });
+        assert.deepEqual(findModelConfigPricing(result.config.models, "claude-opus-4.6", "anthropic", true), { input: 0, output: 0 });
+    });
 });
 // ============================================================================
 // getProviderFamily
@@ -455,3 +499,38 @@ describe("calculateCost", () => {
         assert.ok(Math.abs(costFallback - 4.91) < 0.0001, `expected 4.91, got ${costFallback}`);
     });
 });
+// ============================================================================
+// calculateCost partial match — longest-key-first regression
+// ============================================================================
+describe("calculateCost partial match (longest-key-first)", () => {
+    it("should match gpt-4o-mini over gpt-4o for variant model name", () => {
+        // gpt-4o-mini-2024-07-18 should match gpt-4o-mini ($0.15/$0.6), not gpt-4o ($2.5/$10)
+        const cost = calculateCost("gpt-4o-mini-2024-07-18", "openai", 1_000_000, 1_000_000);
+        // Expected: input 0.15 + output 0.6 = 0.75 (no cache in this test)
+        assert.ok(Math.abs(cost - 0.75) < 0.001, `expected 0.75, got ${cost}`);
+    });
+    it("should match o3-mini over o3 for variant model name", () => {
+        // o3-mini-high should match o3-mini ($1.1/$4.4), not o3 ($10/$40)
+        const cost = calculateCost("o3-mini-high", "openai", 1_000_000, 1_000_000);
+        // Expected: input 1.1 + output 4.4 = 5.5
+        assert.ok(Math.abs(cost - 5.5) < 0.001, `expected 5.5, got ${cost}`);
+    });
+    it("should match gemini-2.5-flash-lite over gemini-2.5-flash for variant model name", () => {
+        // gemini-2.5-flash-lite-preview should match gemini-2.5-flash-lite ($0.1/$0.4), not gemini-2.5-flash ($0.3/$2.5)
+        const cost = calculateCost("gemini-2.5-flash-lite-preview", "google", 1_000_000, 1_000_000);
+        // Expected: input 0.1 + output 0.4 = 0.5
+        assert.ok(Math.abs(cost - 0.5) < 0.001, `expected 0.5, got ${cost}`);
+    });
+    it("should match gpt-5.2-pro over gpt-5.2 for variant model name", () => {
+        // gpt-5.2-pro-2025 should match gpt-5.2-pro ($21/$168), not gpt-5.2 ($1.75/$14)
+        const cost = calculateCost("gpt-5.2-pro-2025", "openai", 1_000_000, 1_000_000);
+        // Expected: input 21 + output 168 = 189
+        assert.ok(Math.abs(cost - 189) < 0.01, `expected 189, got ${cost}`);
+    });
+    it("should match o1-mini over o1 for variant model name", () => {
+        // o1-mini-high should match o1-mini ($1.1/$4.4), not o1 ($15/$60)
+        const cost = calculateCost("o1-mini-high", "openai", 1_000_000, 1_000_000);
+        // Expected: input 1.1 + output 4.4 = 5.5
+        assert.ok(Math.abs(cost - 5.5) < 0.001, `expected 5.5, got ${cost}`);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-token-tracker",
-  "version": "1.5.6",
+  "version": "1.5.7",
   "description": "Real-time token usage and cost tracking plugin for OpenCode with Toast notifications and CLI stats",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,6 +8,11 @@
   "bin": {
     "opencode-tokens": "dist/bin/opencode-tokens.js"
   },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && node --test dist/test/shared.test.js",
+    "prepublishOnly": "npm run build"
+  },
   "keywords": [
     "opencode",
     "plugin",
@@ -46,9 +51,5 @@
   ],
   "engines": {
     "node": ">=18.0.0"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "tsc && node --test dist/test/shared.test.js"
   }
-}
+}