ompchamber 2.0.2 → 3.1.0

package/src/shared/types/settings/provider.ts

@@ -22,6 +22,47 @@ export interface ProviderModel {
   reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 }
 
+/**
+ * `api` values omp's `ApiSchema` accepts — the wire dialect a provider speaks.
+ * Mirrors `models-config-schema-bundle.ts` in omp; a value here that omp does
+ * not know makes it disable EVERY custom provider in the file at once.
+ */
+export type OmpProviderApi =
+  | 'openai-completions'
+  | 'openai-responses'
+  | 'openai-codex-responses'
+  | 'azure-openai-responses'
+  | 'anthropic-messages'
+  | 'bedrock-converse-stream'
+  | 'google-generative-ai'
+  | 'google-gemini-cli'
+  | 'google-vertex'
+  | 'openrouter-decisions'
+  | 'typesafe';
+
+/** omp's `ProviderAuthSchema`. `none` is what makes a local server keyless. */
+export type ProviderAuthMode = 'apiKey' | 'none' | 'oauth';
+
+/** omp's `ProviderDiscoverySchema.type` — how omp lists a provider's models itself. */
+export type ProviderDiscoveryType =
+  | 'ollama'
+  | 'llama.cpp'
+  | 'lm-studio'
+  | 'openai-models-list'
+  | 'proxy'
+  | 'litellm'
+  | 'apple-foundation-models';
+
+/**
+ * How a provider's models reach `models.yml`.
+ *
+ * - `fetch` — the chamber lists the endpoint now and writes the ids in.
+ * - `discovery` — omp lists them live from `discovery.type`; nothing is written.
+ * - `override` — keep omp's bundled model list and only override the endpoint
+ *   (the documented "override-only provider" shape).
+ */
+export type ProviderModelSource = 'fetch' | 'discovery' | 'override';
+
 export interface ProviderItem {
   id: string;
   name: string;
@@ -35,8 +76,38 @@ export interface ProviderItem {
    */
   disabled?: boolean;
   configuredIn: string; // e.g. "auth credentials", "api key", "environment"
+  /**
+   * Where omp resolves this provider's credential from. The two are not
+   * interchangeable in the UI: an `omp-auth` provider is signed in through
+   * `/login` (the OAuth flow), while a `models.yml` provider carries its own
+   * endpoint and key and is edited in place. Testing the provider ID instead
+   * sent a keyless local server into a login flow it can never complete.
+   */
+  credentialSource?: 'omp-auth' | 'models.yml' | 'chamber';
+  /**
+   * The provider HAS an entry in omp's own `models.yml`.
+   *
+   * Read from the file by the server rather than inferred on the client, because
+   * it gates a destructive action: deleting removes that entry, and only the
+   * server knows which slugs the file actually holds. A provider that exists
+   * only in the chamber overlay must not offer the button — there is nothing in
+   * models.yml to delete.
+   */
+  inModelsYml?: boolean;
   apiKey?: string;
   baseUrl?: string;
+  /** Wire dialect from models.yml. Absent for omp's bundled providers. */
+  api?: OmpProviderApi;
+  /** Auth mode from models.yml; `none` means the provider is keyless. */
+  auth?: ProviderAuthMode;
+  /** Live-discovery type from models.yml, when the provider declares one. */
+  discovery?: ProviderDiscoveryType;
+  /**
+   * Where this provider's models come from. Persisted so the settings UI can
+   * say WHY a provider legitimately has no model list — an endpoint override
+   * for a bundled provider and a failed fetch look identical without it.
+   */
+  modelSource?: ProviderModelSource;
   models: ProviderModel[];
 }
 
@@ -46,4 +117,14 @@ export interface PresetProviderOption {
   slug: string;
   icon: string;
   defaultUrl: string;
+  /** Wire dialect the preset declares; omitted means "infer from the URL". */
+  api?: OmpProviderApi;
+  /** Auth mode the preset declares. `none` marks a keyless local server. */
+  auth?: ProviderAuthMode;
+  /** Preset pins a discovery type instead of fetching a model list. */
+  discovery?: ProviderDiscoveryType;
+  /** Preset configures a provider omp already bundles (override-only entry). */
+  bundled?: boolean;
+  /** Grouping label in the Add Provider picker. */
+  group: string;
 }

package/src/shared/types/settings/usage.ts

@@ -1,18 +1,15 @@
 /**
  * Usage / balance contracts for the Settings → Usage panel.
  *
- * Served by `GET /api/settings/usage`. Both provider reports are always
- * present; `configured` is false when the matching provider key is missing
- * from Settings → Providers, and `error` carries a human-readable failure
- * when the upstream call could not be completed.
+ * Served by `GET /api/settings/usage`. `providers` lists every provider whose
+ * credential omp can resolve — a provider with no API key is omitted, never
+ * shown as an empty row. Each entry carries the provider's own quota windows
+ * (`omp usage --json`), the token/cost burn omp recorded locally for the
+ * trailing 30 days, and — for kenari and DeepSeek — the richer provider-specific
+ * report described below. `error` carries a human-readable failure when an
+ * upstream call could not be completed.
  */
 
-/** Fields shared by every provider report. */
-export interface UsageProviderStatus {
-  configured: boolean;
-  error?: string;
-}
-
 /** A single rolling quota window from kenari's plan (week / month / 5 hours). */
 export interface KenariQuotaWindow {
   key: 'five_hour' | 'week' | 'month';
@@ -66,10 +63,16 @@ export interface KenariBalance {
   raw: string;
 }
 
-export interface KenariUsageReport extends UsageProviderStatus {
+/**
+ * kenari wallet, plan quota, and 30-day usage. Present only when kenari has a
+ * credential; the builder returns `null` otherwise, so no `configured` flag is
+ * needed on the report itself.
+ */
+export interface KenariUsageReport {
   balance?: KenariBalance;
   usage?: KenariUsage;
   quota?: KenariQuota;
+  error?: string;
 }
 
 /** One currency bucket from DeepSeek's balance response. */
@@ -86,14 +89,85 @@ export interface DeepSeekBalance {
   entries: DeepSeekBalanceEntry[];
 }
 
-export interface DeepSeekUsageReport extends UsageProviderStatus {
+/** DeepSeek prepaid balance; present only when DeepSeek has a credential. */
+export interface DeepSeekUsageReport {
   balance?: DeepSeekBalance;
+  error?: string;
+}
+
+/** Unit of a provider-reported quota amount (mirrors omp's `UsageUnit`). */
+export type UsageUnit = 'percent' | 'tokens' | 'requests' | 'credits' | 'usd' | 'minutes' | 'bytes' | 'unknown';
+
+/** Coarse state of one quota window. */
+export type UsageWindowStatus = 'ok' | 'warning' | 'exhausted' | 'unknown';
+
+/**
+ * One quota window reported by a provider's own usage endpoint, flattened from
+ * omp's `UsageLimit` (`omp usage --json`). Every amount is optional: providers
+ * populate different subsets (`used`/`limit`, `usedFraction`, or
+ * `remainingFraction`), and `usedFraction` is pre-resolved here with omp's own
+ * precedence so the UI never has to re-derive it.
+ */
+export interface UsageLimitWindow {
+  id: string;
+  label: string;
+  /** Compact window label from omp, e.g. "5h" or "7d". */
+  windowLabel?: string;
+  /** Model/account scope when the provider reports per-model windows. */
+  modelId?: string;
+  accountId?: string;
+  used?: number;
+  limit?: number;
+  remaining?: number;
+  /** Fraction used, 0..1; values above 1 mean overage. */
+  usedFraction?: number;
+  unit: UsageUnit;
+  status: UsageWindowStatus;
+  /** Epoch ms when the window rolls over. */
+  resetsAt?: number;
+  notes?: string[];
+}
+
+/**
+ * One provider row in the Usage surfaces. Only providers whose credentials
+ * were actually detected are present — a provider with no key is absent from
+ * `UsageReport.providers` entirely rather than shown as "not configured".
+ */
+export interface UsageProviderSummary {
+  /** Stable id (provider slug, lowercased) used for selection + persistence. */
+  id: string;
+  name: string;
+  /** Where the credential was found ("models.yml", "agent.db", "app DB"). */
+  credentialSources: string[];
+  /**
+   * Whether omp ships a usage adapter for this provider. False means omp has no
+   * quota endpoint for it at all (kenari, DeepSeek, arbitrary OpenAI-compatible
+   * gateways), which is different from an adapter that returned nothing — see
+   * `limitsUnavailable`.
+   */
+  tracked: boolean;
+  /**
+   * True when omp DOES track this provider but its endpoint produced no data
+   * (invalid or expired credential, unreachable endpoint, or a plan exposing no
+   * quota). Distinguishes "nothing to report" from "not supported".
+   */
+  limitsUnavailable?: boolean;
+  /** Provider-wide caveats from its usage report (e.g. spend is omp-observed). */
+  notes?: string[];
+  /** Human-readable failure from the provider's usage endpoint, when it failed. */
+  error?: string;
+  /** Native quota windows; empty when the provider exposes no usage endpoint. */
+  limits: UsageLimitWindow[];
+  /** Rich kenari report (wallet, Rupiah plan windows, MCP usage table). */
+  kenari?: KenariUsageReport;
+  /** Rich DeepSeek report (prepaid balance). */
+  deepseek?: DeepSeekUsageReport;
 }
 
 /** Response body of `GET /api/settings/usage`. */
 export interface UsageReport {
   isMock: boolean;
   generatedAt: string;
-  kenari: KenariUsageReport;
-  deepseek: DeepSeekUsageReport;
+  /** Every provider with a detected credential, ordered by display name. */
+  providers: UsageProviderSummary[];
 }

package/src/shared/types/todo.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * oh-my-pi's `todo` tool state, as the chamber reads it.
+ *
+ * omp owns this list, not the chamber: the `todo` tool writes a structured
+ * snapshot into the session JSONL (a `toolResult` entry's `details.phases`, or
+ * a `user_todo_edit` custom entry when the operator edits the list by hand), and
+ * every later branch rehydration — resume, rewind, fork, `/btw` — reads the
+ * DEEPEST such snapshot on the active branch back out of it
+ * (`getLatestTodoPhasesFromEntries`). The chamber mirrors exactly that read, so
+ * the panel and the agent's own HUD cannot disagree about what is open.
+ *
+ * The status vocabulary is omp's, including the two states the chamber's chat
+ * timeline never rendered before: `blocked` (waiting on something, with an
+ * optional note) and `abandoned` (deliberately dropped). Both are settled-but-
+ * not-done, which is why `isClosedTodo` — not `status === 'completed'` — is
+ * what any progress counter must use.
+ */
+
+/** Lifecycle state of one todo item (omp's `TodoStatus`). */
+export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'abandoned' | 'blocked';
+
+/** One task inside a phase. */
+export interface TodoItem {
+  content: string;
+  status: TodoStatus;
+  /** Present on a `blocked` task: what it is waiting for. */
+  blocker?: string;
+  details?: string;
+  notes?: string[];
+}
+
+/** A named group of tasks. */
+export interface TodoPhase {
+  name: string;
+  tasks: TodoItem[];
+}
+
+/** The `todo` op that produced a snapshot; absent on legacy transcript entries. */
+export type TodoOperation =
+  | 'init'
+  | 'start'
+  | 'done'
+  | 'rm'
+  | 'drop'
+  | 'block'
+  | 'unblock'
+  | 'append'
+  | 'view';
+
+/**
+ * Where the snapshot that resolved the list came from. A `toolResult` entry
+ * only exists when the `todo` tool actually ran in this transcript; the
+ * `custom` variant is omp's own durable rehydration record (a hand edit from
+ * the `/todo` command, a HUD reveal, or the auto-complete omp performs when a
+ * subagent matching a task description finishes). The distinction is
+ * diagnostic: "the agent never used todos here" and "the agent used them and
+ * then edited them by hand" look identical without it.
+ */
+export type TodoSnapshotSource = 'toolResult' | 'custom';
+
+/** The resolved todo list for a session, plus the entry that carried it. */
+export interface TodoSnapshot {
+  phases: TodoPhase[];
+  /** Entry id of the snapshot — what a later snapshot has to beat. */
+  sourceEntryId: string;
+  source: TodoSnapshotSource;
+  /** ISO timestamp of the snapshot entry, when it carries one. */
+  updatedAt?: string;
+  /** Op that produced it, when the entry records one. */
+  op?: TodoOperation;
+  /** omp's own storage mode: `session` (durable) or `memory` (no session file). */
+  storage?: 'session' | 'memory';
+}
+
+/** Rolled-up counters over a snapshot's tasks. */
+export interface TodoProgress {
+  total: number;
+  completed: number;
+  /** `completed` + `abandoned` — the pair omp's HUD hides as settled. */
+  closed: number;
+  inProgress: number;
+  pending: number;
+  blocked: number;
+  abandoned: number;
+}
+
+/** One session's todo state as the panel consumes it. */
+export interface SessionTodoState {
+  /** null when this session's transcript holds no committed snapshot. */
+  snapshot: TodoSnapshot | null;
+  /** Roll-up over the snapshot's tasks; all zeros when there is none. */
+  progress: TodoProgress;
+}
+
+/** Wire payload of `GET /api/omp/session-todos`. */
+export interface SessionTodosPayload extends SessionTodoState {
+  sessionId: string;
+  /** ISO timestamp of the read. */
+  generatedAt: string;
+  isMock: boolean;
+  /** Set when the session has no readable transcript (never written, or gone). */
+  error?: string;
+}

package/tsconfig.json

@@ -16,7 +16,9 @@
     "forceConsistentCasingInFileNames": true,
     "baseUrl": ".",
     "paths": {
-      "@/*": ["./src/*"]
+      "@/*": ["./src/*"],
+      "elkjs/lib/elk.bundled.js": ["./src/client/stubs/elkjs.ts"],
+      "elkjs": ["./src/client/stubs/elkjs.ts"]
     },
     "types": ["bun-types"],
     "skipLibCheck": true,