@hachej/boring-core 0.1.71 → 0.1.73

package/dist/{PostgresModelBudgetStore-CFbEEdQL.d.ts → PostgresModelBudgetStore-D5GHv0fE.d.ts}

@@ -1,4 +1,4 @@
-import { C as CoreConfig } from './types-DVgeIw1d.js';
+import { C as CoreConfig } from './types-DDnayJjI.js';
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 
 interface RunMigrationsOptions {
@@ -89,7 +89,7 @@ interface RecordUsageResult {
     inserted: boolean;
 }
 type ReservationFinalStatus = 'settled' | 'released';
-interface FinishReservationInput {
+interface FinishReservationInput$1 {
     /** Preferred key: the id returned by reserve(). */
     reservationId?: string;
     /** Fallback key; pair with userId to scope across tenants. */
@@ -203,7 +203,7 @@ declare class PostgresMeteringStore {
      * retry), so the runId fallback resolves to the single newest matching row
      * — a settle never flips both the dead and the live reservation together.
      */
-    finishReservation(input: FinishReservationInput, status: ReservationFinalStatus): Promise<{
+    finishReservation(input: FinishReservationInput$1, status: ReservationFinalStatus): Promise<{
         updated: boolean;
     }>;
     /** Expire stale active reservations without charging. Returns the count. */
@@ -225,6 +225,9 @@ declare class PostgresMeteringStore {
     private sumActiveReservations;
 }
 
+type BudgetDatabase = PostgresJsDatabase<Record<string, unknown>>;
+type BudgetReservationStatus = 'active' | 'settled' | 'released' | 'expired';
+type BudgetReservationScope = 'model' | 'user';
 declare class ModelBudgetExceededError extends Error {
     readonly usedMicros: number;
     readonly heldMicros: number;
@@ -234,37 +237,117 @@ declare class ModelBudgetExceededError extends Error {
     readonly code = "MODEL_BUDGET_EXCEEDED";
     constructor(usedMicros: number, heldMicros: number, budgetMicros: number, requestedMicros: number);
 }
-interface ReserveModelBudgetInput {
+declare class UserBudgetExceededError extends Error {
+    readonly usedMicros: number;
+    readonly heldMicros: number;
+    readonly budgetMicros: number;
+    readonly requestedMicros: number;
+    readonly statusCode = 402;
+    readonly code = "MODEL_BUDGET_EXCEEDED";
+    constructor(usedMicros: number, heldMicros: number, budgetMicros: number, requestedMicros: number);
+}
+interface ReserveBudgetBaseInput {
     userId: string;
     workspaceId?: string;
     sessionId?: string;
     runId: string;
-    provider: string;
-    model: string;
     budgetMicros: number;
     holdMicros: number;
     ttlSeconds: number;
     now?: Date;
 }
-interface ReserveModelBudgetResult {
+type ReserveBudgetInput = (ReserveBudgetBaseInput & {
+    scope: 'user';
+    provider?: never;
+    model?: never;
+}) | (ReserveBudgetBaseInput & {
+    scope: 'model';
+    provider: string;
+    model: string;
+});
+interface ReserveBudgetResult {
+    scope: BudgetReservationScope;
     reservationId: string;
     created: boolean;
     period: string;
 }
-interface FinishModelBudgetReservationInput {
+interface BudgetReservationAdmissionInput {
+    user?: Extract<ReserveBudgetInput, {
+        scope: 'user';
+    }>;
+    model: Extract<ReserveBudgetInput, {
+        scope: 'model';
+    }>;
+}
+interface BudgetReservationAdmission {
+    user?: ReserveBudgetResult & {
+        scope: 'user';
+    };
+    model: ReserveBudgetResult & {
+        scope: 'model';
+    };
+}
+interface FinishReservationInput {
+    scope: BudgetReservationScope;
     reservationId?: string;
     runId?: string;
     userId?: string;
 }
-declare class PostgresModelBudgetStore {
+declare class PostgresBudgetReservationStore {
     private db;
+    private readonly options;
+    constructor(db: BudgetDatabase, options?: {
+        eligibleLegacySources?: readonly string[];
+    });
+    static monthPeriodUtc(now?: Date): string;
+    sweepExpired(now?: Date): Promise<number>;
+    reserve(input: ReserveBudgetInput): Promise<ReserveBudgetResult>;
+    reserveAdmission(input: BudgetReservationAdmissionInput): Promise<BudgetReservationAdmission>;
+    reserveMany(inputs: readonly ReserveBudgetInput[]): Promise<ReserveBudgetResult[]>;
+    private reserveInTransaction;
+    settle(input: FinishReservationInput): Promise<void>;
+    release(input: FinishReservationInput): Promise<void>;
+    metadataForAdmission(admission: BudgetReservationAdmission): Record<string, string>;
+    releaseCreated(admission: BudgetReservationAdmission): Promise<void>;
+    finishAdmission(admission: BudgetReservationAdmission, status: Exclude<BudgetReservationStatus, 'active' | 'expired'>): Promise<void>;
+    private handlesForAdmission;
+    finishRun(input: {
+        userId: string;
+        runId: string;
+    }, status: Exclude<BudgetReservationStatus, 'active' | 'expired'>): Promise<void>;
+    finishMany(inputs: readonly FinishReservationInput[], status: Exclude<BudgetReservationStatus, 'active' | 'expired'>): Promise<void>;
+    private scopeBudgetWhere;
+    private reservationTotal;
+    private spend;
+    private spendTotals;
+    private finish;
+    private finishInTransaction;
+}
+
+interface ReserveModelBudgetInput {
+    userId: string;
+    workspaceId?: string;
+    sessionId?: string;
+    runId: string;
+    provider: string;
+    model: string;
+    budgetMicros: number;
+    holdMicros: number;
+    ttlSeconds: number;
+    now?: Date;
+}
+type ReserveModelBudgetResult = Omit<ReserveBudgetResult, 'scope'>;
+interface FinishModelBudgetReservationInput extends Omit<FinishReservationInput, 'scope'> {
+    scope?: 'model';
+}
+declare class PostgresModelBudgetStore {
+    private readonly store;
     constructor(db: PostgresJsDatabase);
     static monthPeriodUtc(now?: Date): string;
     sweepExpired(now?: Date): Promise<number>;
     reserve(input: ReserveModelBudgetInput): Promise<ReserveModelBudgetResult>;
     settle(input: FinishModelBudgetReservationInput): Promise<void>;
     release(input: FinishModelBudgetReservationInput): Promise<void>;
-    private finish;
 }
 
-export { type CreditLedgerEntry as C, type FinishReservationInput as F, type GrantOnceInput as G, InsufficientCreditError as I, type MeteringBalance as M, PostgresMeteringStore as P, type RecordUsageInput as R, ModelBudgetExceededError as a, PostgresModelBudgetStore as b, type RecordUsageResult as c, type ReservationFinalStatus as d, type ReserveInput as e, type ReserveResult as f, type RunMigrationsOptions as g, runMigrations as r };
+export { type BudgetReservationAdmission as B, type CreditLedgerEntry as C, type FinishReservationInput as F, type GrantOnceInput as G, InsufficientCreditError as I, type MeteringBalance as M, PostgresBudgetReservationStore as P, type RecordUsageInput as R, UserBudgetExceededError as U, type BudgetReservationAdmissionInput as a, type BudgetReservationScope as b, type FinishReservationInput$1 as c, ModelBudgetExceededError as d, PostgresMeteringStore as e, PostgresModelBudgetStore as f, type RecordUsageResult as g, type ReservationFinalStatus as h, type ReserveBudgetInput as i, type ReserveBudgetResult as j, type ReserveInput as k, type ReserveResult as l, type RunMigrationsOptions as m, runMigrations as r };

package/dist/app/server/index.d.ts

@@ -2,10 +2,10 @@ import { RuntimeProvisioningContribution, RegisterAgentRoutesOptions } from '@ha
 import { DirPluginEntry, CreateWorkspaceAgentServerOptions } from '@hachej/boring-workspace/app/server';
 import { WorkspaceServerPlugin, WorkspaceBridgeOperationDefinition, WorkspaceBridgeHandler, WorkspaceBridgeRuntimeEnvOptions, WorkspaceBridgeCallRequest, WorkspaceBridgeCallResponse } from '@hachej/boring-workspace/server';
 import { FastifyInstance } from 'fastify';
-import { C as CoreConfig } from '../../types-DVgeIw1d.js';
+import { C as CoreConfig } from '../../types-DDnayJjI.js';
 import { T as TelemetrySink } from '../../telemetry-DR18MeI0.js';
-import { B as BetterAuthInstance, L as LoadConfigOptions } from '../../authHook-BUSGTx_o.js';
-import { D as Database, U as UserStore, W as WorkspaceStore } from '../../connection-D9s7Td0I.js';
+import { B as BetterAuthInstance, L as LoadConfigOptions } from '../../loadConfig-C3iHuZNw.js';
+import { D as Database, U as UserStore, W as WorkspaceStore } from '../../types-Dm11Zm56.js';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import 'better-auth';
 import 'drizzle-orm/postgres-js';

package/dist/app/server/index.js

@@ -9,13 +9,13 @@ import {
   registerRoutes,
   registerSettingsRoutes,
   registerWorkspaceRoutes
-} from "../../chunk-CIRY3ZLU.js";
+} from "../../chunk-DSENO5O4.js";
 import {
   PostgresUserStore,
   PostgresWorkspaceStore,
   createDatabase,
   telemetryEvents
-} from "../../chunk-EFM5IWTK.js";
+} from "../../chunk-JBEKMYST.js";
 import {
   noopTelemetry,
   safeCapture

package/dist/{chunk-CIRY3ZLU.js → chunk-DSENO5O4.js}

@@ -2,6 +2,7 @@ import {
   creditGrants,
   creditPurchases,
   idempotencyKeys,
+  modelBudgetReservations,
   schema_exports,
   usageLedger,
   usageReservations,
@@ -12,7 +13,7 @@ import {
   workspaceRuntimes,
   workspaceSettings,
   workspaces
-} from "./chunk-EFM5IWTK.js";
+} from "./chunk-JBEKMYST.js";
 import {
   noopTelemetry,
   safeCapture
@@ -928,6 +929,7 @@ async function deleteUserCompletely(userId, deps) {
           await tx.delete(verification_tokens).where(eq(verification_tokens.identifier, userRow.email));
         }
         await tx.delete(usageReservations).where(eq(usageReservations.userId, userId));
+        await tx.delete(modelBudgetReservations).where(eq(modelBudgetReservations.userId, userId));
         await tx.delete(usageLedger).where(eq(usageLedger.userId, userId));
         await tx.delete(creditGrants).where(eq(creditGrants.userId, userId));
         await tx.delete(creditPurchases).where(eq(creditPurchases.userId, userId));