opencode-total-session-cost 1.1.1 → 1.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 crazybyte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -24,16 +24,49 @@ Without tracking these sub-sessions, you might see a main session cost of a few
 - **Mouse Click Interaction**: Left-clicking on the cost bar in the prompt header right panel triggers the same detailed breakdown popup.
 
 ## Installation
-Once published, you can install it globally with:
+Install it globally with:
 ```bash
 opencode plugin opencode-total-session-cost -g
 ```
 
+## Cost categories
+The breakdown separates costs into three buckets:
+- **Session**: the cost of the active/root session.
+- **Task**: child sessions spawned through the Task tool by the `explore` and `general` agents.
+- **Sub-agent**: any other child session.
+
+Costs that are not present in the session messages (for example archived or compacted
+messages) are still attributed to the session's configured provider/model, so the totals
+always match the real spending reported by Opencode.
+
+Example `/total_cost` output:
+```
+By session
+Session:   $0.12
+Task:      $0.34
+Sub-agent: $0.08
+---------------
+Total:     $0.54
+
+By provider/model
+anthropic/claude-sonnet-4: $0.40
+openai/gpt-5:              $0.14
+------------------------------
+Total:                     $0.54
+```
+
 ## How it works
 The plugin runs inside Opencode's TUI framework, recursively fetching session data:
 1. It reads the core cost of your active session.
 2. It recursively queries all child sub-sessions spawned by sub-agents.
 3. It displays the combined sum dynamically in the TUI.
 
+## Development
+```bash
+npm install
+npm run typecheck
+npm test
+```
+
 ## License
 MIT

package/cost.ts

@@ -0,0 +1,136 @@
+export type SessionLike = {
+  id: string;
+  cost?: number;
+  agent?: string;
+  model?: {
+    providerID?: string;
+    id?: string;
+  };
+};
+
+export type MessageLike = {
+  role?: string;
+  cost?: number;
+  providerID?: string;
+  modelID?: string;
+};
+
+export type CostDeps = {
+  getSession: (sessionID: string) => SessionLike | undefined;
+  getChildren: (sessionID: string) => Promise<readonly SessionLike[]>;
+  getMessages: (sessionID: string) => readonly MessageLike[];
+};
+
+export type SessionCosts = {
+  parent: number;
+  task: number;
+  subagent: number;
+};
+
+export type CostBreakdown = {
+  sessions: SessionCosts;
+  models: Record<string, number>;
+  total: number;
+};
+
+/**
+ * Agents that OpenCode spawns through the Task tool. Their sessions are
+ * reported under the "Task" category in the breakdown.
+ */
+export const TASK_AGENTS: ReadonlySet<string> = new Set(["explore", "general"]);
+
+const EPSILON = 0.0001;
+
+export async function collectCosts(rootSessionID: string, deps: CostDeps): Promise<CostBreakdown> {
+  const sessions: SessionCosts = { parent: 0, task: 0, subagent: 0 };
+  const models: Record<string, number> = {};
+  const visited = new Set<string>();
+
+  const addModelCost = (providerID: string, modelID: string, cost: number) => {
+    const key = `${providerID}/${modelID}`;
+    models[key] = (models[key] ?? 0) + cost;
+  };
+
+  const walk = async (sessionID: string, fallback?: SessionLike): Promise<void> => {
+    if (visited.has(sessionID)) return;
+    visited.add(sessionID);
+
+    const session = deps.getSession(sessionID) ?? fallback;
+    const sessionCost = session && typeof session.cost === "number" ? session.cost : 0;
+
+    if (sessionID === rootSessionID) {
+      sessions.parent += sessionCost;
+    } else if (session?.agent && TASK_AGENTS.has(session.agent)) {
+      sessions.task += sessionCost;
+    } else {
+      sessions.subagent += sessionCost;
+    }
+
+    let attributedCost = 0;
+    for (const message of deps.getMessages(sessionID)) {
+      if (message.role !== "assistant") continue;
+      const cost = message.cost;
+      if (typeof cost !== "number" || cost <= 0) continue;
+      addModelCost(
+        message.providerID ?? session?.model?.providerID ?? "unknown",
+        message.modelID ?? session?.model?.id ?? "unknown",
+        cost
+      );
+      attributedCost += cost;
+    }
+
+    const remainder = sessionCost - attributedCost;
+    if (remainder > EPSILON) {
+      addModelCost(
+        session?.model?.providerID ?? "unknown",
+        session?.model?.id ?? "unknown",
+        remainder
+      );
+    }
+
+    for (const child of await deps.getChildren(sessionID)) {
+      await walk(child.id, child);
+    }
+  };
+
+  await walk(rootSessionID);
+
+  const total = sessions.parent + sessions.task + sessions.subagent;
+  return { sessions, models, total };
+}
+
+export function formatSessionSection(sessions: SessionCosts): string {
+  const total = sessions.parent + sessions.task + sessions.subagent;
+  return [
+    "By session",
+    `Session:   $${sessions.parent.toFixed(2)}`,
+    `Task:      $${sessions.task.toFixed(2)}`,
+    `Sub-agent: $${sessions.subagent.toFixed(2)}`,
+    "---------------",
+    `Total:     $${total.toFixed(2)}`,
+  ].join("\n");
+}
+
+export function formatModelSection(models: Record<string, number>, total: number): string {
+  const sorted = Object.entries(models).sort((a, b) => b[1] - a[1]);
+
+  let labelWidth = "Total:".length;
+  for (const [key] of sorted) {
+    labelWidth = Math.max(labelWidth, key.length + 1);
+  }
+
+  const lines = sorted.map(
+    ([key, cost]) => `${`${key}:`.padEnd(labelWidth + 1, " ")}$${cost.toFixed(2)}`
+  );
+  const separator = "-".repeat(labelWidth + 7);
+  const totalLine = `${"Total:".padEnd(labelWidth + 1, " ")}$${total.toFixed(2)}`;
+
+  return ["By provider/model", ...lines, separator, totalLine].join("\n");
+}
+
+export function formatBreakdown(breakdown: CostBreakdown): string {
+  return `${formatSessionSection(breakdown.sessions)}\n\n${formatModelSection(
+    breakdown.models,
+    breakdown.total
+  )}`;
+}

package/index.ts

@@ -1,6 +1,6 @@
 import type { Plugin, PluginModule } from "@opencode-ai/plugin";
 
-export const id = "opencode-cost-bar";
+export const id = "opencode-total-session-cost";
 
 export const server: Plugin = async (ctx) => {
   return {}; // No-op backend hooks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-total-session-cost",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Real-time cumulative cost tracker for Opencode sessions, aggregating costs from parent sessions, archived messages, and all child sub-agent tasks.",
   "type": "module",
   "main": "./index.ts",
@@ -8,6 +8,24 @@
     ".": "./index.ts",
     "./tui": "./tui.tsx"
   },
+  "files": [
+    "cost.ts",
+    "index.ts",
+    "tui.tsx",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --test",
+    "prepublishOnly": "npm run typecheck && npm test"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "overrides": {
+    "@babel/core": "^7.29.7"
+  },
   "keywords": [
     "opencode-plugin",
     "opencode",

package/tui.tsx

@@ -1,161 +1,99 @@
-import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui";
+import type {
+  TuiHostSlotMap,
+  TuiPlugin,
+  TuiPluginApi,
+  TuiPluginModule,
+  TuiSlotContext
+} from "@opencode-ai/plugin/tui";
+import type { Message } from "@opencode-ai/sdk/v2";
 import { createSignal, onCleanup } from "solid-js";
+import { collectCosts, formatBreakdown, type CostDeps, type MessageLike } from "./cost.ts";
 
-export const id = "opencode-cost-bar";
+export const id = "opencode-total-session-cost";
 
-export const SessionCostPlugin: TuiPlugin = async (api) => {
-  const showCostBreakdown = async (sessionID: string) => {
-    let parentCost = 0;
-    let taskCost = 0;
-    let subagentCost = 0;
-
-    const modelCosts: Record<string, number> = {};
-
-    const addModelCost = (providerID: string, modelID: string, cost: number) => {
-      const key = `${providerID}/${modelID}`;
-      modelCosts[key] = (modelCosts[key] || 0) + cost;
+const toMessageLike = (message: Message): MessageLike => {
+  if (message.role === "assistant") {
+    return {
+      role: message.role,
+      cost: message.cost,
+      providerID: message.providerID,
+      modelID: message.modelID
     };
+  }
+  return { role: message.role };
+};
 
-    const calculateCostRecursive = async (currID: string, fallbackSession?: any): Promise<void> => {
-      const sessionObj = api.state.session.get(currID) || fallbackSession;
-      let sessionCost = 0;
-      if (sessionObj && typeof sessionObj.cost === "number") {
-        sessionCost = sessionObj.cost;
-        if (currID === sessionID) {
-          parentCost += sessionCost;
-        } else if (sessionObj.agent === "explore" || sessionObj.agent === "general") {
-          taskCost += sessionCost;
-        } else {
-          subagentCost += sessionCost;
-        }
-      }
-
-      let messagesAttributedCost = 0;
-      try {
-        const msgRes = await api.client.session.messages({ sessionID: currID });
-        if (msgRes.data) {
-          for (const item of msgRes.data) {
-            const msg = item.info as any;
-            if (msg && msg.role === "assistant" && typeof msg.cost === "number" && msg.cost > 0) {
-              const provider = msg.providerID || (sessionObj?.model?.providerID) || "unknown";
-              const model = msg.modelID || (sessionObj?.model?.id) || "unknown";
-              addModelCost(provider, model, msg.cost);
-              messagesAttributedCost += msg.cost;
-            }
-          }
-        }
-      } catch (err) {}
-
-      const remainder = sessionCost - messagesAttributedCost;
-      if (remainder > 0.0001) {
-        const provider = (sessionObj?.model?.providerID) || "unknown";
-        const model = (sessionObj?.model?.id) || "unknown";
-        addModelCost(provider, model, remainder);
-      }
-
-      try {
-        const childrenRes = await api.client.session.children({ sessionID: currID });
-        if (childrenRes.data) {
-          for (const child of childrenRes.data) {
-            await calculateCostRecursive(child.id, child);
-          }
-        }
-      } catch (err) {}
-    };
-
-    await calculateCostRecursive(sessionID);
-    const total = parentCost + taskCost + subagentCost;
-
-    // Format Session breakdown
-    const sessionSection = `By session\nSession:   $${parentCost.toFixed(2)}\nTask:      $${taskCost.toFixed(2)}\nSub-agent: $${subagentCost.toFixed(2)}\n---------------\nTotal:     $${total.toFixed(2)}`;
-
-    // Format Model breakdown
-    let maxLabelLength = 6; // Length of "Total:" is 6
-    for (const key of Object.keys(modelCosts)) {
-      const label = `${key}:`;
-      if (label.length > maxLabelLength) {
-        maxLabelLength = label.length;
-      }
-    }
-
-    const sortedModels = Object.entries(modelCosts).sort((a, b) => b[1] - a[1]);
-    const modelLines: string[] = [];
-    for (const [key, cost] of sortedModels) {
-      const label = `${key}:`;
-      const paddedLabel = label.padEnd(maxLabelLength + 1, " ");
-      modelLines.push(`${paddedLabel}$${cost.toFixed(2)}`);
+const createDeps = (api: TuiPluginApi): CostDeps => ({
+  getSession: (sessionID) => api.state.session.get(sessionID),
+  getMessages: (sessionID) => api.state.session.messages(sessionID).map(toMessageLike),
+  getChildren: async (sessionID) => {
+    try {
+      const res = await api.client.session.children({ sessionID });
+      return res.data ?? [];
+    } catch (error) {
+      console.error(`[${id}] failed to load children of session ${sessionID}`, error);
+      return [];
     }
+  }
+});
 
-    const modelSeparator = "-".repeat(maxLabelLength + 7);
-    const paddedTotalLabel = "Total:".padEnd(maxLabelLength + 1, " ");
-    const modelTotalLine = `${paddedTotalLabel}$${total.toFixed(2)}`;
-
-    const modelSection = `By provider/model\n${modelLines.join("\n")}\n${modelSeparator}\n${modelTotalLine}`;
+export const SessionCostPlugin: TuiPlugin = async (api) => {
+  const showCostBreakdown = async (sessionID: string) => {
+    const breakdown = await collectCosts(sessionID, createDeps(api));
 
     api.ui.toast({
       title: "Session Costs Breakdown",
-      message: `${sessionSection}\n\n${modelSection}`,
+      message: formatBreakdown(breakdown),
       variant: "success",
       duration: 10000
     });
   };
 
-  // Register TUI slots with reactive signals defined inside the renderers
   api.slots?.register({
     slots: {
-      // session_prompt_right: Persistent cost tracker in the prompt header right panel next to active model info
-      session_prompt_right: (ctx: any, props: any) => {
+      session_prompt_right: (
+        ctx: Readonly<TuiSlotContext>,
+        props: TuiHostSlotMap["session_prompt_right"]
+      ) => {
         const [total, setTotal] = createSignal<number>(0);
-
-        const calculateCost = async (sessionID: string): Promise<number> => {
-          let totalCost = 0;
-
-          const sessionObj = api.state.session.get(sessionID);
-          if (sessionObj && typeof sessionObj.cost === "number") {
-            totalCost += sessionObj.cost;
-          }
-
-          try {
-            const childrenRes = await api.client.session.children({ sessionID });
-            if (childrenRes.data) {
-              for (const child of childrenRes.data) {
-                totalCost += await calculateCost(child.id);
-              }
-            }
-          } catch (err) {}
-
-          return totalCost;
-        };
+        let requestId = 0;
 
         const update = async () => {
-          const sessionID = props?.session_id;
-          if (sessionID) {
-            const res = await calculateCost(sessionID);
-            setTotal(res);
-          } else {
+          const currentRequest = ++requestId;
+          const sessionID = props.session_id;
+          if (!sessionID) {
             setTotal(0);
+            return;
           }
+
+          const breakdown = await collectCosts(sessionID, createDeps(api));
+          if (currentRequest !== requestId) return;
+
+          setTotal(breakdown.total);
         };
 
-        const unsubMsgUpdated = api.event.on("message.updated", update);
-        const unsubMsgRemoved = api.event.on("message.removed", update);
-        const interval = setInterval(update, 3000);
+        const unsubMsgUpdated = api.event.on("message.updated", () => void update());
+        const unsubMsgRemoved = api.event.on("message.removed", () => void update());
+        const unsubSessionUpdated = api.event.on("session.updated", () => void update());
+        const unsubSessionIdle = api.event.on("session.idle", () => void update());
+        const interval = setInterval(() => void update(), 3000);
 
         onCleanup(() => {
           unsubMsgUpdated();
           unsubMsgRemoved();
+          unsubSessionUpdated();
+          unsubSessionIdle();
           clearInterval(interval);
         });
 
-        // Trigger update immediately
-        update();
+        void update();
 
         return (
           <text
-            fg="gray"
-            onMouseUp={(e: any) => {
-              if (props?.session_id && e.button === 0) {
-                showCostBreakdown(props.session_id);
+            fg={ctx.theme.current.textMuted}
+            onMouseUp={(event) => {
+              if (event.button === 0) {
+                void showCostBreakdown(props.session_id);
               }
             }}
           >
@@ -166,7 +104,6 @@ export const SessionCostPlugin: TuiPlugin = async (api) => {
     }
   });
 
-  // Register slash command /total_cost (and alias /costs)
   api.command?.register(() => [
     {
       title: "Total Session Cost",
@@ -178,9 +115,12 @@ export const SessionCostPlugin: TuiPlugin = async (api) => {
         aliases: ["costs"]
       },
       onSelect: async () => {
-        const currentSessionID = api.route.current && api.route.current.name === "session" && typeof api.route.current.params?.sessionID === "string"
-          ? api.route.current.params.sessionID
-          : null;
+        const currentSessionID =
+          api.route.current &&
+          api.route.current.name === "session" &&
+          typeof api.route.current.params?.sessionID === "string"
+            ? api.route.current.params.sessionID
+            : null;
 
         if (!currentSessionID) {
           api.ui.toast({
@@ -198,13 +138,11 @@ export const SessionCostPlugin: TuiPlugin = async (api) => {
   ]);
 };
 
-// Export named constant for loaders looking for `export const tui = ...`
 export const tui = SessionCostPlugin;
 
-// Export default module configuration
 const pluginModule: TuiPluginModule = {
   id,
   tui: SessionCostPlugin
 };
 
-export default pluginModule;
+export default pluginModule;

package/.github/workflows/ci.yml

@@ -1,27 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  typecheck:
-    name: TypeScript Typecheck
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: Install Dependencies
-        run: bun install --frozen-lockfile
-
-      - name: Run Typecheck
-        run: bun x tsc --noEmit

package/.github/workflows/publish.yml

@@ -1,30 +0,0 @@
-name: Publish to NPM
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch:
-
-jobs:
-  publish:
-    name: Publish Package
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v6
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          registry-url: 'https://registry.npmjs.org'
-          package-manager-cache: false
-
-      - name: Install Dependencies
-        run: npm ci
-
-      - name: Publish Package
-        run: npm publish --access public

package/opencode.jsonc

@@ -1,6 +0,0 @@
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    "./tui.tsx"
-  ]
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "jsx": "preserve",
-    "jsxImportSource": "@opentui/solid",
-    "strict": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["./index.ts", "./tui.tsx"]
-}