@elliotsystems/eai 0.1.5 → 0.1.9

package/plugin/opencode-plugin/src/tui/format.ts

@@ -71,3 +71,40 @@ export function formatDiffStat(additions: number, deletions: number): string {
 export function pluralize(count: number, singular: string, plural = `${singular}s`): string {
   return `${count} ${count === 1 ? singular : plural}`
 }
+
+/**
+ * Mirror of the backend's own `_eai_money` (`backend/app/routers/mcp.py`),
+ * so a real spend figure read out of a `get_eai_usage` tool call renders
+ * identically whether a model relayed `summary`'s prose or this sidebar
+ * rendered the structured `current_spend`/`max_budget` fields directly.
+ *
+ * ~6 decimal places, widened only as far as needed so a genuinely nonzero
+ * spend never prints as "$0.000000" — four decimals rounds a value just
+ * under a round number (0.032999144) up to a falsely clean "$0.0330", which
+ * reads as exactly that amount when it is not.
+ */
+export function formatMoney(n: number): string {
+  if (n === 0) return "$0"
+  let decimals = 6
+  while (decimals < 10 && Number(Math.abs(n).toFixed(decimals)) === 0) decimals += 1
+  return `$${n.toFixed(decimals)}`
+}
+
+/**
+ * Mirror of the backend's own `_eai_date` — "DD Mon YYYY" from an ISO
+ * timestamp's date portion. Returns the input unchanged if it does not
+ * parse, the same "degrade, never throw" rule `_eai_date` follows, since this
+ * renders inside a sidebar slot where a thrown error would blank the chrome.
+ */
+export function formatEaiDate(iso: string): string {
+  const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso)
+  if (!match) return iso
+  const [, y, m, d] = match
+  const months = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+  ]
+  const monthIndex = Number(m) - 1
+  if (monthIndex < 0 || monthIndex > 11) return iso
+  return `${d} ${months[monthIndex]} ${y}`
+}

package/plugin/opencode-plugin/src/tui/sidebar.tsx

@@ -15,6 +15,7 @@
 import { For, Show } from "solid-js"
 
 import type { SessionSlotProps, TuiPluginApi } from "./api.js"
+import { formatEaiDate, formatMoney } from "./format.js"
 import {
   collectKnowledgeResults,
   distinctCitations,
@@ -23,6 +24,7 @@ import {
   type Citation,
   type KnowledgeResult,
 } from "./knowledge.js"
+import { collectUsageResults, latestUsage, type UsageResult } from "./usage.js"
 
 /** A height-bounded panel: past this, rows push the built-in sections off. */
 const MAX_CITATIONS = 6
@@ -84,6 +86,92 @@ function CitationRow(props: { api: TuiPluginApi; citation: Citation }) {
   )
 }
 
+/**
+ * Every `get_eai_usage` call in this session.
+ *
+ * Reads the transcript rather than calling the backend — same rule, same
+ * reason as `resultsFor` and `knowledge.ts` above it.
+ */
+function usageFor(api: TuiPluginApi, sessionID: string) {
+  const servers = elliotServerNames(api.state.mcp())
+  if (servers.length === 0) return []
+
+  const parts = api.state.session
+    .messages(sessionID)
+    .flatMap((message) => [...api.state.part(message.id)])
+  return collectUsageResults(parts, servers)
+}
+
+/**
+ * The real LiteLLM spend `/usage` already proved — not the stock "Context"
+ * panel's figure, which is a local token-count × static-price-table estimate
+ * that has no entry for Elliot's proxied `elliot-general`/`elliot-coder`
+ * model names and so is always $0.00 regardless of real usage (see
+ * `usage.ts`'s own module docstring for the full reasoning).
+ *
+ * Silent until `/usage` has run once this session: there is no second
+ * credential path here to fetch it proactively, so a single muted hint line
+ * is the honest state rather than a number that has not been proven yet.
+ */
+function UsageSection(props: { api: TuiPluginApi; slot: SessionSlotProps }) {
+  const theme = props.api.theme.current
+  const usage = () => latestUsage(usageFor(props.api, props.slot.session_id))
+
+  return (
+    <box>
+      <Label api={props.api}>EAI USAGE</Label>
+      <Show
+        when={usage()}
+        fallback={
+          <text fg={theme.textMuted} selectable={false}>
+            real LiteLLM spend here after you run /usage
+          </text>
+        }
+      >
+        {(u: () => UsageResult) => (
+          <Show
+            when={u().available}
+            fallback={
+              <text fg={theme.warning} selectable={false}>
+                EAI Gateway usage temporarily unavailable
+              </text>
+            }
+          >
+            <Show
+              when={u().provisioned}
+              fallback={
+                <text fg={theme.textMuted} selectable={false}>
+                  personal EAI identity not set up yet
+                </text>
+              }
+            >
+              <Show
+                when={u().maxBudget !== null}
+                fallback={
+                  <text fg={theme.text} selectable={true}>
+                    {formatMoney(u().currentSpend)} spent (no limit set)
+                  </text>
+                }
+              >
+                <text fg={theme.text} selectable={true}>
+                  {formatMoney(u().currentSpend)} of {formatMoney(u().maxBudget ?? 0)}
+                  {"  "}
+                  ({Math.round((u().currentSpend / (u().maxBudget || 1)) * 100)}%)
+                </text>
+              </Show>
+              <Show when={u().budgetResetAt}>
+                <text fg={theme.textMuted} selectable={false}>
+                  Resets: {formatEaiDate(u().budgetResetAt!)}
+                </text>
+              </Show>
+            </Show>
+          </Show>
+        )}
+      </Show>
+    </box>
+  )
+}
+
 /** The one row that appears only on trouble. */
 function Trouble(props: { api: TuiPluginApi }) {
   const theme = props.api.theme.current
@@ -138,6 +226,8 @@ export function SidebarContent(props: { api: TuiPluginApi; slot: SessionSlotProp
           </For>
         </box>
       </Show>
+
+      <UsageSection api={props.api} slot={props.slot} />
     </box>
   )
 }

package/plugin/opencode-plugin/src/tui/usage.ts

@@ -0,0 +1,132 @@
+/**
+ * Reading Elliot's REAL LiteLLM spend out of what the TUI already has.
+ *
+ * The stock OpenCode "Context" sidebar panel shows a cost figure too, but it
+ * is computed locally -- tokens × a static per-model price table
+ * (`session.ts`), looked up by provider+model id. Elliot's provider declares
+ * its models under the LiteLLM-alias names `elliot-general`/`elliot-coder`,
+ * which are not real upstream model ids, so that table has no entry for them
+ * and the figure is always $0.00 regardless of real usage. That is a
+ * structural property of a proxied provider, not a bug in the stock panel --
+ * it has no way to know Elliot's billing.
+ *
+ * This section shows the number that panel cannot: the REAL spend LiteLLM is
+ * tracking, which is already computed server-side by `get_eai_usage`
+ * (`/usage`'s own tool) and already proven correct — it is the SAME endpoint
+ * the Web Chat Settings -> Usage view reads.
+ *
+ * Reading it works exactly like `knowledge.ts`'s does, for the identical
+ * reason recorded there: the sidebar must not call the backend itself (a
+ * second credential path the server plugin's contract forbids). So real
+ * spend appears here only AFTER the user has run `/usage` at least once in
+ * this session — the number is read out of that completed tool call's own
+ * output, never fetched independently. No polling, no background refresh.
+ */
+
+import { USAGE_TOOL, toCanonicalToolUnderAnyGateway } from "../mcp-keys.js"
+
+// ------------------------------------------------------------- host shapes --
+
+/** A `ToolPart` in its completed state, narrowed to what usage needs. */
+export interface ToolPartLike {
+  readonly type: string
+  readonly tool?: string
+  readonly state?: {
+    readonly status?: string
+    readonly output?: string
+  }
+}
+
+// ---------------------------------------------------------------- parsing --
+
+export type UsageResult = {
+  readonly available: boolean
+  readonly provisioned: boolean
+  readonly currentSpend: number
+  /** `null` means "no limit configured", a real and distinct state from
+   *  "unknown" -- mirrors `PersonalUsageResponse.max_budget`. */
+  readonly maxBudget: number | null
+  readonly budgetResetAt: string | null
+}
+
+/**
+ * Is this agent-visible tool key Elliot's own usage lookup?
+ *
+ * Exact composed-key match against the configured servers, the same rule
+ * `isKnowledgeTool` uses and for the same reason: a suffix match would let an
+ * unrelated server's tool be attributed to Elliot.
+ */
+export function isUsageTool(tool: string | undefined, serverNames: readonly string[]): boolean {
+  if (typeof tool !== "string") return false
+  return toCanonicalToolUnderAnyGateway(tool, serverNames) === USAGE_TOOL
+}
+
+/**
+ * Parse one completed `get_eai_usage` output.
+ *
+ * The output is the JSON-stringified dict `handle_get_eai_usage`
+ * (`backend/app/routers/mcp.py`) returns -- `{summary, available,
+ * provisioned, current_spend, max_budget, budget_reset_at}`. This reads the
+ * structured fields, never `summary`'s prose: that string is formatted for a
+ * model to relay verbatim and its exact wording is not a contract this file
+ * should depend on.
+ *
+ * Every branch returns `undefined` on anything unexpected, matching
+ * `parseKnowledgeOutput`'s own rule: silent rather than wrong if the backend
+ * shape changes, and `test/tui-usage.test.ts` locks the contract so a
+ * backend change breaks a test instead of the sidebar.
+ */
+export function parseUsageOutput(output: string | undefined): UsageResult | undefined {
+  if (!output) return undefined
+
+  let envelope: unknown
+  try {
+    envelope = JSON.parse(output)
+  } catch {
+    return undefined
+  }
+  if (typeof envelope !== "object" || envelope === null) return undefined
+
+  const record = envelope as Record<string, unknown>
+  const available = record["available"]
+  if (typeof available !== "boolean") return undefined
+
+  const provisioned = typeof record["provisioned"] === "boolean" ? record["provisioned"] : true
+  const currentSpend = typeof record["current_spend"] === "number" ? record["current_spend"] : 0
+  const maxBudget = typeof record["max_budget"] === "number" ? record["max_budget"] : null
+  const budgetResetAt = typeof record["budget_reset_at"] === "string" ? record["budget_reset_at"] : null
+
+  return { available, provisioned, currentSpend, maxBudget, budgetResetAt }
+}
+
+/**
+ * Every `get_eai_usage` call in this session, oldest first.
+ *
+ * Running and errored calls are skipped — "temporarily unavailable" already
+ * has its own `available: false` branch in the parsed result, and a
+ * still-running call has no output to parse at all.
+ */
+export function collectUsageResults(
+  parts: readonly ToolPartLike[],
+  serverNames: readonly string[],
+): UsageResult[] {
+  const results: UsageResult[] = []
+  for (const part of parts) {
+    if (part.type !== "tool") continue
+    if (!isUsageTool(part.tool, serverNames)) continue
+    if (part.state?.status !== "completed") continue
+    const parsed = parseUsageOutput(part.state.output)
+    if (parsed) results.push(parsed)
+  }
+  return results
+}
+
+/**
+ * The most recent usage snapshot in this session, or `undefined` if `/usage`
+ * has not been run yet. Spend is a point-in-time figure, so only the LATEST
+ * call is ever shown — unlike knowledge citations, earlier calls are not
+ * accumulated.
+ */
+export function latestUsage(results: readonly UsageResult[]): UsageResult | undefined {
+  return results.length > 0 ? results[results.length - 1] : undefined
+}