opencode-litellm-cost 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kevin Abraham
+
+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

@@ -0,0 +1,42 @@
+# opencode-litellm-cost
+
+An [opencode](https://opencode.ai) plugin that feeds real [LiteLLM](https://www.litellm.ai/) per-token pricing into opencode's model `cost` config, so cost tracking reflects what your LiteLLM proxy actually charges instead of opencode's built-in defaults.
+
+## What it does
+
+The plugin implements opencode's `config` hook. On config load, for every provider in your opencode config that has:
+
+- an `options.baseURL` pointing at a LiteLLM proxy, and
+- a matching entry in opencode's `auth.json` with `"type": "api"`,
+
+it calls that proxy's `/model/info` endpoint, matches models by name against your configured `models` map, and writes `input`/`output`/`cache_read`/`cache_write` costs (and, where available, `context_over_200k` tiered pricing) onto each matching model's `cost` field.
+
+It never throws — any failure (missing auth, unreachable proxy, malformed response) is caught and logged, and config loading continues normally.
+
+## Install
+
+Add the plugin to your `opencode.json`/`opencode.jsonc`:
+
+```jsonc
+{
+  "plugin": ["opencode-litellm-cost"]
+}
+```
+
+Or, if running from a local checkout, reference the file path directly:
+
+```jsonc
+{
+  "plugin": ["./plugins/opencode-litellm-cost/plugin.js"]
+}
+```
+
+## Requirements
+
+- A provider entry with `options.baseURL` set to your LiteLLM proxy base URL.
+- An entry for that same provider ID in `~/.local/share/opencode/auth.json` (or `$XDG_DATA_HOME/opencode/auth.json`) with `"type": "api"` and a valid `key`.
+- Model keys in your provider's `models` map that match the `model_name` values LiteLLM reports from `/model/info`.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "opencode-litellm-cost",
+  "version": "0.1.0",
+  "description": "Feeds real LiteLLM per-token pricing into opencode's model cost config",
+  "type": "module",
+  "main": "plugin.js",
+  "author": "Kevin Abraham <kevin@westhousefarm.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abraha2d/opencode-litellm-cost.git"
+  },
+  "homepage": "https://github.com/abraha2d/opencode-litellm-cost#readme",
+  "private": false
+}

package/plugin.js

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+/**
+ * opencode plugin: feed real LiteLLM per-token pricing into model cost config.
+ * Only implements the `config` hook. Never throws.
+ */
+export default async function litellmCostPlugin() {
+  return {
+    config: async (cfg) => {
+      try {
+        const dataDir =
+          process.env.XDG_DATA_HOME ||
+          path.join(os.homedir(), ".local", "share");
+        const authPath = path.join(dataDir, "opencode", "auth.json");
+
+        if (!fs.existsSync(authPath)) return;
+
+        let auth;
+        try {
+          auth = JSON.parse(fs.readFileSync(authPath, "utf8"));
+        } catch {
+          return;
+        }
+
+        const updateProvider = async (providerID, providerCfg) => {
+          try {
+            if (!providerCfg?.options?.baseURL) return;
+            if (
+              !providerCfg?.models ||
+              typeof providerCfg.models !== "object" ||
+              Object.keys(providerCfg.models).length === 0
+            )
+              return;
+
+            const providerAuth = auth?.[providerID];
+            if (
+              !providerAuth ||
+              providerAuth.type !== "api" ||
+              typeof providerAuth.key !== "string"
+            )
+              return;
+
+            const base = providerCfg.options.baseURL.replace(/\/+$/, "");
+            const url = base + "/model/info";
+
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            let res;
+            try {
+              res = await fetch(url, {
+                headers: { Authorization: `Bearer ${providerAuth.key}` },
+                signal: controller.signal,
+              });
+            } finally {
+              clearTimeout(timeout);
+            }
+            if (!res.ok) return;
+
+            const body = await res.json();
+            const infoList = Array.isArray(body?.data) ? body.data : [];
+            const priceByName = new Map(
+              infoList.map((m) => [m.model_name, m.model_info ?? {}]),
+            );
+
+            for (const [modelKey, modelCfg] of Object.entries(
+              providerCfg.models,
+            )) {
+              const info = priceByName.get(modelKey);
+              if (!info) continue;
+
+              const input = info.input_cost_per_token;
+              const output = info.output_cost_per_token;
+              if (typeof input !== "number" || typeof output !== "number")
+                continue;
+
+              const cost = {
+                input: input * 1_000_000,
+                output: output * 1_000_000,
+              };
+
+              if (typeof info.cache_read_input_token_cost === "number")
+                cost.cache_read = info.cache_read_input_token_cost * 1_000_000;
+              if (typeof info.cache_creation_input_token_cost === "number")
+                cost.cache_write =
+                  info.cache_creation_input_token_cost * 1_000_000;
+
+              const over200kInput = info.input_cost_per_token_above_200k_tokens;
+              const over200kOutput =
+                info.output_cost_per_token_above_200k_tokens;
+              if (
+                typeof over200kInput === "number" &&
+                typeof over200kOutput === "number"
+              ) {
+                const over = {
+                  input: over200kInput * 1_000_000,
+                  output: over200kOutput * 1_000_000,
+                };
+                if (
+                  typeof info.cache_read_input_token_cost_above_200k_tokens ===
+                  "number"
+                )
+                  over.cache_read =
+                    info.cache_read_input_token_cost_above_200k_tokens *
+                    1_000_000;
+                if (
+                  typeof info.cache_creation_input_token_cost_above_200k_tokens ===
+                  "number"
+                )
+                  over.cache_write =
+                    info.cache_creation_input_token_cost_above_200k_tokens *
+                    1_000_000;
+                cost.context_over_200k = over;
+              }
+
+              modelCfg.cost = cost;
+            }
+          } catch (err) {
+            console.error(
+              `litellm-cost: provider ${providerID} failed: ${
+                err?.name ?? "Error"
+              }: ${err?.message ?? String(err)}`,
+            );
+          }
+        };
+
+        await Promise.allSettled(
+          Object.entries(cfg.provider ?? {}).map(([providerID, providerCfg]) =>
+            updateProvider(providerID, providerCfg),
+          ),
+        );
+      } catch (err) {
+        console.error("litellm-cost: config hook failed:", err);
+      }
+    },
+  };
+}