@lijinzhao8/opencode-usage 1.0.0

package/README.md

@@ -0,0 +1,120 @@
+# opencode-usage
+
+OpenCode 插件：实时显示 API 用量和费用统计，完全复制 API-Proxy 的定价逻辑（中转组、按模型费率、时间段倍率）。
+
+## 功能
+
+- 实时显示 token 用量（输入/输出/缓存）
+- 按模型计算费用（复制 API-Proxy 的 `calculateAllowanceDebitUnits` 逻辑）
+- 支持中转共享组（Relay Groups）概念
+- 支持时间段倍率（Beijing time）
+- 显示每条消息的增量费用
+- 显示会话累计总量
+
+## 安装
+
+```bash
+opencode plugin @lijinzhao8/opencode-usage@latest
+```
+
+## 配置
+
+在 `.opencode/opencode.json` 的 `plugin` 数组中添加：
+
+```json
+{
+  "plugin": [
+    "@lijinzhao8/opencode-usage@latest"
+  ]
+}
+```
+
+### 定价配置
+
+编辑 `src/pricing.ts` 中的 `DEFAULT_GROUPS` 和 `DEFAULT_PROVIDERS`，或者在插件初始化时传入 options：
+
+```typescript
+// 在 opencode.json 中无法直接传 options，
+// 请直接修改 src/pricing.ts 中的默认配置
+```
+
+### 中转组（Relay Groups）
+
+```typescript
+DEFAULT_GROUPS = [
+  {
+    id: "grp_api_proxy",
+    name: "API-Proxy",
+    enabled: true,
+    provider_ids: ["api-proxy"],  // 属于此组的 provider ID
+    initial_balance: 0,
+    rates_text: `
+      * input=0.15 output=0.60 cache_hit=0.03 cache_create=0.15
+      gpt-5.5 input=2.50 output=10.00
+      claude-opus-4-8 input=15.00 output=75.00
+    `,
+  },
+];
+```
+
+### 费率格式（rates_text）
+
+每行一个模型规则，格式：`model_name key=value ...`
+
+| Key | 说明 | 单位 |
+|-----|------|------|
+| `input` | 输入 token 费率 | 美元/百万 token |
+| `output` | 输出 token 费率 | 美元/百万 token |
+| `cache_hit` | 缓存命中费率 | 美元/百万 token |
+| `cache_create` | 缓存创建费率 | 美元/百万 token |
+| `calls` | 按次计费次数 | 次 |
+| `call_value` | 每次费用 | 美元 |
+| `multiplier` | 全局倍率 | 倍数 |
+| `time_mult` | 时间段倍率 | 格式：`HH:MM-HH:MM=倍率;...` |
+
+`*` 匹配所有未明确列出的模型。
+
+### 时间段倍率
+
+```bash
+# 北京时间 22:00-02:00 加价 50%
+time_mult=22:00-02:00=1.5
+
+# 多个时段
+time_mult=22:00-02:00=1.5;08:00-20:00=1.0
+```
+
+## 费用计算公式
+
+完全复制 API-Proxy 的 `calculateAllowanceDebitUnits`：
+
+```
+normalInput = max(0, input - cacheHit - cacheCreate)
+cost = (normalInput / 1M × rate.input
+      + output / 1M × rate.output
+      + cacheHit / 1M × rate.cache_hit
+      + cacheCreate / 1M × rate.cache_create)
+      × multiplier × timeMultiplier
+```
+
+## 显示位置
+
+- **侧边栏底部**（session 视图）
+- **首页底部**（home 视图）
+
+## 开发
+
+```bash
+# 安装依赖
+npm install
+
+# 构建
+bun run build
+
+# 类型检查
+bun run typecheck
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * opencode-usage — Server Plugin
+ *
+ * Captures token usage from each AI response and calculates costs
+ * using the same logic as API-Proxy (relay groups, per-model rates,
+ * time multipliers). Persists data via the plugin kv store.
+ */
+import type { UsagePluginOptions } from "./types";
+export default function opencodeUsagePlugin(ctx: any, options?: UsagePluginOptions): Promise<{
+    event: ({ event }: {
+        event: any;
+    }) => Promise<void>;
+    "chat.message": (input: any, output: any) => Promise<void>;
+}>;

package/dist/index.js

@@ -0,0 +1,283 @@
+// src/pricing.ts
+var DEFAULT_GROUP_RATES = `* input=0.15 output=0.60 cache_hit=0.03 cache_create=0.15`;
+var DEFAULT_GROUPS = [
+  {
+    id: "grp_api_proxy",
+    name: "API-Proxy",
+    enabled: true,
+    provider_ids: ["api-proxy"],
+    initial_balance: 0,
+    rates_text: DEFAULT_GROUP_RATES
+  },
+  {
+    id: "grp_xiaomi",
+    name: "Xiaomi Token Plan",
+    enabled: true,
+    provider_ids: ["xiaomi-token-plan"],
+    initial_balance: 0,
+    rates_text: DEFAULT_GROUP_RATES
+  }
+];
+var DEFAULT_PROVIDERS = [
+  {
+    id: "api-proxy",
+    name: "API-Proxy",
+    enabled: true,
+    group_id: "grp_api_proxy",
+    model_rates: {}
+  },
+  {
+    id: "xiaomi-token-plan",
+    name: "Xiaomi Token Plan",
+    enabled: true,
+    group_id: "grp_xiaomi",
+    model_rates: {}
+  },
+  {
+    id: "penguin-lm-gpt",
+    name: "Penguin LM GPT",
+    enabled: true,
+    group_id: "",
+    model_rates: {}
+  }
+];
+var ALLOWANCE_SCALE = 1e6;
+function parseRateLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#"))
+    return null;
+  const parts = trimmed.split(/\s+/);
+  if (parts.length < 2)
+    return null;
+  const model = parts[0];
+  const rate = {
+    input: 0,
+    output: 0,
+    cache_hit: 0,
+    cache_create: 0,
+    calls: 0,
+    call_value: 0,
+    multiplier: 1,
+    time_mult: ""
+  };
+  for (let i = 1;i < parts.length; i++) {
+    const eqIndex = parts[i].indexOf("=");
+    if (eqIndex === -1)
+      continue;
+    const key = parts[i].substring(0, eqIndex);
+    const value = parseFloat(parts[i].substring(eqIndex + 1));
+    if (key in rate) {
+      rate[key] = isNaN(value) ? 0 : value;
+    }
+  }
+  return { model, rate };
+}
+function parseRates(ratesText) {
+  const rates = {};
+  for (const line of ratesText.split(`
+`)) {
+    const parsed = parseRateLine(line);
+    if (parsed) {
+      rates[parsed.model] = parsed.rate;
+    }
+  }
+  return rates;
+}
+function findRate(rates, model) {
+  return rates[model] || rates["*"] || null;
+}
+function computeTimeMultiplier(timeMultStr) {
+  if (!timeMultStr)
+    return 1;
+  const now = new Date;
+  const bjHour = (now.getUTCHours() + 8) % 24;
+  const bjMinute = now.getUTCMinutes();
+  const currentMinutes = bjHour * 60 + bjMinute;
+  const segments = timeMultStr.split(";");
+  for (const seg of segments) {
+    const match = seg.trim().match(/^(\d{2}):(\d{2})-(\d{2}):(\d{2})=(.+)$/);
+    if (!match)
+      continue;
+    const startH = parseInt(match[1], 10);
+    const startM = parseInt(match[2], 10);
+    const endH = parseInt(match[3], 10);
+    const endM = parseInt(match[4], 10);
+    const mult = parseFloat(match[5]);
+    if (isNaN(mult))
+      continue;
+    const startMin = startH * 60 + startM;
+    const endMin = endH * 60 + endM;
+    if (startMin <= endMin) {
+      if (currentMinutes >= startMin && currentMinutes <= endMin) {
+        return mult;
+      }
+    } else {
+      if (currentMinutes >= startMin || currentMinutes <= endMin) {
+        return mult;
+      }
+    }
+  }
+  return 1;
+}
+function calculateCost(usage, rate) {
+  if (!rate)
+    return 0;
+  const multiplier = (rate.multiplier || 1) * computeTimeMultiplier(rate.time_mult || "");
+  if (rate.calls > 0 && rate.call_value > 0) {
+    return Math.ceil(rate.calls) * rate.call_value * multiplier;
+  }
+  const normalInput = Math.max(0, usage.input - usage.cache_hit - usage.cache_create);
+  const cost = normalInput / ALLOWANCE_SCALE * rate.input + usage.output / ALLOWANCE_SCALE * rate.output + usage.cache_hit / ALLOWANCE_SCALE * rate.cache_hit + usage.cache_create / ALLOWANCE_SCALE * rate.cache_create;
+  return cost * multiplier;
+}
+function calculateModelCost(usage, providerId, modelId, groups, providers) {
+  const provider = providers.find((p) => p.id === providerId);
+  if (!provider || !provider.enabled)
+    return 0;
+  const providerRate = provider.model_rates?.[modelId];
+  if (providerRate) {
+    const baseRate = {
+      input: 0,
+      output: 0,
+      cache_hit: 0,
+      cache_create: 0,
+      calls: 0,
+      call_value: 0,
+      multiplier: 1,
+      time_mult: "",
+      ...providerRate
+    };
+    return calculateCost(usage, baseRate);
+  }
+  if (provider.group_id) {
+    const group = groups.find((g) => g.id === provider.group_id && g.enabled);
+    if (group) {
+      const groupRates = parseRates(group.rates_text);
+      const rate = findRate(groupRates, modelId);
+      if (rate)
+        return calculateCost(usage, rate);
+    }
+  }
+  return 0;
+}
+
+// src/index.ts
+var KV_PREFIX = "ou_";
+var KV_SESSION_PREFIX = `${KV_PREFIX}session_`;
+var KV_OPTIONS_KEY = `${KV_PREFIX}options`;
+function genId() {
+  return `ou_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function parseUsageFromEvent(event) {
+  const props = event.properties || event;
+  const info = props.info || props;
+  const usage = info.usage || info.token_usage || info;
+  if (!usage)
+    return null;
+  const input = usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens ?? usage.input_token_count ?? 0;
+  const output = usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens ?? usage.candidates_token_count ?? 0;
+  const cache_hit = usage.cache_tokens ?? usage.cached_tokens ?? usage.cached_content_token_count ?? usage.prompt_tokens_details?.cached_tokens ?? 0;
+  const cache_create = usage.cache_create_tokens ?? usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens ?? 0;
+  if (input === 0 && output === 0)
+    return null;
+  return { input, output, cache_hit, cache_create };
+}
+async function opencodeUsagePlugin(ctx, options) {
+  const groups = options?.groups ?? DEFAULT_GROUPS;
+  const providers = options?.providers ?? DEFAULT_PROVIDERS;
+  let currentSessionId = null;
+  let sessionUsage = {
+    total_input: 0,
+    total_output: 0,
+    total_cache_hit: 0,
+    total_cache_create: 0,
+    total_cost: 0,
+    records: []
+  };
+  function saveSessionUsage(kv) {
+    if (!currentSessionId)
+      return;
+    try {
+      const key = `${KV_SESSION_PREFIX}${currentSessionId}`;
+      kv.set(key, JSON.stringify(sessionUsage));
+    } catch {}
+  }
+  function loadSessionUsage(kv, sessionId) {
+    try {
+      const key = `${KV_SESSION_PREFIX}${sessionId}`;
+      const raw = kv.get(key);
+      if (raw)
+        return JSON.parse(raw);
+    } catch {}
+    return {
+      total_input: 0,
+      total_output: 0,
+      total_cache_hit: 0,
+      total_cache_create: 0,
+      total_cost: 0,
+      records: []
+    };
+  }
+  return {
+    event: async ({ event }) => {
+      const type = event.type;
+      const props = event.properties || {};
+      const info = props.info || props;
+      if (type === "session.created" || type === "session.updated") {
+        const sid = info.id || info.sessionID || info.sessionId;
+        if (sid && sid !== currentSessionId) {
+          currentSessionId = sid;
+        }
+      }
+      if (type === "message.updated" || type === "message.completed" || type === "message.finished") {
+        const usage = parseUsageFromEvent(event);
+        if (!usage)
+          return;
+        const providerId = info.providerID || info.providerId || info.provider || "";
+        const modelId = info.modelID || info.modelId || info.model || "";
+        if (!modelId)
+          return;
+        const cost = calculateModelCost(usage, providerId, modelId, groups, providers);
+        const record = {
+          id: genId(),
+          provider_id: providerId,
+          model_id: modelId,
+          input_tokens: usage.input,
+          output_tokens: usage.output,
+          cache_tokens: usage.cache_hit,
+          cache_create_tokens: usage.cache_create,
+          cost,
+          timestamp: Date.now()
+        };
+        sessionUsage.total_input += usage.input;
+        sessionUsage.total_output += usage.output;
+        sessionUsage.total_cache_hit += usage.cache_hit;
+        sessionUsage.total_cache_create += usage.cache_create;
+        sessionUsage.total_cost += cost;
+        sessionUsage.records.push(record);
+        if (sessionUsage.records.length > 200) {
+          sessionUsage.records = sessionUsage.records.slice(-200);
+        }
+        if (typeof globalThis !== "undefined") {
+          globalThis.__opencode_usage_state = {
+            groups,
+            providers,
+            session: sessionUsage,
+            lastRecord: record
+          };
+        }
+      }
+    },
+    "chat.message": async (input, output) => {
+      if (input?.model?.providerID) {
+        if (typeof globalThis !== "undefined") {
+          globalThis.__opencode_usage_last_provider = input.model.providerID;
+          globalThis.__opencode_usage_last_model = input.model.modelID;
+        }
+      }
+    }
+  };
+}
+export {
+  opencodeUsagePlugin as default
+};

package/dist/pricing.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pricing configuration for opencode-usage plugin.
+ *
+ * Mirrors the API-Proxy's rates_text format:
+ *   model_name input=0.15 output=0.60 cache_hit=0.03 cache_create=0.15
+ *
+ * Each line is: <model_pattern> <key>=<value> ...
+ *
+ * Supported keys:
+ *   input       - cost per million input tokens (after cache subtracted)
+ *   output      - cost per million output tokens
+ *   cache_hit   - cost per million cache hit tokens
+ *   cache_create - cost per million cache creation tokens
+ *   calls       - cost per call (overrides per-token billing)
+ *   call_value  - dollar value per call
+ *   multiplier  - global cost multiplier (default: 1)
+ *   time_mult   - time-based multipliers (Beijing time)
+ *                 format: "HH:MM-HH:MM=mult;HH:MM-HH:MM=mult"
+ *                 supports crossing midnight (e.g. 22:00-02:00)
+ *
+ * The "*" model pattern matches any model not explicitly listed.
+ */
+import type { RelayGroup, ProviderConfig, RateConfig, TokenUsage } from "./types";
+/** Default per-token rate for relay groups */
+export declare const DEFAULT_GROUP_RATES = "* input=0.15 output=0.60 cache_hit=0.03 cache_create=0.15";
+/** Default per-token rate for standalone providers */
+export declare const DEFAULT_PROVIDER_RATES = "* input=1.00 output=4.00 cache_hit=0.15 cache_create=1.00";
+export declare const DEFAULT_GROUPS: RelayGroup[];
+export declare const DEFAULT_PROVIDERS: ProviderConfig[];
+/**
+ * Parse a single rate line into a RateConfig object.
+ * Format: "model_name key=value key=value ..."
+ */
+export declare function parseRateLine(line: string): {
+    model: string;
+    rate: Partial<RateConfig>;
+} | null;
+/**
+ * Parse multiple rate lines into a map of model → RateConfig.
+ */
+export declare function parseRates(ratesText: string): Record<string, RateConfig>;
+/**
+ * Find the rate for a specific model.
+ * Priority: exact match → wildcard "*" → null
+ */
+export declare function findRate(rates: Record<string, RateConfig>, model: string): RateConfig | null;
+/**
+ * Compute the time-based multiplier for the current moment (Beijing time).
+ * Supports ranges that cross midnight, e.g. "22:00-02:00=1.5"
+ */
+export declare function computeTimeMultiplier(timeMultStr: string): number;
+/**
+ * Calculate the cost of a request in dollars.
+ *
+ * Formula:
+ *   normalInput = max(0, input - cacheHit - cacheCreate)
+ *   cost = (normalInput / 1M * rate.input
+ *         + output / 1M * rate.output
+ *         + cacheHit / 1M * rate.cache_hit
+ *         + cacheCreate / 1M * rate.cache_create)
+ *         * multiplier * timeMultiplier
+ *
+ * For per-call billing:
+ *   cost = calls * call_value
+ */
+export declare function calculateCost(usage: TokenUsage, rate: RateConfig): number;
+/**
+ * Calculate cost for a specific provider + model combination.
+ * Looks up rates from the group's rates_text, then applies provider model_rates overrides.
+ */
+export declare function calculateModelCost(usage: TokenUsage, providerId: string, modelId: string, groups: RelayGroup[], providers: ProviderConfig[]): number;

package/dist/tui.d.ts

@@ -0,0 +1,12 @@
+/**
+ * opencode-usage — TUI Plugin
+ *
+ * Displays real-time API usage and cost information in the OpenCode TUI.
+ * Shows per-message cost and session totals in the sidebar footer.
+ */
+import type { UsagePluginOptions } from "./types";
+declare const _default: {
+    id: string;
+    tui: (api: any, options?: UsagePluginOptions, meta?: any) => Promise<void>;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,163 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/pricing.ts
+var DEFAULT_GROUP_RATES = `* input=0.15 output=0.60 cache_hit=0.03 cache_create=0.15`;
+var DEFAULT_GROUPS = [
+  {
+    id: "grp_api_proxy",
+    name: "API-Proxy",
+    enabled: true,
+    provider_ids: ["api-proxy"],
+    initial_balance: 0,
+    rates_text: DEFAULT_GROUP_RATES
+  },
+  {
+    id: "grp_xiaomi",
+    name: "Xiaomi Token Plan",
+    enabled: true,
+    provider_ids: ["xiaomi-token-plan"],
+    initial_balance: 0,
+    rates_text: DEFAULT_GROUP_RATES
+  }
+];
+var DEFAULT_PROVIDERS = [
+  {
+    id: "api-proxy",
+    name: "API-Proxy",
+    enabled: true,
+    group_id: "grp_api_proxy",
+    model_rates: {}
+  },
+  {
+    id: "xiaomi-token-plan",
+    name: "Xiaomi Token Plan",
+    enabled: true,
+    group_id: "grp_xiaomi",
+    model_rates: {}
+  },
+  {
+    id: "penguin-lm-gpt",
+    name: "Penguin LM GPT",
+    enabled: true,
+    group_id: "",
+    model_rates: {}
+  }
+];
+
+// src/tui.ts
+function element(tag, props = {}, children = []) {
+  try {
+    const { createElement, insert, setProp } = __require("@opentui/solid");
+    const node = createElement(tag);
+    for (const [key, value] of Object.entries(props)) {
+      if (value !== undefined)
+        setProp(node, key, value);
+    }
+    for (const child of children) {
+      if (child === null || child === undefined || child === false)
+        continue;
+      insert(node, child);
+    }
+    return node;
+  } catch {
+    return { tag, props, children };
+  }
+}
+function text(props, children) {
+  return element("text", props, children);
+}
+function box(props = {}, children = []) {
+  return element("box", props, children);
+}
+function formatNumber(n) {
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}K`;
+  return n.toString();
+}
+function formatCost(cost, decimals = 4) {
+  if (cost === 0)
+    return "$0";
+  if (cost < 0.0001)
+    return "<$0.0001";
+  return `$${cost.toFixed(decimals)}`;
+}
+var tui_default = {
+  id: "opencode-usage:tui",
+  tui: async (api, options, meta) => {
+    const t = api.theme.current;
+    const currency = options?.currency ?? "$";
+    const costDecimals = options?.cost_decimals ?? 4;
+    const showPerMsg = options?.show_per_message !== false;
+    const showTotals = options?.show_session_totals !== false;
+    const groups = options?.groups ?? DEFAULT_GROUPS;
+    const providers = options?.providers ?? DEFAULT_PROVIDERS;
+    function getUsageState() {
+      try {
+        const state = globalThis.__opencode_usage_state;
+        if (state) {
+          return {
+            session: state.session,
+            lastRecord: state.lastRecord
+          };
+        }
+      } catch {}
+      return { session: null, lastRecord: null };
+    }
+    function renderUsage() {
+      const { session, lastRecord } = getUsageState();
+      if (!session || session.total_input === 0) {
+        return null;
+      }
+      const children = [];
+      if (showTotals) {
+        children.push(text({ fg: t.textMuted, bold: true }, [` ${currency} `]), text({ fg: t.accent }, [`T: ${formatNumber(session.total_input + session.total_output)}tok`]), text({ fg: t.textMuted }, [` | In: ${formatNumber(session.total_input)}`]), text({ fg: t.textMuted }, [` Out: ${formatNumber(session.total_output)}`]));
+        if (session.total_cache_hit > 0) {
+          children.push(text({ fg: t.textMuted }, [` Cache: ${formatNumber(session.total_cache_hit)}`]));
+        }
+        children.push(text({ fg: t.accent, bold: true }, [` ${formatCost(session.total_cost, costDecimals)}`]));
+      }
+      if (showPerMsg && lastRecord && lastRecord.cost > 0) {
+        const modelShort = lastRecord.model_id.split("/").pop() || lastRecord.model_id;
+        children.push(text({ fg: t.textMuted }, [` └ ${modelShort}: `]), text({ fg: t.accent }, [`+${formatCost(lastRecord.cost, costDecimals)}`]), text({ fg: t.textMuted }, [` (${formatNumber(lastRecord.input_tokens)}→${formatNumber(lastRecord.output_tokens)})`]));
+      }
+      if (children.length === 0)
+        return null;
+      return box({
+        width: "100%",
+        flexDirection: "column",
+        padding: { left: 1, right: 0, top: 0, bottom: 0 }
+      }, children);
+    }
+    api.slots.register({
+      order: 500,
+      slots: {
+        sidebar_footer() {
+          return renderUsage();
+        },
+        home_footer() {
+          return renderUsage();
+        },
+        app_bottom() {
+          return renderUsage();
+        }
+      }
+    });
+    api.event.on("message.updated", () => {
+      try {
+        api.renderer.render();
+      } catch {}
+    });
+    api.event.on("message.completed", () => {
+      try {
+        api.renderer.render();
+      } catch {}
+    });
+    api.lifecycle.onDispose(() => {});
+  }
+};
+export {
+  tui_default as default
+};

package/dist/types.d.ts

@@ -0,0 +1,83 @@
+export interface TokenUsage {
+    input: number;
+    output: number;
+    cache_hit: number;
+    cache_create: number;
+}
+export interface RateConfig {
+    /** Cost per million tokens for normal input (after subtracting cache) */
+    input: number;
+    /** Cost per million tokens for output */
+    output: number;
+    /** Cost per million tokens for cache hits */
+    cache_hit: number;
+    /** Cost per million tokens for cache creation */
+    cache_create: number;
+    /** Cost per call (if > 0, uses per-call billing instead of per-token) */
+    calls: number;
+    /** Cost per call in dollars */
+    call_value: number;
+    /** Global multiplier applied to the total cost */
+    multiplier: number;
+    /** Time-based multipliers (Beijing time), e.g. "22:00-02:00=1.5;08:00-20:00=1.0" */
+    time_mult: string;
+}
+export interface RelayGroup {
+    /** Unique group ID */
+    id: string;
+    /** Human-readable group name */
+    name: string;
+    /** Whether this group is enabled */
+    enabled: boolean;
+    /** List of provider IDs that belong to this group */
+    provider_ids: string[];
+    /** Initial balance in dollars (only used for display/reference) */
+    initial_balance: number;
+    /** Pricing rules text (one line per model, same format as API-Proxy) */
+    rates_text: string;
+}
+export interface ProviderConfig {
+    /** Provider ID (e.g. "api-proxy", "xiaomi-token-plan") */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Whether this provider is enabled */
+    enabled: boolean;
+    /** Relay group ID this provider belongs to (empty = standalone) */
+    group_id: string;
+    /** Per-model rate overrides (overrides group rates) */
+    model_rates: Record<string, Partial<RateConfig>>;
+}
+export interface UsageRecord {
+    id: string;
+    provider_id: string;
+    model_id: string;
+    input_tokens: number;
+    output_tokens: number;
+    cache_tokens: number;
+    cache_create_tokens: number;
+    cost: number;
+    timestamp: number;
+}
+export interface SessionUsage {
+    total_input: number;
+    total_output: number;
+    total_cache_hit: number;
+    total_cache_create: number;
+    total_cost: number;
+    records: UsageRecord[];
+}
+export interface UsagePluginOptions {
+    /** Relay groups configuration */
+    groups?: RelayGroup[];
+    /** Provider configurations */
+    providers?: ProviderConfig[];
+    /** Currency symbol (default: "$") */
+    currency?: string;
+    /** Show per-message cost (default: true) */
+    show_per_message?: boolean;
+    /** Show session totals (default: true) */
+    show_session_totals?: boolean;
+    /** Decimal places for cost display (default: 4) */
+    cost_decimals?: number;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@lijinzhao8/opencode-usage",
+  "version": "1.0.0",
+  "description": "OpenCode plugin that displays real-time API usage and cost tracking, replicating API-Proxy's pricing logic",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./tui": {
+      "import": "./dist/tui.js",
+      "types": "./dist/tui.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "bun run clean && bun build src/index.ts --outdir dist --target node --format esm --external @opencode-ai/plugin --external @opentui/core --external @opentui/solid && bun build src/tui.ts --outdir dist --target node --format esm --external @opencode-ai/plugin --external @opentui/core --external @opentui/solid && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "usage",
+    "cost",
+    "tracking",
+    "api-proxy",
+    "billing"
+  ],
+  "author": "jinzhao-li",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jinzhao-li/opencode-usage"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0",
+    "@opentui/core": ">=0.3.0",
+    "@opentui/solid": ">=0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.17.9",
+    "@opentui/core": "^0.3.4",
+    "@opentui/solid": "^0.3.4",
+    "@types/node": "^22.0.0",
+    "bun-types": "^1.3.0",
+    "typescript": "^5.9.3"
+  }
+}