teapot-coding-agent 0.19.4 → 0.19.6

package/dist/agent/agent.js

@@ -78,6 +78,8 @@ export class Agent {
         outputTokens: 0,
         compactions: 0,
         startedAt: null,
+        /** running cost estimate in USD (pricing known only) */
+        costUsd: 0,
     };
     opts;
     messages = [];
@@ -105,6 +107,9 @@ export class Agent {
     lastProgressAt = Date.now();
     /** the provider's own prompt_tokens from the last completed turn */
     lastUsage;
+    /** USD per token for the CURRENT model (from provider /models metadata);
+        undefined = pricing unknown → cost estimate stays 0 and hidden */
+    modelPricing;
     /** messages.length right after the last successful compaction */
     compactedAtLen = 0;
     /** live compaction phase for UI progress ("summarizing"/"harvesting") */
@@ -194,6 +199,35 @@ export class Agent {
         this.messages = msgs;
         this.compactedAtLen = 0;
     }
+    /**
+     * Attach USD-per-token pricing for the CURRENT model (provider /models
+     * metadata). Late resolution is normal: the metadata lookup races boot.
+     * Recomputes the session cost from the log so a restart with pricing now
+     * known still shows the full number instead of starting from zero.
+     */
+    async setModelPricing(p) {
+        const wasUndefined = !this.modelPricing;
+        this.modelPricing = p;
+        if (!p || !wasUndefined)
+            return; // already priced, or nothing to price
+        // recompute from the usage events (cheap: file is mtime-cached)
+        try {
+            const events = await readEvents(this.log.filePath);
+            let cost = 0;
+            for (const e of events) {
+                if (e.type !== "usage")
+                    continue;
+                const u = e.data;
+                const inTok = u.inputTokens ?? 0;
+                const cached = Math.min(u.cachedInputTokens ?? 0, inTok);
+                cost += (inTok - cached) * p.prompt + (u.outputTokens ?? 0) * p.completion + cached * p.prompt * 0.1;
+            }
+            this.stats.costUsd = cost;
+        }
+        catch {
+            /* no log yet — live accumulation takes over */
+        }
+    }
     get workspace() {
         return this.opts.workspace;
     }
@@ -420,6 +454,15 @@ export class Agent {
                 this.stats.inputTokens += u.inputTokens ?? 0;
                 this.stats.outputTokens += u.outputTokens ?? 0;
                 this.stats.cachedInputTokens += u.cachedInputTokens ?? 0;
+                if (this.modelPricing) {
+                    const p = this.modelPricing;
+                    const inTok = u.inputTokens ?? 0;
+                    const cached = Math.min(u.cachedInputTokens ?? 0, inTok);
+                    // same blended-cache model as the live path (cached ≈ 10% of prompt)
+                    this.stats.costUsd =
+                        (this.stats.costUsd ?? 0) +
+                            ((inTok - cached) * p.prompt + (u.outputTokens ?? 0) * p.completion + cached * p.prompt * 0.1);
+                }
             }
             else if (e.type === "system_note") {
                 const d = e.data;
@@ -666,7 +709,7 @@ export class Agent {
                 ...(this.goal.audit ? { audit: this.goal.audit } : {}),
             },
             latestProgress: this.latestProgress,
-            stats: { ...this.stats },
+            stats: { ...this.stats, costUsd: this.modelPricing ? this.stats.costUsd : undefined },
             model: this.opts.llm.model,
             provider: this.opts.provider,
             sessionDir: this.opts.sessionDir,
@@ -1029,9 +1072,22 @@ export class Agent {
                 throw err;
             }
             if (res.usage) {
-                this.stats.inputTokens += res.usage.inputTokens ?? 0;
-                this.stats.cachedInputTokens += res.usage.cachedInputTokens ?? 0;
+                const inTok = res.usage.inputTokens ?? 0;
+                const cached = res.usage.cachedInputTokens ?? 0;
+                this.stats.inputTokens += inTok;
+                this.stats.cachedInputTokens += cached;
                 this.stats.outputTokens += res.usage.outputTokens ?? 0;
+                // cost estimate: uncached input at prompt rate, cache hits usually
+                // bill at a fraction (OpenRouter reports the blended prompt price, so
+                // cached tokens are charged separately at ~10% — a common provider
+                // convention; without per-provider detail this is the honest guess)
+                if (this.modelPricing) {
+                    const p = this.modelPricing;
+                    const uncached = Math.max(0, inTok - cached);
+                    this.stats.costUsd =
+                        (this.stats.costUsd ?? 0) +
+                            (uncached * p.prompt + (res.usage.outputTokens ?? 0) * p.completion + cached * p.prompt * 0.1);
+                }
                 this.lastUsage = {
                     input: res.usage.inputTokens ?? 0,
                     output: res.usage.outputTokens ?? 0,

package/dist/master.js

@@ -397,6 +397,11 @@ export class Master {
             ...(ac.parent ? { parent: ac.parent } : {}),
             ...(ac.chatFn ? { chatFn: ac.chatFn } : {}),
         });
+        // pricing metadata (USD/token) for the runtime cost estimate — best
+        // effort: providers without pricing in /models simply show no cost
+        void fetchModelList(llm.baseUrl, llm.apiKey)
+            .then((list) => agent.setModelPricing(list.find((m) => m.id === llm.model)?.pricing))
+            .catch(() => { });
         // console line + broadcast: the web UI only refreshes on bus traffic, so
         // every appended event must reach it (otherwise messages sit invisible
         // until an unrelated status change happens to fire)
@@ -812,6 +817,12 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             if (!agent.compactBudgetIsManual)
                 opts.opts.contextTokenBudget = Math.round(win * 0.75);
         }
+        // re-price for the NEW model (cost estimate follows the model switch)
+        try {
+            const list = await fetchModelList(llm.baseUrl, llm.apiKey);
+            await agent.setModelPricing(list.find((m) => m.id === llm.model)?.pricing);
+        }
+        catch { /* pricing stays stale — cosmetic only */ }
         this.saveConfig();
         void agent.log.append("system_note", agent.currentSession, agent.currentBranch, {
             event: "model-changed",

package/dist/model-meta.js

@@ -30,6 +30,14 @@ export async function fetchModelList(baseUrl, apiKey) {
             .map((m) => ({
             id: typeof m.id === "string" ? m.id : "",
             contextLength: typeof m.context_length === "number" ? m.context_length : undefined,
+            // OpenRouter-style USD per token (e.g. "0.000003") — powers the
+            // runtime cost estimate. Providers without pricing stay undefined.
+            pricing: m.pricing && (m.pricing.prompt !== undefined || m.pricing.completion !== undefined)
+                ? {
+                    prompt: Number(m.pricing.prompt ?? 0),
+                    completion: Number(m.pricing.completion ?? 0),
+                }
+                : undefined,
         }))
             .filter((m) => m.id);
         cache.set(root, { at: Date.now(), list });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.19.4",
+  "version": "0.19.6",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",