opencode-usage-insights 0.1.0 → 0.1.1

package/dist/line.d.ts

@@ -1,4 +1,4 @@
-import { type LineFields, type LineIdentity, type LineLabels, type LineTone, type Totals, type TranscriptMessage, type TurnStats, type TurnTotalsView } from "./core";
+import { type LineFields, type LineLabels, type LineTone, type Totals, type TranscriptMessage, type TurnStats, type TurnTotalsView } from "./core";
 /**
  * Adapter between the host's session messages and the pure turn accounting in
  * `core`, plus the plain-text parts the TUI line is made of.
@@ -66,7 +66,6 @@ export declare function lineParts(stats: TurnStats | undefined, options?: {
     labels?: Partial<LineLabels>;
     fields?: Partial<LineFields>;
     turnTotals?: TurnTotalsView;
-    identity?: LineIdentity;
 }): LinePart[];
 /** Plain text of the same line, useful for tests and logs. */
 export declare function lineText(parts: readonly LinePart[]): string;

package/dist/panel-build.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from "bun:sqlite";
-import { type CacheStats, type PairRow } from "./stats/aggregates";
+import { type CacheStats, type PairRow, type SwitchRow } from "./stats/aggregates";
 import { type Filters } from "./stats/queries";
 import type { DbInfo } from "./stats/maintenance";
 import { type Granularity, type LineFormatOptions, type PanelLine, type PanelRow, type PanelView, type RangeKey } from "./panel-data";
@@ -42,3 +42,5 @@ export declare function detailLabel(row: PanelRow): string;
 export declare function buildPanel(request: PanelRequest): PanelLine[];
 /** Token reuse per model, for the models view and the cache view. */
 export declare function cacheByModel(pairs: readonly PairRow[]): Map<string, CacheStats>;
+/** The switch summary per `modelKey`, as the models view reads it. */
+export declare function switchesByModel(rows: readonly SwitchRow[]): Map<string, SwitchRow>;

package/dist/panel-data.d.ts

@@ -1,7 +1,7 @@
-import { type LineFields, type LineIdentity, type LineLabels, type TurnStats, type TurnTotalsView } from "./core";
+import { type LineFields, type LineLabels, type TurnStats, type TurnTotalsView } from "./core";
 import type { CacheDropRow, LatencyReport, ModelUsage, Overview, Range, SessionUsage, TurnUsage, TtlEvidenceRow } from "./stats/queries";
 import type { DbInfo } from "./stats/maintenance";
-import type { AffinityReport, CacheStats, CoverageReport, EndpointRow, EndpointSummary, GapReport, LatencyGroupRow, PeriodGranularity, PeriodRow } from "./stats/aggregates";
+import type { CacheStats, CoverageReport, ProviderRow, ProviderSummary, GapReport, LatencyGroupRow, PeriodGranularity, PeriodRow, SwitchRow } from "./stats/aggregates";
 /**
  * View models and formatting for the stats panel. Everything here is pure:
  * the panel component feeds query results in and renders the lines out, which
@@ -9,7 +9,7 @@ import type { AffinityReport, CacheStats, CoverageReport, EndpointRow, EndpointS
  * identity the cursor selects and Enter drills into.
  */
 export declare const PANEL_NAME = "usage-insights";
-export declare const PANEL_VIEWS: readonly ["overview", "models", "endpoints", "affinity", "cache", "periods", "latency", "sessions", "turns", "db"];
+export declare const PANEL_VIEWS: readonly ["overview", "models", "providers", "cache", "periods", "latency", "sessions", "turns", "db"];
 export type PanelView = (typeof PANEL_VIEWS)[number];
 export declare const RANGE_KEYS: readonly ["session", "today", "7d", "30d", "all"];
 export type RangeKey = (typeof RANGE_KEYS)[number];
@@ -18,7 +18,7 @@ export type Granularity = (typeof GRANULARITIES)[number];
 export type PanelTone = "base" | "muted" | "warning" | "accent";
 /** What a selectable line stands for; Enter drills into it. */
 export type PanelRow = {
-    kind: "model" | "session" | "period" | "endpoint" | "provider" | "turn" | "prune";
+    kind: "model" | "session" | "period" | "provider" | "turn" | "prune";
     value: string;
     variant?: string | undefined;
 };
@@ -50,8 +50,8 @@ export type PanelSettings = {
     turnsScope: TurnsScope;
     /** Empty string means "no filter". */
     modelID: string;
-    /** The routing endpoint that served the request. */
-    routerID: string;
+    /** The provider the model ran through. */
+    providerID: string;
 };
 export declare const DEFAULT_SETTINGS: PanelSettings;
 /** Merge persisted state with the defaults, dropping anything unrecognized. */
@@ -122,7 +122,7 @@ export declare function viewBar(view: PanelView, width?: number): PanelLine;
 export declare function keysFor(of: PanelView): string;
 export declare function filterSummary(filters: {
     modelID?: string | undefined;
-    routerID?: string | undefined;
+    providerID?: string | undefined;
 }): string | undefined;
 export declare function granularityLabel(granularity: PeriodGranularity): string;
 /** Help overlay: the keys and the exact meaning of every number. */
@@ -139,20 +139,19 @@ export declare function overviewLines(data: {
 export type ModelExtras = {
     /** Reuse stats per `modelKey`, computed from the step facts. */
     cache?: Map<string, CacheStats> | undefined;
-    /** Identity changes per `modelKey`, from the affinity report. */
-    changes?: Map<string, number> | undefined;
+    /** Switches per `modelKey`, computed from the consecutive step pairs. */
+    switches?: Map<string, SwitchRow> | undefined;
 };
 /**
- * Usage per model with the cache it actually got, where it was served from and
- * how often its identity changed. One line per model; `providers` keeps the
+ * Usage per model with the cache it actually got, the providers it ran through
+ * and how often its identity changed. One line per model; `providers` keeps the
  * per-provider detail.
  */
 export declare function modelsLines(rows: readonly ModelUsage[], width: number, extras?: ModelExtras, limit?: number): PanelLine[];
-/** One row per endpoint, over every model it served. */
-export declare function endpointSummaryLines(rows: readonly EndpointSummary[], width: number, limit?: number): PanelLine[];
-/** One row per model × endpoint: the endpoints that served each model. */
-export declare function endpointsLines(rows: readonly EndpointRow[], width: number, limit?: number): PanelLine[];
-export declare function affinityLines(report: AffinityReport, width: number, limit?: number): PanelLine[];
+/** One row per provider, over every model it served. */
+export declare function providerSummaryLines(rows: readonly ProviderSummary[], width: number, limit?: number): PanelLine[];
+/** One row per model × provider: the providers each model ran through. */
+export declare function providerLines(rows: readonly ProviderRow[], width: number, limit?: number): PanelLine[];
 /** One model's reuse row, shared by the models and cache views. */
 export type CacheModelRow = {
     usage: {
@@ -186,7 +185,6 @@ export type LineFormatOptions = {
     labels?: Partial<LineLabels> | undefined;
     fields?: Partial<LineFields> | undefined;
     turnTotals?: TurnTotalsView | undefined;
-    identity?: LineIdentity | undefined;
 };
 /** The line's own view of a recorded turn, so both render identically. */
 export declare function turnStats(turn: TurnUsage): TurnStats;
@@ -204,8 +202,14 @@ export declare function turnsLines(rows: readonly TurnUsage[], width: number, op
  */
 export declare function sessionSummaryLines(usage: Overview, budget?: number): PanelLine[];
 /**
- * The sidebar history: two compact lines per turn — when and through which
- * endpoint, then the prompt volumes — truncated to the sidebar budget.
+ * The sidebar history: a compact block per turn — when and through which
+ * provider, then the prompt volumes, then the cache hit, the rate and the cost.
+ *
+ * The model gets a line of its own at both ends of the block and on every turn
+ * that changed it. The ends matter because the reader cannot tell whether a
+ * block is the whole history or a window of a long session: the newest turn
+ * names the model in use now, the oldest names the one the window started with,
+ * and everything between them is read against the nearest line below it.
  */
 export declare function sidebarLines(rows: readonly TurnUsage[], options?: LineFormatOptions & {
     budget?: number | undefined;

package/dist/recorder.d.ts

@@ -5,8 +5,10 @@ import type { Database } from "bun:sqlite";
  * unexpected shape, so unknown events are ignored and malformed payloads are
  * dropped rather than thrown.
  *
- * Pure with respect to its inputs (database plus events) so the whole
- * recording policy can be unit-tested without the plugin runtime.
+ * Everything written comes from the event stream: the step's provider, model
+ * and variant, its tokens, its timing and its outcome. Pure with respect to
+ * its inputs (database plus events) so the whole recording policy can be
+ * unit-tested without the plugin runtime.
  */
 export type SessionModelRef = {
     id: string;
@@ -48,19 +50,6 @@ export type RecorderEvent = {
     created?: number | undefined;
     data?: RecorderEventData | undefined;
 };
-export type HttpResponseInput = {
-    sessionID?: string | undefined;
-    kind?: string | undefined;
-    model?: SessionModelRef | undefined;
-    request?: {
-        method?: string | undefined;
-        url?: string | undefined;
-    } | undefined;
-    response?: {
-        status?: number | undefined;
-        headers?: Headers | Record<string, string | undefined> | undefined;
-    } | undefined;
-};
 export type PendingStep = {
     messageID: string;
     sessionID: string;
@@ -75,8 +64,6 @@ export type RecorderOptions = {
 export type Recorder = {
     /** Apply one session event. Unknown or malformed events are ignored. */
     handleEvent(event: RecorderEvent): void;
-    /** Learn the routing endpoint from one model response. */
-    handleHttpResponse(event: HttpResponseInput): void;
     pendingFor(sessionID: string): PendingStep | undefined;
 };
 export declare function createRecorder(db: Database, options?: RecorderOptions): Recorder;

package/dist/sidebar.d.ts

@@ -4,9 +4,9 @@ import type { Context } from "@opencode/plugin/tui/context";
 import { type LineFormatOptions } from "./panel-data";
 /**
  * Sidebar history: the session's accumulated usage, then the last finished
- * turns, two compact lines each (when + endpoint, then the prompt volumes).
- * Reads the same database, the same buckets and the same formatter as the panel
- * and the live line, and refreshes whenever a turn ends.
+ * turns — when and through which provider, the model when it changed, and the
+ * prompt volumes. Reads the same database, the same buckets and the same
+ * formatter as the panel and the live line, and refreshes whenever a turn ends.
  */
 export type TurnsSidebarDeps = {
     db: () => Database | undefined;

package/dist/stats/aggregates.d.ts

@@ -33,7 +33,6 @@ export type StepRow = {
     providerID: string | undefined;
     modelID: string | undefined;
     variant: string | undefined;
-    router: string | undefined;
     input: number;
     cached: number;
     cacheWrite: number;
@@ -69,18 +68,18 @@ export declare function cachePairs(db: Database, options?: Options): PairRow[];
 export type CoverageReport = {
     steps: number;
     models: number;
-    endpoints: number;
+    /** Providers the steps ran through. A step whose provider is unknown is counted nowhere. */
+    providers: number;
     missingModel: number;
-    missingEndpoint: number;
     unsettled: number;
     missingTps: number;
     firstAt: number | undefined;
     lastAt: number | undefined;
 };
 /**
- * What the panel cannot answer honestly: how many steps lack a model or an
- * observed endpoint, and how many never settled. A zero in the affinity view
- * means "never changed" only when this coverage is complete.
+ * What the panel cannot answer honestly: how many steps lack a model, and how
+ * many never settled. A zero in the switch counts means "never switched" only
+ * when this coverage is complete.
  */
 export declare function coverageOf(db: Database, options?: Options): CoverageReport;
 /** The steps a latency report is built from. It reads no generated tokens. */
@@ -103,7 +102,7 @@ export type LatencyGroupRow = {
     stream: LatencyStats;
     tps: LatencyStats;
 };
-export type Dimension = "model" | "provider" | "endpoint";
+export type Dimension = "model" | "provider";
 /** Wall, streaming window and throughput percentiles per group. */
 export declare function latencyGroupsOf(rows: readonly StepRow[], by: Dimension): LatencyGroupRow[];
 export type CacheStats = {
@@ -130,26 +129,23 @@ export type CacheModelRow = {
  * range. A boundary step is not part of the range, so it is left out.
  */
 export declare function cacheStatsByModel(rows: readonly PairRow[]): CacheModelRow[];
-export type AffinityRow = {
+export type SwitchRow = {
     modelID: string;
     variant: string | undefined;
     steps: number;
     pairs: number;
+    /** Steps whose model, variant or provider differed from the step before. */
     changes: number;
+    /** Of those, the ones whose model (or variant) differed. */
     modelChanges: number;
-    endpointChanges: number;
+    /** Of those, the ones whose provider differed. */
+    providerChanges: number;
+    /** Cache the changes cost: only a provider switch can forfeit a reusable cache. */
     cacheLost: number;
     cacheLostEvents: number;
 };
-export type AffinityTransition = {
-    dimension: "model" | "endpoint";
-    from: string;
-    to: string;
-    count: number;
-};
-export type AffinityReport = {
-    rows: AffinityRow[];
-    transitions: AffinityTransition[];
+export type SwitchReport = {
+    rows: SwitchRow[];
     totals: {
         pairs: number;
         changes: number;
@@ -158,12 +154,17 @@ export type AffinityReport = {
     };
 };
 /**
- * Identity changes between consecutive steps of a session, by the two
- * dimensions that decide where the work ran: the model and the routing
- * endpoint. A change is not by itself a fault — a gateway may re-route
- * deliberately — so the report pairs the count with the cache it actually cost.
+ * Switches between consecutive steps of a session, by the two dimensions that
+ * decide which cache holds the work: the model (with its variant) and the
+ * provider.
+ *
+ * A switch is not by itself a fault — it is usually the user choosing another
+ * model — so the report only names a cost where one is measurable: a provider
+ * switch that leaves the model intact forfeits the cache the previous provider
+ * held. A model switch has no measurable cost by definition, because two models
+ * never share a cache to lose.
  */
-export declare function affinityOf(rows: readonly PairRow[]): AffinityReport;
+export declare function switchesOf(rows: readonly PairRow[]): SwitchReport;
 export type GapBucket = {
     label: string;
     samples: number;
@@ -173,9 +174,9 @@ export type GapBucket = {
     lostTokens: number;
     retainedRatio: number | undefined;
 };
-export type EndpointReuseRow = {
-    /** The routing endpoint, or `(unknown)` when it was never observed. */
-    endpoint: string;
+export type ProviderReuseRow = {
+    /** The provider, or `(unknown)` when a step ran without one. */
+    provider: string;
     samples: number;
     retained: number;
     drops: number;
@@ -184,14 +185,14 @@ export type EndpointReuseRow = {
 };
 export type GapReport = {
     buckets: GapBucket[];
-    endpoints: EndpointReuseRow[];
+    providers: ProviderReuseRow[];
     samples: number;
 };
 /** Idle-gap buckets, coarse enough to read at a glance. */
 export declare const GAP_BUCKETS: ReadonlyArray<readonly [string, number, number | undefined]>;
 /**
  * How long an idle gap the prompt cache survives, per gap bucket and per
- * endpoint. Only pairs of the same model are comparable, which is exactly the
+ * provider. Only pairs of the same model are comparable, which is exactly the
  * set the cache rule already uses.
  */
 export declare function gapReportOf(rows: readonly PairRow[]): GapReport;
@@ -233,10 +234,10 @@ export type CacheDropRow = {
 export declare function cacheDropsOf(db: Database, rows: readonly PairRow[], options?: {
     ttlHintMs?: number;
 }): CacheDropRow[];
-export type EndpointSummary = {
-    /** The routing endpoint, or undefined for requests whose destination was never observed. */
-    endpoint: string | undefined;
-    /** Models this endpoint served. */
+export type ProviderSummary = {
+    /** The provider, or undefined for steps recorded without one. */
+    provider: string | undefined;
+    /** Models this provider served. */
     models: string[];
     share: number;
     usage: Usage;
@@ -246,14 +247,14 @@ export type EndpointSummary = {
     firstAt: number | undefined;
     lastAt: number | undefined;
 };
-export type EndpointRow = EndpointSummary & {
+export type ProviderRow = ProviderSummary & {
     modelID: string;
     variant: string | undefined;
 };
-/** One row per endpoint, over every model it served. */
-export declare function endpointSummaryOf(rows: readonly StepRow[]): EndpointSummary[];
-/** One row per model × endpoint: where each model was served, and how much. */
-export declare function endpointBreakdownOf(rows: readonly StepRow[]): EndpointRow[];
+/** One row per provider, over every model it served. */
+export declare function providerSummaryOf(rows: readonly StepRow[]): ProviderSummary[];
+/** One row per model × provider: through which provider each model ran, and how much. */
+export declare function providerBreakdownOf(rows: readonly StepRow[]): ProviderRow[];
 export type PeriodGranularity = "day" | "week" | "month";
 export type PeriodRow = {
     key: string;

package/dist/stats/db.d.ts

@@ -1,5 +1,4 @@
 import { Database } from "bun:sqlite";
-import type { EndpointInfo } from "../endpoint";
 /**
  * Persistent usage store. One SQLite database holds every recorded step,
  * prompt, event and session row — and nothing else: the recorder only writes
@@ -15,7 +14,7 @@ import type { EndpointInfo } from "../endpoint";
  * - `openStatsDbWrite` is a short-lived maintenance connection (prune, vacuum)
  *   that gives up quickly instead of holding the recorder up.
  */
-export declare const SCHEMA_VERSION = 8;
+export declare const SCHEMA_VERSION = 9;
 /** Tables carried by `exportNdjson` / `importNdjson`, in import-safe order. */
 export declare const TABLES: readonly ["sessions", "prompts", "events", "steps"];
 export type TableName = (typeof TABLES)[number];
@@ -23,6 +22,7 @@ export type StepRecord = {
     messageID: string;
     sessionID: string;
     parentID?: string | undefined;
+    /** The provider the model ran through, as OpenCode configured it (`opencode-go`). */
     providerID?: string | undefined;
     modelID?: string | undefined;
     variant?: string | undefined;
@@ -36,8 +36,6 @@ export type StepRecord = {
     streamedAt?: number | undefined;
     completedAt?: number | undefined;
     finish?: string | undefined;
-    /** Gateway routing endpoint that served the request (`orcarouter-dsv4.1flash`). */
-    router?: string | undefined;
     /** Clock of the recording itself, defaults to `Date.now()`. */
     recordedAt?: number | undefined;
 };
@@ -77,25 +75,18 @@ export declare function openStatsDbReadOnly(path: string): Database;
 export declare function openStatsDbWrite(path: string): Database;
 /**
  * Insert or refresh an assistant step. Idempotent by message ID so replayed
- * events, restarts and NDJSON imports never duplicate usage. Non-null fields
- * discovered later (the routing endpoint) survive a re-record with `NULL`
+ * events, restarts and NDJSON imports never duplicate usage. A non-null field
+ * (the provider, the model, the finish reason) survives a re-record with `NULL`
  * through COALESCE.
+ *
+ * The provider is the identity every view groups by, so it is validated as a
+ * token before it is stored: a value that is not a provider id is recorded as
+ * absent instead of becoming a grouping key.
  */
 export declare function recordStep(db: Database, record: StepRecord): void;
 export declare function recordPrompt(db: Database, record: PromptRecord): void;
 export declare function recordEvent(db: Database, record: EventRecord): void;
 export declare function upsertSession(db: Database, record: SessionRecord): void;
-/**
- * Attach the endpoint discovered after the step was recorded. A step that
- * already carries the same endpoint is left alone: the recorder runs on the
- * request path, and a no-op write there is a cost with no reader.
- */
-export declare function setStepRouter(db: Database, messageID: string, info: EndpointInfo): void;
-/**
- * Apply the endpoint learned from a compaction to every step of that session
- * and model that still lacks one. Returns the number of rows touched.
- */
-export declare function setStepRouterForSessionModel(db: Database, sessionID: string, modelID: string | undefined, info: EndpointInfo): number;
 /** Dump every table as NDJSON (`{"table": "...", "row": {...}}` per line). */
 export declare function exportNdjson(db: Database): string;
 /**

package/dist/stats/queries.d.ts

@@ -18,7 +18,7 @@ export type Range = {
     to?: number | undefined;
 };
 /**
- * Panel filters. They narrow every aggregation to one model, one endpoint or
+ * Panel filters. They narrow every aggregation to one model, one provider or
  * one session, and are applied with the same `WHERE` builder the range uses so
  * a filtered view and a drill-down agree.
  */
@@ -32,11 +32,12 @@ export type Filters = {
      */
     modelKey?: string | undefined;
     /**
-     * The routing endpoint that served the request (`router`). It is the one
-     * identity that answers "who ran this inference": the provider you configured
-     * says where the request came from, which is evidence, not an answer.
+     * The provider the model ran through, as OpenCode configured it
+     * (`opencode-go`, `deepseek`, `deepinfra`). It is the identity every view
+     * groups by: a gateway may re-route the request, but the upstream that
+     * actually ran it is not observable.
      */
-    router?: string | undefined;
+    provider?: string | undefined;
     /**
      * One session, exactly. Used by the `session` range and by the overview's
      * "this session" block, which must not pick up the steps of every other
@@ -93,8 +94,6 @@ export type Overview = Usage & {
 export declare function overview(db: Database, range?: Range, filters?: Filters): Overview;
 export type ProviderUsage = Usage & {
     providerID: string;
-    /** Gateway routing endpoints that served the requests. */
-    routers: string[];
     firstAt: number | undefined;
     lastAt: number | undefined;
 };
@@ -106,8 +105,8 @@ export type ModelUsage = {
 };
 /**
  * Usage per model, each with the providers that served it. This is the view
- * that answers "which inference providers is this model actually coming from
- * over the selected period".
+ * that answers "through which provider is this model actually coming, over the
+ * selected period".
  */
 export declare function models(db: Database, range?: Range, filters?: Filters): ModelUsage[];
 export type TimelineBucket = {
@@ -196,9 +195,6 @@ export type TurnUsage = {
     providerID: string | undefined;
     modelID: string | undefined;
     variant: string | undefined;
-    router: string | undefined;
-    /** The displayed identity differs from the previous turn of the session. */
-    routerChanged: boolean;
     providerChanged: boolean;
     modelChanged: boolean;
     steps: number;
@@ -232,28 +228,12 @@ export declare function turns(db: Database, options?: {
     filters?: Filters | undefined;
     limit?: number | undefined;
 }): TurnUsage[];
-/**
- * Routing endpoint of the newest step recorded before `at`. The TUI compares
- * it with the endpoint of the turn it is about to render, because the same
- * provider and model can be routed to a different endpoint per request.
- */
-export declare function routerBefore(db: Database, sessionID: string, at: number | undefined): string | undefined;
-/**
- * Routing endpoint of one turn: the newest endpoint the recorder stored for
- * the given steps of a session. The TUI reads this for the telemetry line
- * because the line renders from the TUI process while the recorder (the server
- * process) is still writing the step that just finished. Scoped to the turn's
- * own steps on purpose: the same provider and model can be routed to a
- * different endpoint per request, so the newest endpoint of the session is not
- * necessarily the one that served the turn being rendered.
- */
-export declare function routerForSteps(db: Database, sessionID: string, messageIDs: readonly string[]): string | undefined;
 export type FilterOption = {
     value: string;
     steps: number;
 };
-/** Distinct models and endpoints, most used first. */
+/** Distinct models and providers, most used first. */
 export declare function filterOptions(db: Database): {
     models: FilterOption[];
-    endpoints: FilterOption[];
+    providers: FilterOption[];
 };

package/dist/text.d.ts

@@ -1,12 +1,11 @@
 /**
  * Text hygiene for everything that reaches a terminal.
  *
- * Some of what the plugin displays is not written by the user: a gateway names
- * its own endpoint in a response header, a model writes a session title, an
- * NDJSON export can come from anywhere. A control character in any of those is
- * interpreted by the terminal that renders it (title changes, cursor moves,
- * colours), so every such string is stripped of control characters before it
- * is stored or drawn.
+ * Some of what the plugin displays is not written by the user: a model writes
+ * a session title, an NDJSON export can come from anywhere. A control
+ * character in any of those is interpreted by the terminal that renders it
+ * (title changes, cursor moves, colours), so every such string is stripped of
+ * control characters before it is stored or drawn.
  *
  * The rule is deliberately blunt: drop C0 controls, DEL and the C1 block, keep
  * everything else (the text is otherwise arbitrary Unicode), and cap the
@@ -24,5 +23,3 @@ export declare function sanitizeText(value: string, limit?: number): string;
 /** `sanitizeText` without the layout, for a stored label: trimmed as well. */
 export declare function sanitizeLabel(value: string, limit?: number): string;
 export declare function isToken(value: string, limit?: number): boolean;
-/** The lowercase form of a token identity, so the same endpoint groups once. */
-export declare function normalizeToken(value: string, limit?: number): string | undefined;

package/dist/tui.d.ts

@@ -1,31 +1,26 @@
 /** @jsxImportSource @opentui/solid */
 import { Plugin } from "@opencode/plugin/tui";
-import { type LineFields, type LineIdentity, type LineLabels, type TurnStats, type TurnTotalsView } from "./core";
+import { type LineFields, type LineLabels, type TurnStats, type TurnTotalsView } from "./core";
 import { type PanelView, type RangeKey } from "./panel-data";
 /**
  * TUI side of the plugin. Two contributions:
  *
  * - `session.composer.top`: one telemetry line after every turn with the end
- *   time, the delta since the previous prompt, the endpoint that served it,
- *   turn and session token totals, and cache warnings.
+ *   time, the delta since the previous prompt, the provider and model that ran
+ *   it, turn and session token totals, and cache warnings.
  * - `session.panel` + the `/stats` slash command: the statistics panel over
  *   the database written by the server entry.
  *
- * The database is opened lazily and read-only in spirit: the TUI never
- * writes usage. When the database cannot be opened, the line falls back to
- * host data only and the panel explains itself.
+ * The line is computed from the host's transcript alone; the database is opened
+ * lazily for the panel and the sidebar, read-only in spirit: the TUI never
+ * writes usage. When the database cannot be opened, the line still works and
+ * the panel explains itself.
  */
 export type Options = {
     /** Turn the TUI side off: no line and no panel. */
     enabled?: boolean | undefined;
     /** SQLite database path override; must match the server entry. */
     db?: string | undefined;
-    /**
-     * Which identity the line leads with: `endpoint` (default) shows the gateway
-     * endpoint that served the turn (`orcarouter-dsv4.1flash`) and warns when it
-     * changes; `model` shows `provider/model#variant` as before.
-     */
-    identity?: LineIdentity | undefined;
     /**
      * How the turn segment counts prompt usage: `latest` (default) shows the
      * prompt size the turn ended with, `sum` adds every step of the turn.