@aria-framework/ai 0.1.0 → 0.3.0

package/index.js

@@ -170,6 +170,13 @@ function createAiClient(deps = {}) {
 }
 
 module.exports = {
+  // The usage counter behind every ceiling. LAZY: it needs the db-worker driver contract, which
+  // is an OPTIONAL peer — a consumer using only createAiClient/polish/facts must not be made to
+  // install a database package to require this one.
+  get createUsageStore() { return require('./usageStore').createUsageStore; },
+  get createProviderStore() { return require('./providerStore').createProviderStore; },
+  get providerSchemaFor() { return require('./providerStore').schemaFor; },
+  get usageSchemaFor() { return require('./usageStore').schemaFor; },
   createAiClient,
   PROVIDERS, DEFAULTS,
   AiError, fromFetchFailure, redact,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aria-framework/ai",
   "description": "Aria App Framework — AI module. A dependency-injected model seam (createAiClient) over several providers (LM Studio / OpenAI-compatible / Anthropic), with a fact-preservation guard, generic Polish and Generate writing engines, and a browser polish widget. Prompts and config stay in the consuming app.",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "license": "UNLICENSED",
   "private": false,
   "publishConfig": {
@@ -16,9 +16,15 @@
     "generate.js",
     "providers/openai-compatible.js",
     "providers/anthropic.js",
-    "browser/ai-polish.js"
+    "browser/ai-polish.js", "usageStore.js", "providerStore.js"
   ],
+  "peerDependencies": {
+    "@aria-framework/db-worker": ">=0.7.0"
+  },
+  "peerDependenciesMeta": {
+    "@aria-framework/db-worker": { "optional": true }
+  },
   "scripts": {
-    "test": "node test/smoke.js"
+    "test": "node test/smoke.js && node test/usageStore.js && node test/providerStore.js"
   }
 }

package/providerStore.js

@@ -0,0 +1,200 @@
+/**
+ * The provider registry — every endpoint the app can talk to, configured once.
+ *
+ * WHY THIS EXISTS. Support101's AI settings page is one flat form with eleven fields describing a
+ * single provider, and nine of those eleven are really per-endpoint. That shape collapses the
+ * moment a second endpoint exists, which is what a backup provider is. The fix is not a
+ * `backup_base_url` beside every field — that is the same form doubled, and it caps at two.
+ *
+ * A PROVIDER IS AN ENDPOINT, not a job. It has a connection, a model or two, capability limits and
+ * its own spend guard, and it can be health-checked. Routes reference providers by id, so one
+ * endpoint can be one route's primary and another's fallback without being configured twice.
+ *
+ * ── THE ID IS THE OPERATOR'S ────────────────────────────────────────────────────────────────────
+ * `local-fast`, `gpu-box-1`, whatever they like. NO CALL SITE EVER NAMES A PROVIDER — code names a
+ * route, the operator decides what serves it. That is the whole reason failover is possible, and
+ * it means renaming a provider must break nothing.
+ *
+ * ── ONE ENDPOINT CAN SERVE CHAT AND EMBEDDINGS ──────────────────────────────────────────────────
+ * `model` and `embedding_model` are separate columns on the SAME row because that is how the
+ * servers actually work: one LM Studio instance answers both. Splitting them into two provider
+ * rows would duplicate the connection, and then its health twice. A chat route reads `model`, an
+ * embedding route reads `embedding_model`.
+ *
+ * ── THE API KEY IS NOT IN THIS TABLE ────────────────────────────────────────────────────────────
+ * It lives in whatever secret store the app already has — Support101 keeps it in an encrypted
+ * credentials database beside its Entra secret. So `secrets` is INJECTED, the package never sees a
+ * credential at rest, and `resolve()` is the only thing that pulls one. Keys are write-only from
+ * the UI's point of view: there is no read-back, because a lost LLM key is rotated at the
+ * provider, not recovered.
+ */
+
+'use strict';
+
+/** Columns the caller may set. `id` is separate — it is the key and is never updated in place. */
+const FIELDS = [
+  'label', 'kind', 'base_url', 'model', 'embedding_model',
+  'context_tokens', 'max_tokens', 'timeout_ms', 'daily_token_cap', 'enabled', 'sort_order'
+];
+
+const NUMERIC = new Set(['context_tokens', 'max_tokens', 'timeout_ms', 'daily_token_cap', 'enabled', 'sort_order']);
+
+/** An id an operator typed, constrained so it can appear in a URL and a log line unescaped. */
+function assertId(id) {
+  if (typeof id !== 'string' || !/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/.test(id)) {
+    throw new Error(
+      `provider id ${JSON.stringify(id)} is not usable: 3-40 characters, lowercase letters, ` +
+      'digits and hyphens, not starting or ending with a hyphen.'
+    );
+  }
+  return id;
+}
+
+/**
+ * @param {object} opts
+ *   driver     @aria-framework/db-worker driver contract (required)
+ *   table      default 'ai_providers'
+ *   secrets    { get(id) => Promise<string> } — the app's credential store. Optional; without it
+ *              resolve() returns an empty apiKey, which is correct for local endpoints.
+ *   defaults   { [kind]: { baseUrl, model, label } } — the package's PROVIDER DEFAULTS, so a row
+ *              may leave base_url or model blank and still resolve to something usable.
+ */
+function createProviderStore(opts = {}) {
+  const driver = opts.driver;
+  if (!driver || typeof driver.run !== 'function') {
+    throw new Error('createProviderStore({ driver }): the db-worker driver contract is required');
+  }
+  const table = opts.table || 'ai_providers';
+  const secrets = opts.secrets || null;
+  const defaults = opts.defaults || {};
+
+  const clean = (p) => {
+    const out = {};
+    for (const f of FIELDS) {
+      if (p[f] === undefined) continue;
+      out[f] = NUMERIC.has(f) ? (Number(p[f]) || 0) : (p[f] == null ? null : String(p[f]));
+    }
+    return out;
+  };
+
+  return {
+    table,
+
+    /** Every provider, in the operator's chosen order. */
+    async all() {
+      return driver.all(`SELECT * FROM ${table} ORDER BY sort_order, id`);
+    },
+
+    /** Only the ones that may be used. A disabled provider stays configured but is never called. */
+    async enabled() {
+      return driver.all(`SELECT * FROM ${table} WHERE enabled = 1 ORDER BY sort_order, id`);
+    },
+
+    async byId(id) {
+      return driver.get(`SELECT * FROM ${table} WHERE id = ?`, [String(id)]);
+    },
+
+    async create(p = {}) {
+      const id = assertId(p.id);
+      if (await this.byId(id)) throw new Error(`a provider called ${JSON.stringify(id)} already exists`);
+      if (!p.kind) throw new Error('a provider needs a kind (the adapter that talks to it)');
+      const fields = clean(p);
+      const cols = ['id'].concat(Object.keys(fields));
+      const vals = [id].concat(Object.values(fields));
+      await driver.run(
+        `INSERT INTO ${table} (${cols.join(', ')}) VALUES (${cols.map(() => '?').join(', ')})`, vals);
+      return { id };
+    },
+
+    /**
+     * Update in place. The ID IS NOT UPDATABLE here on purpose: routes reference providers by id,
+     * so renaming one would silently orphan every chain that points at it. A rename is a create
+     * plus a repoint plus a delete, which is a deliberate act rather than a typo in a text field.
+     */
+    async update(id, p = {}) {
+      const existing = await this.byId(id);
+      if (!existing) throw new Error(`no provider called ${JSON.stringify(id)}`);
+      const fields = clean(p);
+      const keys = Object.keys(fields);
+      if (!keys.length) return { changes: 0 };
+      const r = await driver.run(
+        `UPDATE ${table} SET ${keys.map((k) => `${k} = ?`).join(', ')} WHERE id = ?`,
+        Object.values(fields).concat([String(id)]));
+      return { changes: r.changes };
+    },
+
+    async remove(id) {
+      const r = await driver.run(`DELETE FROM ${table} WHERE id = ?`, [String(id)]);
+      return { changes: r.changes };
+    },
+
+    /**
+     * Everything needed to make a call, in the shape createAiClient's `resolveConfig` returns.
+     *
+     * This is the seam that makes adoption a swap rather than a rewrite: an app whose getConfig()
+     * read eleven settings keys can point at this instead and change nothing else.
+     *
+     * @param {string} id
+     * @param {{embedding?: boolean}} o  resolve the EMBEDDING model rather than the chat one
+     */
+    async resolve(id, o = {}) {
+      const row = await this.byId(id);
+      if (!row) return { provider: 'off', enabled: false, missing: String(id) };
+      if (!row.enabled) return { provider: 'off', enabled: false, disabled: String(id) };
+
+      const d = defaults[row.kind] || {};
+      let apiKey = '';
+      if (secrets && typeof secrets.get === 'function') {
+        // A credential store that is locked or unavailable must not take the whole call down with
+        // an exception — a local endpoint needs no key at all, and the adapter's own auth failure
+        // is a better error than "the keychain was busy".
+        try { apiKey = (await secrets.get(row.id)) || ''; } catch (_) { apiKey = ''; }
+      }
+
+      return {
+        enabled: true,
+        id: row.id,
+        provider: row.kind,
+        label: row.label || d.label || row.id,
+        baseUrl: row.base_url || d.baseUrl || '',
+        model: (o.embedding ? row.embedding_model : row.model) || (o.embedding ? '' : d.model) || '',
+        embeddingModel: row.embedding_model || '',
+        apiKey,
+        timeoutMs: Number(row.timeout_ms) || 60000,
+        maxTokens: Number(row.max_tokens) || 1024,
+        contextTokens: Number(row.context_tokens) || 8192,
+        dailyTokenCap: Number(row.daily_token_cap) || 0
+      };
+    }
+  };
+}
+
+/**
+ * The DDL, in the caller's dialect.
+ *
+ * `id` is TEXT and the primary key rather than an autoincrement integer, because it is the name an
+ * operator types and the thing routes reference. A surrogate key would mean routes pointed at
+ * numbers nobody recognises in a config screen.
+ */
+function schemaFor(dialect) {
+  const t = dialect || { now: () => "datetime('now')" };
+  return `
+  id                TEXT    PRIMARY KEY,
+  label             TEXT,
+  kind              TEXT    NOT NULL,
+  base_url          TEXT,
+  model             TEXT,
+  embedding_model   TEXT,
+  context_tokens    INTEGER NOT NULL DEFAULT 0,
+  max_tokens        INTEGER NOT NULL DEFAULT 0,
+  timeout_ms        INTEGER NOT NULL DEFAULT 0,
+  -- Per PROVIDER, not global: a ceiling is meaningless on a GPU you already own, and the whole
+  -- point of a cheap cloud fallback is capping what it may spend while the primary is down.
+  daily_token_cap   INTEGER NOT NULL DEFAULT 0,
+  enabled           INTEGER NOT NULL DEFAULT 1,
+  sort_order        INTEGER NOT NULL DEFAULT 0,
+  created_at        TEXT    NOT NULL DEFAULT (${t.now()})
+`;
+}
+
+module.exports = { createProviderStore, schemaFor, _assertId: assertId };

package/usageStore.js

@@ -0,0 +1,273 @@
+/**
+ * What the model has cost — the counter behind every ceiling.
+ *
+ * EXTRACTED FROM SUPPORT101 (models/AiUsage.js + lib/ai/budget.js), which has run this in
+ * production since its migration 014. The design decisions below are its, kept because they were
+ * right and the reasoning was written down; what changed is that the app-specific parts became
+ * parameters.
+ *
+ * ── APPEND-ONLY, ONE ROW PER CALL ───────────────────────────────────────────────────────────────
+ * Not a per-day counter that gets incremented. Two reasons, both from the original:
+ *   1. A counter update is a read-modify-write, and two concurrent calls lose one of them. A
+ *      ceiling backed by a lossy counter is a report, not a limit.
+ *   2. A row per call is what makes "which ticket ate the budget" answerable at all.
+ *
+ * The cost is volume, and it is NOT negligible at every scale. Support101's own comment says "the
+ * table is small — a busy day is hundreds of rows", which is true for a helpdesk (~110k rows/year)
+ * and false for log triage (~14.6M rows/year at 40k calls/day). So `rollup()` exists: detail rows
+ * are short-lived, and a daily aggregate is what survives. Append-only is preserved; only the
+ * retention of the detail changes.
+ *
+ * ── CHECKED BEFORE, RECORDED AFTER ──────────────────────────────────────────────────────────────
+ * There is no way to know what a call will cost until it returns, so a ceiling is "you are already
+ * over", never "this would take you over". The last call may overshoot by its own size. The
+ * alternative — estimate and refuse in advance — is a guess about a number that cannot be
+ * computed, and being wrong in the confident direction blocks work that would have fit. A bounded
+ * overshoot is explainable; a wrong estimate is not.
+ *
+ * ── A CEILING OF 0 IS OFF ───────────────────────────────────────────────────────────────────────
+ * Not "no tokens allowed". An install that has never opened the budget screen is unlimited rather
+ * than silently broken — the opposite default presents as "the AI stopped working" on a fresh
+ * install with no clue why.
+ *
+ * ── THE DAY IS THE APP'S DAY ────────────────────────────────────────────────────────────────────
+ * A ceiling is an allowance a person set, so it resets when their day does. Computing it in UTC
+ * rolls the budget over mid-afternoon in +02:00, which gets diagnosed as "the AI randomly stopped
+ * working". The clock is therefore injected, and defaults to the host's local date.
+ *
+ * ── WHAT STAYS IN THE APP ───────────────────────────────────────────────────────────────────────
+ * The SCOPE column and its foreign key. Support101 scopes by `ticket_id REFERENCES tickets(id)
+ * ON DELETE SET NULL` — deleting a ticket KEEPS the usage row and forgets which ticket it belonged
+ * to, so the spend history survives the thing it was spent on. (An earlier draft of this comment
+ * said CASCADE, which would have been the opposite and wrong: erasing a ticket would erase the
+ * record that its budget was ever consumed.) That is real behaviour a generic column could not
+ * carry, and app 3 will scope by incident instead. So the package is told the column NAME and the
+ * app owns the column, its type and its constraints.
+ */
+
+'use strict';
+
+/** YYYY-MM-DD in whatever zone the supplied clock is in. */
+function dayOf(date) {
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+/**
+ * @param {object} opts
+ *   driver         @aria-framework/db-worker driver contract (required)
+ *   table          detail table, default 'ai_usage'
+ *   rollupTable    daily aggregate, default 'ai_usage_daily'
+ *   scopeColumn    the app's scope column, e.g. 'ticket_id'. Omitted = no scope dimension.
+ *   routeColumn    the route column, e.g. 'route'. Omitted = no route dimension.
+ *   now            () => Date, the APP'S clock. Default: host local time.
+ */
+function createUsageStore(opts = {}) {
+  const driver = opts.driver;
+  if (!driver || typeof driver.run !== 'function') {
+    throw new Error('createUsageStore({ driver }): the db-worker driver contract is required');
+  }
+  const table = opts.table || 'ai_usage';
+  const rollupTable = opts.rollupTable || 'ai_usage_daily';
+  const scopeCol = opts.scopeColumn || null;
+  const routeCol = opts.routeColumn || null;
+  const now = typeof opts.now === 'function' ? opts.now : () => new Date();
+
+  /** Column list and placeholders, built once from what the app actually has. */
+  const cols = ['day', 'provider', 'model', 'calls', 'prompt_tokens', 'completion_tokens', 'total_tokens'];
+  if (scopeCol) cols.splice(3, 0, scopeCol);
+  if (routeCol) cols.splice(3, 0, routeCol);
+
+  return {
+    table,
+    rollupTable,
+
+    /** The current day string, exposed because callers compare against it. */
+    today: () => dayOf(now()),
+
+    /**
+     * Record one provider call. NEVER THROWS — see the wrapper in `budget` below; a lost counter
+     * row is a bookkeeping problem, not a reason to fail work that succeeded.
+     */
+    async record(entry = {}) {
+      const prompt = Number(entry.promptTokens) || 0;
+      const completion = Number(entry.completionTokens) || 0;
+      const total = Number(entry.totalTokens) || (prompt + completion);
+
+      const values = [dayOf(now()), String(entry.provider || ''), String(entry.model || '')];
+      if (routeCol) values.push(entry.route == null ? null : String(entry.route));
+      if (scopeCol) values.push(entry.scope == null ? null : entry.scope);
+      values.push(1, prompt, completion, total);
+
+      const placeholders = cols.map(() => '?').join(', ');
+      const r = await driver.run(
+        `INSERT INTO ${table} (${cols.join(', ')}) VALUES (${placeholders})`, values);
+      return { id: r.lastId };
+    },
+
+    /** Tokens spent today, across every path — background jobs and button presses alike. */
+    async tokensToday() {
+      const r = await driver.get(
+        `SELECT COALESCE(SUM(total_tokens), 0) n FROM ${table} WHERE day = ?`, [dayOf(now())]);
+      return Number(r.n) || 0;
+    },
+
+    /**
+     * Tokens ever spent against one scope.
+     *
+     * NOT PER DAY, deliberately, and this is load-bearing: the scope cap exists to stop one
+     * pathological thread — a hundred-message argument, or a retry loop against something the
+     * model keeps failing on — from eating the budget. A cap that reset at midnight would let
+     * exactly that happen, one day at a time, which is the failure it was written to prevent.
+     */
+    async tokensForScope(scope) {
+      if (!scopeCol) throw new Error('createUsageStore: no scopeColumn was configured');
+      const r = await driver.get(
+        `SELECT COALESCE(SUM(total_tokens), 0) n FROM ${table} WHERE ${scopeCol} = ?`, [scope]);
+      return Number(r.n) || 0;
+    },
+
+    /** For the admin screen: recent days, newest first. */
+    async byDay(days = 14) {
+      const limit = Math.min(200, Math.max(1, Number(days) * 4));
+      const group = ['day', 'provider', 'model'].concat(routeCol ? [routeCol] : []);
+      return driver.all(
+        `SELECT ${group.join(', ')},
+                SUM(calls) calls, SUM(prompt_tokens) prompt_tokens,
+                SUM(completion_tokens) completion_tokens, SUM(total_tokens) total_tokens
+           FROM ${table}
+          GROUP BY ${group.join(', ')}
+          ORDER BY day DESC, total_tokens DESC
+          LIMIT ?`, [limit]);
+    },
+
+    /** Totals per provider over a window, for the usage screen's per-provider table. */
+    async byProvider(sinceDay) {
+      return driver.all(
+        `SELECT provider, model,
+                SUM(calls) calls, SUM(prompt_tokens) prompt_tokens,
+                SUM(completion_tokens) completion_tokens, SUM(total_tokens) total_tokens
+           FROM ${table}
+          WHERE day >= ?
+          GROUP BY provider, model
+          ORDER BY total_tokens DESC`, [String(sinceDay)]);
+    },
+
+    /**
+     * Fold completed days of detail into the daily aggregate, then drop the folded detail.
+     *
+     * THIS IS WHAT MAKES APPEND-ONLY SURVIVABLE AT VOLUME. Deliberately NOT a trigger or an upsert
+     * on the write path: keeping the hot path a plain INSERT is the entire reason two concurrent
+     * calls cannot lose each other's counts.
+     *
+     * GRANULARITY MATCHES THE DATA. The detail table carries `day`, not an hour, so this rolls up
+     * by day — an earlier draft grouped by day and wrote the result into an `hour` column, which
+     * was incoherent. A consumer that needs finer buckets (log triage, where a day is far too
+     * coarse) adds an hour column to its own detail table and configures it; inventing one here
+     * from a date would be inventing precision that was never recorded.
+     *
+     * ONLY COMPLETED DAYS are folded. Folding today would race with calls still arriving into it,
+     * and the aggregate would disagree with the detail for as long as the day lasted.
+     *
+     * IDEMPOTENT via a watermark read from the aggregate's own MAX(day) — see below. Re-running is
+     * a no-op rather than a doubling, which matters because retention can leave folded detail in
+     * place for days.
+     *
+     * @param {{keepDetailDays?: number}} o  how many completed days of DETAIL to keep after
+     *        folding. 0 = keep none; the aggregate is the record from then on.
+     * @returns {{folded: number, deleted: number}}
+     */
+    async rollup(o = {}) {
+      const keepDays = Math.max(0, Number(o.keepDetailDays) || 0);
+      const group = ['provider', 'model'].concat(routeCol ? [routeCol] : []);
+      const todayStr = dayOf(now());
+      // Detail older than this is safe to delete: it has been folded AND is past retention.
+      const deleteBefore = dayOf(new Date(now().getTime() - keepDays * 86400000));
+
+      let folded = 0;
+      let deleted = 0;
+      await driver.transaction(async (tx) => {
+        // THE WATERMARK, and it is what makes this idempotent. Without it, any run with
+        // keepDetailDays > 0 re-folds detail that survived the last run and DOUBLES the aggregate
+        // — the ON CONFLICT accumulates, which is correct for new rows and catastrophic for
+        // repeats. Derived from the aggregate itself rather than stored separately: the highest
+        // day already folded is exactly `MAX(day)` there, so there is no second piece of state to
+        // keep in step.
+        const mark = await tx.get(`SELECT MAX(day) m FROM ${rollupTable}`);
+        const after = (mark && mark.m) || '';
+
+        const rows = await tx.all(
+          `SELECT day, ${group.join(', ')},
+                  SUM(calls) calls, SUM(prompt_tokens) p, SUM(completion_tokens) c,
+                  SUM(total_tokens) t
+             FROM ${table}
+            WHERE day < ? AND day > ?
+            GROUP BY day, ${group.join(', ')}`, [todayStr, after]);
+
+        const key = ['day', 'provider', 'model'].concat(routeCol ? [routeCol] : []);
+        for (const row of rows) {
+          const vals = [row.day, row.provider, row.model];
+          if (routeCol) vals.push(row[routeCol]);
+          await tx.run(
+            `INSERT INTO ${rollupTable} (${key.join(', ')}, calls, prompt_tokens, completion_tokens, total_tokens)
+             VALUES (${key.map(() => '?').join(', ')}, ?, ?, ?, ?)
+             ON CONFLICT(${key.join(', ')}) DO UPDATE SET
+               calls = ${rollupTable}.calls + excluded.calls,
+               prompt_tokens = ${rollupTable}.prompt_tokens + excluded.prompt_tokens,
+               completion_tokens = ${rollupTable}.completion_tokens + excluded.completion_tokens,
+               total_tokens = ${rollupTable}.total_tokens + excluded.total_tokens`,
+            vals.concat([row.calls, row.p, row.c, row.t]));
+          folded++;
+        }
+
+        if (folded && deleteBefore < todayStr) {
+          const res = await tx.run(`DELETE FROM ${table} WHERE day < ?`, [deleteBefore]);
+          deleted = Number(res.changes) || 0;
+        }
+      });
+      return { folded, deleted };
+    }
+  };
+}
+
+/**
+ * The DDL for both tables, in the caller's dialect.
+ *
+ * The app owns its SCOPE column and any foreign key on it — Support101's `ticket_id` cascades from
+ * `tickets`, which a generic column could not do — so this emits everything EXCEPT that, and the
+ * app adds it in its own migration.
+ */
+function schemaFor(dialect, o = {}) {
+  const t = dialect || {
+    autoIncrementPk: () => 'INTEGER PRIMARY KEY AUTOINCREMENT',
+    now: () => "datetime('now')"
+  };
+  const route = o.routeColumn ? `\n  ${o.routeColumn}${' '.repeat(Math.max(1, 14 - o.routeColumn.length))}TEXT,` : '';
+  return {
+    detail: `
+  id                ${t.autoIncrementPk()},
+  day               TEXT    NOT NULL,
+  provider          TEXT    NOT NULL,
+  model             TEXT    NOT NULL,${route}
+  calls             INTEGER NOT NULL DEFAULT 1,
+  prompt_tokens     INTEGER NOT NULL DEFAULT 0,
+  completion_tokens INTEGER NOT NULL DEFAULT 0,
+  total_tokens      INTEGER NOT NULL DEFAULT 0,
+  created_at        TEXT    NOT NULL DEFAULT (${t.now()})
+`,
+    // The UNIQUE key is what ON CONFLICT targets — without it the rollup silently inserts
+    // duplicates instead of accumulating, and every re-run doubles the totals.
+    rollup: `
+  day               TEXT    NOT NULL,
+  provider          TEXT    NOT NULL,
+  model             TEXT    NOT NULL,${route}
+  calls             INTEGER NOT NULL DEFAULT 0,
+  prompt_tokens     INTEGER NOT NULL DEFAULT 0,
+  completion_tokens INTEGER NOT NULL DEFAULT 0,
+  total_tokens      INTEGER NOT NULL DEFAULT 0,
+  UNIQUE(day, provider, model${o.routeColumn ? ', ' + o.routeColumn : ''})
+`
+  };
+}
+
+module.exports = { createUsageStore, schemaFor, _dayOf: dayOf };