nexus-ai-pro 2.4.0 → 2.5.0

package/dist/evaluate/threads.js

@@ -0,0 +1,187 @@
+const USER_INSTRUCTIONS = `You are playing a user who is talking to an assistant. Stay in character.
+Your goal: {goal}
+{persona}
+Write only your next message to the assistant, as the user would. Give details the assistant asks for when your goal needs them.
+When the assistant has fully achieved your goal, reply with exactly: DONE: GOAL
+When you are sure the assistant will never achieve it, reply with exactly: DONE: GAVE UP`;
+const DONE = /^\s*DONE:\s*(GOAL|GAVE[\s-]*UP)\b/i;
+export function simulatedUser(options) {
+    return {
+        async next(context) {
+            const instructions = (options.instructions ?? USER_INSTRUCTIONS)
+                .replace('{goal}', context.goal)
+                .replace('{persona}', context.persona ?? options.persona ?? '');
+            const messages = [
+                { role: 'system', content: instructions },
+                ...context.turns.map((turn) => ({
+                    role: turn.role === 'assistant' ? 'user' : 'assistant',
+                    content: turn.content,
+                })),
+            ];
+            if (context.turns.length === 0)
+                messages.push({ role: 'user', content: 'Begin the conversation.' });
+            const response = await options.client.complete({
+                model: options.model,
+                messages,
+                temperature: options.temperature ?? 0,
+                maxTokens: options.maxTokens ?? 300,
+                ...(context.signal ? { signal: context.signal } : {}),
+            });
+            const done = DONE.exec(response.content ?? '');
+            if (done)
+                return { done: /^GOAL$/i.test(done[1]) ? 'goal' : 'gave-up' };
+            return { message: (response.content ?? '').trim() };
+        },
+    };
+}
+export function scriptedUser(script) {
+    if (typeof script === 'function')
+        return { next: script };
+    return {
+        next: ({ turns }) => {
+            const said = turns.filter((turn) => turn.role === 'user').length;
+            const message = script.messages[said];
+            return message === undefined ? { done: script.done ?? 'goal' } : { message };
+        },
+    };
+}
+export function conversationTarget(agent, options) {
+    const maxTurns = options.maxTurns ?? 10;
+    return async (inputs, context) => {
+        const user = typeof options.user === 'function' ? options.user(inputs) : options.user;
+        const turns = [];
+        const conversationId = `${context.example.id}:${context.run}:${globalThis.crypto.randomUUID()}`;
+        const ask = async () => user.next({
+            goal: inputs.goal,
+            ...(inputs.persona === undefined ? {} : { persona: inputs.persona }),
+            turns,
+            ...(context.signal ? { signal: context.signal } : {}),
+        });
+        let move = inputs.opening === undefined ? await ask() : { message: inputs.opening };
+        for (let turn = 1;; turn += 1) {
+            if ('done' in move)
+                return { turns, ended: move.done };
+            if (turn > maxTurns)
+                return { turns, ended: 'max-turns' };
+            turns.push({ role: 'user', content: move.message });
+            const started = performance.now();
+            try {
+                const reply = await agent(transcriptOf(turns), {
+                    inputs,
+                    turn,
+                    conversationId,
+                    ...(context.signal ? { signal: context.signal } : {}),
+                });
+                const latencyMs = Math.round(performance.now() - started);
+                turns.push(typeof reply === 'string'
+                    ? { role: 'assistant', content: reply, latencyMs }
+                    : {
+                        role: 'assistant',
+                        content: reply.content,
+                        latencyMs,
+                        ...(reply.messages ? { messages: reply.messages } : {}),
+                    });
+            }
+            catch (error) {
+                return {
+                    turns,
+                    ended: 'error',
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            move = await ask();
+        }
+    };
+}
+function transcriptOf(turns) {
+    return turns.flatMap((turn) => turn.role === 'assistant' && turn.messages?.length ? turn.messages : [{ role: turn.role, content: turn.content }]);
+}
+export function graphThreadAgent(graph) {
+    return async (messages, context) => {
+        const result = await graph.invoke({ messages: [...messages] }, { threadId: context.conversationId, ...(context.signal ? { signal: context.signal } : {}) });
+        const state = result.state;
+        const content = typeof state?.answer === 'string' ? state.answer : JSON.stringify(result.state);
+        const after = Array.isArray(state?.messages) ? state.messages : undefined;
+        return after && after.length > messages.length ? { content, messages: after.slice(messages.length) } : content;
+    };
+}
+function threadOf(context) {
+    const output = context.output;
+    return output && Array.isArray(output.turns) ? output : undefined;
+}
+export function formatThread(thread) {
+    return thread.turns.map((turn) => `${turn.role === 'user' ? 'User' : 'Assistant'}: ${turn.content}`).join('\n\n');
+}
+export function goalReached() {
+    return (context) => {
+        const thread = threadOf(context);
+        const reached = thread?.ended === 'goal';
+        return {
+            key: 'goal_reached',
+            score: reached ? 1 : 0,
+            passed: reached,
+            comment: thread ? `ended: ${thread.ended}${thread.error ? ` (${thread.error})` : ''}` : 'no conversation',
+        };
+    };
+}
+export function goalCompletion(judge) {
+    return async (context) => {
+        const thread = threadOf(context);
+        if (!thread)
+            return { key: 'goal_completion', score: 0, passed: false, comment: 'no conversation' };
+        const verdict = await judge.evaluate({
+            actual: formatThread(thread),
+            query: context.example.inputs.goal,
+            rubric: "The text is a conversation between a user and an assistant. Score whether the assistant achieved the user's goal, given as the question, by the end of the conversation.",
+        });
+        return {
+            key: 'goal_completion',
+            score: verdict.score,
+            passed: verdict.passed,
+            ...(verdict.rationale ? { comment: verdict.rationale } : {}),
+        };
+    };
+}
+export function turnCount() {
+    return (context) => ({
+        key: 'turns',
+        score: threadOf(context)?.turns.filter((turn) => turn.role === 'assistant').length ?? 0,
+    });
+}
+export function turnScores(evaluator, options = {}) {
+    const key = options.key ?? 'turn_score';
+    const threshold = options.threshold ?? 0.5;
+    return async (context) => {
+        const thread = threadOf(context);
+        const scores = [];
+        for (const [index, turn] of (thread?.turns ?? []).entries()) {
+            if (turn.role !== 'assistant')
+                continue;
+            const history = thread.turns.slice(0, index);
+            const question = [...history].reverse().find((item) => item.role === 'user')?.content ?? '';
+            const example = {
+                ...context.example,
+                id: `${context.example.id}#${scores.length + 1}`,
+                inputs: question,
+                metadata: { ...context.example.metadata, history, goal: context.example.inputs.goal },
+            };
+            scores.push(numeric(await evaluator({ ...context, example, output: turn.content })));
+        }
+        const mean = scores.length ? scores.reduce((sum, score) => sum + score, 0) / scores.length : 0;
+        const wrong = scores.findIndex((score) => score < threshold);
+        return {
+            key,
+            score: mean,
+            metadata: { turns: scores, ...(wrong === -1 ? {} : { wentWrongAt: wrong + 1 }) },
+            ...(wrong === -1 ? {} : { comment: `turn ${wrong + 1} scored ${scores[wrong].toFixed(2)}` }),
+        };
+    };
+}
+function numeric(result) {
+    if (typeof result === 'number')
+        return result;
+    if (typeof result === 'boolean')
+        return result ? 1 : 0;
+    const first = Array.isArray(result) ? result[0] : result;
+    return first?.score ?? 0;
+}

package/dist/operations/adapters.d.ts

@@ -58,7 +58,8 @@ export declare class RedisOperationStore<TResult = unknown> implements Operation
     private readonly client;
     private readonly prefix;
     private readonly useEval;
-    private readonly indexed;
+    /** Whether queued and leased work is kept in sorted sets, as `index: true` asks. */
+    readonly indexed: boolean;
     constructor(client: RedisOperationLikeClient, options?: RedisOperationStoreOptions);
     /**
      * Stores a new record and indexes its idempotency key. Throws `OperationDuplicateError` when another

package/dist/operations/runner.js

@@ -51,6 +51,8 @@ export class OperationRunner {
         for (const record of candidates) {
             if (claimed.length >= limit)
                 break;
+            if (!matchesFilter(record, filter))
+                continue;
             if (record.expiresAt && record.expiresAt <= nowIso) {
                 await this.settleExpired(record);
                 continue;

package/dist/operations/stats.js

@@ -5,29 +5,36 @@ export function isUnheldQueued(record, now) {
 export function matchesFilter(record, filter) {
     if (filter?.tenantId !== undefined && record.tenantId !== filter.tenantId)
         return false;
+    if (filter?.kinds && !filter.kinds.includes(record.kind ?? ''))
+        return false;
     return !filter?.kindPrefix || (record.kind ?? '').startsWith(filter.kindPrefix);
 }
 export function countRecords(records, now, filter) {
     const byStatus = {};
     let oldestQueuedAt;
     let lapsedLeases = 0;
+    const queuedByKind = {};
     for (const record of records) {
         if (isTerminalOperationStatus(record.status) || !matchesFilter(record, filter))
             continue;
         byStatus[record.status] = (byStatus[record.status] ?? 0) + 1;
-        if (record.status === 'queued' && (!oldestQueuedAt || record.createdAt < oldestQueuedAt)) {
-            oldestQueuedAt = record.createdAt;
+        if (record.status === 'queued') {
+            if (!oldestQueuedAt || record.createdAt < oldestQueuedAt)
+                oldestQueuedAt = record.createdAt;
+            const kind = record.kind ?? '';
+            queuedByKind[kind] = (queuedByKind[kind] ?? 0) + 1;
         }
         if (record.status === 'running' && (!record.lease || record.lease.expiresAt <= now))
             lapsedLeases += 1;
     }
-    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases };
+    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases, queuedByKind };
 }
 export async function operationStats(store, options = {}) {
     const now = (options.now ?? new Date()).toISOString();
-    const filter = options.kindPrefix || options.tenantId !== undefined
+    const filter = options.kindPrefix || options.kinds || options.tenantId !== undefined
         ? {
             ...(options.kindPrefix ? { kindPrefix: options.kindPrefix } : {}),
+            ...(options.kinds ? { kinds: options.kinds } : {}),
             ...(options.tenantId !== undefined ? { tenantId: options.tenantId } : {}),
         }
         : undefined;

package/dist/postgres/index.d.ts

@@ -9,9 +9,10 @@ export { PostgresPromptStore, type PostgresPromptStoreOptions, promptStoreMigrat
 export { PostgresRollupStore, type PostgresRollupStoreOptions, rollupStoreMigration, rollupStoreMigrations, } from './rollups.js';
 export { PostgresStore, type PostgresStoreOptions, storeMigration, storeMigrations } from './store.js';
 export { PostgresTraceStore, type PostgresTraceStoreOptions, traceStoreMigration, traceStoreMigrations, } from './traces.js';
+export { PostgresTenantUsage, type PostgresTenantUsageOptions, tenantUsageMigration, tenantUsageMigrations, } from './tenancy.js';
 export { PostgresVectorStore, type PostgresVectorStoreOptions, vectorStoreMigration, vectorStoreMigrations, } from './vectors.js';
 /** The Postgres adapters a migration can include. */
-export type PostgresAdapter = 'operations' | 'store' | 'traces' | 'evaluation' | 'circuits' | 'prompts' | 'rollups' | 'vectors';
+export type PostgresAdapter = 'operations' | 'store' | 'traces' | 'evaluation' | 'circuits' | 'tenancy' | 'prompts' | 'rollups' | 'vectors';
 /** Options for `postgresMigrations()` and `postgresMigration()`. */
 export interface PostgresMigrationOptions {
     /**

package/dist/postgres/index.js

@@ -7,6 +7,7 @@ import { operationStoreMigrations } from './operations.js';
 import { promptStoreMigrations } from './prompts.js';
 import { rollupStoreMigrations } from './rollups.js';
 import { storeMigrations } from './store.js';
+import { tenantUsageMigrations } from './tenancy.js';
 import { traceStoreMigrations } from './traces.js';
 import { vectorStoreMigrations } from './vectors.js';
 export { migrationChecksum, SchemaMigrationError, } from '../utils/schema-migrations.js';
@@ -19,6 +20,7 @@ export { PostgresPromptStore, promptStoreMigration, promptStoreMigrations, } fro
 export { PostgresRollupStore, rollupStoreMigration, rollupStoreMigrations, } from './rollups.js';
 export { PostgresStore, storeMigration, storeMigrations } from './store.js';
 export { PostgresTraceStore, traceStoreMigration, traceStoreMigrations, } from './traces.js';
+export { PostgresTenantUsage, tenantUsageMigration, tenantUsageMigrations, } from './tenancy.js';
 export { PostgresVectorStore, vectorStoreMigration, vectorStoreMigrations, } from './vectors.js';
 export const POSTGRES_ADAPTERS = [
     'operations',
@@ -26,6 +28,7 @@ export const POSTGRES_ADAPTERS = [
     'traces',
     'evaluation',
     'circuits',
+    'tenancy',
     'prompts',
     'rollups',
     'vectors',
@@ -39,6 +42,7 @@ export function postgresMigrations(options = {}) {
         traces: () => traceStoreMigrations(),
         evaluation: () => evaluationStoreMigrations(),
         circuits: () => circuitStoreMigrations(),
+        tenancy: () => tenantUsageMigrations(),
         prompts: () => promptStoreMigrations(),
         rollups: () => rollupStoreMigrations(),
         vectors: () => {

package/dist/postgres/operations.js

@@ -131,12 +131,12 @@ export class PostgresOperationStore {
     async stats(now, filter) {
         const params = [now];
         const narrowed = filterSql(filter, params);
-        const { rows } = await this.client.query(`SELECT status, count(*)::int AS count,
+        const { rows } = await this.client.query(`SELECT status, kind, count(*)::int AS count,
          min(created_at) FILTER (WHERE status = 'queued') AS oldest,
          count(*) FILTER (WHERE status = 'running' AND (lease_expires_at IS NULL OR lease_expires_at <= $1))::int AS lapsed
        FROM ${this.table}
        WHERE status NOT IN (${TERMINAL})${narrowed}
-       GROUP BY status`, params);
+       GROUP BY status, kind`, params);
         return statsFromRows(rows);
     }
     async prune(before) {
@@ -163,6 +163,10 @@ function filterSql(filter, params) {
         params.push(filter.kindPrefix);
         sql += ` AND substr(kind, 1, char_length($${params.length})) = $${params.length}`;
     }
+    if (filter?.kinds) {
+        params.push([...filter.kinds]);
+        sql += ` AND kind = ANY($${params.length}::text[])`;
+    }
     if (filter?.tenantId !== undefined) {
         params.push(filter.tenantId);
         sql += ` AND doc ->> 'tenantId' = $${params.length}`;
@@ -173,11 +177,14 @@ function statsFromRows(rows) {
     const byStatus = {};
     let oldestQueuedAt;
     let lapsedLeases = 0;
+    const queuedByKind = {};
     for (const row of rows) {
-        byStatus[row.status] = Number(row.count);
+        byStatus[row.status] = (byStatus[row.status] ?? 0) + Number(row.count);
+        if (row.status === 'queued')
+            queuedByKind[row.kind ?? ''] = (queuedByKind[row.kind ?? ''] ?? 0) + Number(row.count);
         if (row.oldest && (!oldestQueuedAt || row.oldest < oldestQueuedAt))
             oldestQueuedAt = row.oldest;
         lapsedLeases += Number(row.lapsed);
     }
-    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases };
+    return { byStatus, ...(oldestQueuedAt ? { oldestQueuedAt } : {}), lapsedLeases, queuedByKind };
 }

package/dist/postgres/store.d.ts

@@ -44,6 +44,13 @@ export declare class PostgresStore implements Store {
     migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /** Stores an item, keeping its original `createdAt` when it replaces one. */
     put<V>(namespace: StoreNamespace, key: string, value: V, options?: StorePutOptions): Promise<void>;
+    /**
+     * Stores an item only when the stored one's `version` is `expected`, or, with `expected` `null`,
+     * only when none is stored. One statement, so two writers deciding on one version cannot both win.
+     */
+    putIfVersion<V extends {
+        version: number;
+    }>(namespace: StoreNamespace, key: string, value: V, expected: number | null): Promise<boolean>;
     /** Reads an item, or `undefined` when it does not exist or has expired. */
     get<V>(namespace: StoreNamespace, key: string): Promise<StoreItem<V> | undefined>;
     /** Deletes an item. */

package/dist/postgres/store.js

@@ -71,6 +71,27 @@ export class PostgresStore {
             vector ? JSON.stringify(vector) : null,
         ]);
     }
+    async putIfVersion(namespace, key, value, expected) {
+        if (!key.trim())
+            throw new RangeError('A store key must not be empty');
+        const timestamp = this.now().toISOString();
+        const vector = await this.embed(value, undefined);
+        const embedding = vector ? JSON.stringify(vector) : null;
+        const cast = this.options.vectorDimensions ? '::vector' : '::jsonb';
+        const { rows } = expected === null
+            ?
+                await this.client.query(`INSERT INTO ${this.table} (ns_key, key, namespace, value, created_at, updated_at, expires_at, embedding)
+             VALUES ($1, $2, $3::jsonb, $4::jsonb, $5, $5, NULL, $6${cast})
+             ON CONFLICT (ns_key, key) DO UPDATE SET value = EXCLUDED.value, created_at = EXCLUDED.created_at,
+               updated_at = EXCLUDED.updated_at, expires_at = NULL, embedding = EXCLUDED.embedding
+             WHERE ${this.table}.expires_at IS NOT NULL AND ${this.table}.expires_at <= $5
+             RETURNING key`, [namespaceKey(namespace), key, JSON.stringify([...namespace]), JSON.stringify(value), timestamp, embedding])
+            : await this.client.query(`UPDATE ${this.table} SET value = $3::jsonb, updated_at = $4, expires_at = NULL, embedding = $5${cast}
+             WHERE ns_key = $1 AND key = $2 AND (expires_at IS NULL OR expires_at > $4)
+               AND jsonb_typeof(value -> 'version') = 'number' AND (value ->> 'version')::numeric = $6
+             RETURNING key`, [namespaceKey(namespace), key, JSON.stringify(value), timestamp, embedding, expected]);
+        return rows.length > 0;
+    }
     async get(namespace, key) {
         const { rows } = await this.client.query(`SELECT namespace::text AS namespace, key, value::text AS value, created_at, updated_at, expires_at FROM ${this.table}
        WHERE ns_key = $1 AND key = $2 AND (expires_at IS NULL OR expires_at > $3)`, [namespaceKey(namespace), key, this.now().toISOString()]);

package/dist/postgres/tenancy.d.ts

@@ -0,0 +1,43 @@
+import type { TenantUsageStore } from '../server/tenancy.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
+import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
+/** Options for `PostgresTenantUsage`. */
+export interface PostgresTenantUsageOptions {
+    /** Table name, optionally schema-qualified. Defaults to `nexus_tenant_usage`. */
+    table?: string;
+    /** Clock for slot leases and spending periods, in epoch milliseconds. Defaults to `Date.now`. */
+    now?: () => number;
+}
+/** The schema, as statements: every migration's, in order. */
+export declare function tenantUsageMigration(options?: Pick<PostgresTenantUsageOptions, 'table'>): string[];
+/** The versioned schema, which `migrate()` and `nexus db migrate` apply. */
+export declare function tenantUsageMigrations(options?: Pick<PostgresTenantUsageOptions, 'table'>): SchemaMigration[];
+/**
+ * Tenant usage in Postgres, shared by every replica, for a deployment that already runs Postgres
+ * and not Redis. Pass it to `tenantLimits({ usage })`.
+ *
+ * Each key is one row: a tenant's active slots as a JSON map from run to lease expiry, or its spending
+ * in the current period. Every step is a single statement on that row, and Postgres applies
+ * concurrent updates of one row one at a time, re-checking each against the newest version. Two
+ * replicas admitting runs for one tenant at the same moment therefore cannot both take its last slot.
+ */
+export declare class PostgresTenantUsage implements TenantUsageStore {
+    private readonly client;
+    private readonly options;
+    private readonly table;
+    private readonly now;
+    constructor(client: PostgresLikeClient, options?: PostgresTenantUsageOptions);
+    /** Creates the table, or brings it up to date. */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
+    /** Takes a slot for `member` unless `max` live slots are held. Holding one already counts as taken. */
+    acquire(key: string, member: string, max: number, ttlMs: number): Promise<boolean>;
+    /** Frees a slot. Freeing one that is not held does nothing. */
+    release(key: string, member: string): Promise<void>;
+    /** Live slots held under a key. */
+    count(key: string): Promise<number>;
+    /** Adds to a total that resets at `resetAt`, and resolves to the new total. */
+    add(key: string, amount: number, resetAt: number): Promise<number>;
+    /** A total, or 0 once its period has reset. */
+    total(key: string): Promise<number>;
+}

package/dist/postgres/tenancy.js

@@ -0,0 +1,71 @@
+import { quoteTable } from './client.js';
+export function tenantUsageMigration(options = {}) {
+    return tenantUsageMigrations(options).flatMap((migration) => [...migration.statements]);
+}
+export function tenantUsageMigrations(options = {}) {
+    const name = options.table ?? 'nexus_tenant_usage';
+    return [
+        {
+            component: `tenancy:${name}`,
+            version: 1,
+            name: 'create the tenant usage table',
+            statements: [
+                `CREATE TABLE IF NOT EXISTS ${quoteTable(name)} (
+  key text PRIMARY KEY,
+  slots jsonb NOT NULL DEFAULT '{}'::jsonb,
+  total double precision NOT NULL DEFAULT 0,
+  reset_at double precision
+)`,
+            ],
+        },
+    ];
+}
+export class PostgresTenantUsage {
+    client;
+    options;
+    table;
+    now;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+        this.table = quoteTable(options.table ?? 'nexus_tenant_usage');
+        this.now = options.now ?? Date.now;
+    }
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await import('./migrations.js');
+        return applyPostgresMigrations(this.client, tenantUsageMigrations(this.options), options);
+    }
+    async acquire(key, member, max, ttlMs) {
+        const now = this.now();
+        await this.client.query(`INSERT INTO ${this.table} (key) VALUES ($1) ON CONFLICT (key) DO NOTHING`, [key]);
+        const live = `(SELECT COALESCE(jsonb_object_agg(slot.member, slot.expires), '{}'::jsonb)
+      FROM jsonb_each(${this.table}.slots) AS slot(member, expires)
+      WHERE (slot.expires #>> '{}')::double precision > $3)`;
+        const { rows } = await this.client.query(`UPDATE ${this.table}
+       SET slots = CASE WHEN ${live} ? $2 THEN ${live} ELSE ${live} || jsonb_build_object($2::text, $4::double precision) END
+       WHERE key = $1 AND (${live} ? $2 OR (SELECT count(*) FROM jsonb_object_keys(${live})) < $5)
+       RETURNING key`, [key, member, now, now + ttlMs, max]);
+        return rows.length > 0;
+    }
+    async release(key, member) {
+        await this.client.query(`UPDATE ${this.table} SET slots = slots - $2::text WHERE key = $1`, [key, member]);
+    }
+    async count(key) {
+        const { rows } = await this.client.query(`SELECT count(*)::int AS held FROM ${this.table}, jsonb_each(${this.table}.slots) AS slot(member, expires)
+       WHERE key = $1 AND (slot.expires #>> '{}')::double precision > $2`, [key, this.now()]);
+        return Number(rows[0]?.held ?? 0);
+    }
+    async add(key, amount, resetAt) {
+        const { rows } = await this.client.query(`INSERT INTO ${this.table} (key, total, reset_at) VALUES ($1, $2, $3)
+       ON CONFLICT (key) DO UPDATE SET
+         total = CASE WHEN ${this.table}.reset_at IS NOT NULL AND ${this.table}.reset_at <= $4
+           THEN EXCLUDED.total ELSE ${this.table}.total + EXCLUDED.total END,
+         reset_at = EXCLUDED.reset_at
+       RETURNING total`, [key, amount, resetAt, this.now()]);
+        return Number(rows[0]?.total ?? 0);
+    }
+    async total(key) {
+        const { rows } = await this.client.query(`SELECT CASE WHEN reset_at IS NULL OR reset_at > $2 THEN total ELSE 0 END AS total FROM ${this.table} WHERE key = $1`, [key, this.now()]);
+        return Number(rows[0]?.total ?? 0);
+    }
+}