@hachej/boring-core 0.1.70 → 0.1.72

package/dist/{PostgresModelBudgetStore-CFbEEdQL.d.ts → PostgresModelBudgetStore-DWwh7ElQ.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,8 @@ declare class PostgresMeteringStore {
     private sumActiveReservations;
 }
 
+type BudgetReservationStatus = 'active' | 'settled' | 'released' | 'expired';
+type BudgetReservationScope = 'model' | 'user';
 declare class ModelBudgetExceededError extends Error {
     readonly usedMicros: number;
     readonly heldMicros: number;
@@ -234,37 +236,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: PostgresJsDatabase, 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/front/index.d.ts

@@ -154,13 +154,17 @@ interface CreditLedgerEntry {
 /** Format SIGNED credit micros as a currency string with an explicit +/− sign.
  * `currency` is the configured display currency (1 credit-unit = 1 major unit); defaults
  * to EUR for callers without a configured purchase currency. */
-declare function formatSignedCreditMicros(micros: number, currency?: string, locale?: string): string;
+interface CreditFormatOptions {
+    /** Show sub-cent/sub-rappen/sub-credit usage instead of rounding tiny amounts to 0.00. */
+    highPrecision?: boolean;
+}
+declare function formatSignedCreditMicros(micros: number, currency?: string, locale?: string, options?: CreditFormatOptions): string;
 /** Format a minor-unit price (e.g. cents) in its currency for pack labels/buttons. */
 declare function formatMinorPrice(priceMinor: number, currency: string, locale?: string): string;
 /** Format credit micros as a currency string. 1 credit-unit = 1 major unit of the
  * configured display `currency` (µ/1e6). Defaults to EUR for callers without a
  * configured purchase currency (e.g. a consumption-only deployment). */
-declare function formatCreditMicros(micros: number, currency?: string, locale?: string): string;
+declare function formatCreditMicros(micros: number, currency?: string, locale?: string, options?: CreditFormatOptions): string;
 /** True when the remaining balance is at or below the low-balance threshold. */
 declare function isLowBalance(micros: number, thresholdMicros?: number): boolean;
 /** Stable server error code for an out-of-credits rejection (mirrors the agent's

package/dist/app/front/index.js

@@ -916,19 +916,26 @@ function creditNetMicros(balance) {
   const debt = Number.isFinite(balance.debtMicros) ? balance.debtMicros : 0;
   return remaining - debt;
 }
-function formatSignedCreditMicros(micros, currency = "EUR", locale) {
+function creditFractionDigits(major, options) {
+  if (!options?.highPrecision) return {};
+  return {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: Math.abs(major) > 0 && Math.abs(major) < 0.01 ? 6 : 2
+  };
+}
+function formatSignedCreditMicros(micros, currency = "EUR", locale, options) {
   const major = (Number.isFinite(micros) ? micros : 0) / 1e6;
   const sign = major > 0 ? "+" : major < 0 ? "\u2212" : "";
-  const abs = new Intl.NumberFormat(locale, { style: "currency", currency }).format(Math.abs(major));
+  const abs = new Intl.NumberFormat(locale, { style: "currency", currency, ...creditFractionDigits(major, options) }).format(Math.abs(major));
   return `${sign}${abs}`;
 }
 function formatMinorPrice(priceMinor, currency, locale) {
   const major = (Number.isFinite(priceMinor) ? priceMinor : 0) / 100;
   return new Intl.NumberFormat(locale, { style: "currency", currency, maximumFractionDigits: major % 1 === 0 ? 0 : 2 }).format(major);
 }
-function formatCreditMicros(micros, currency = "EUR", locale) {
+function formatCreditMicros(micros, currency = "EUR", locale, options) {
   const major = (Number.isFinite(micros) ? Math.max(0, micros) : 0) / 1e6;
-  return new Intl.NumberFormat(locale, { style: "currency", currency }).format(major);
+  return new Intl.NumberFormat(locale, { style: "currency", currency, ...creditFractionDigits(major, options) }).format(major);
 }
 function isLowBalance(micros, thresholdMicros = 5e5) {
   return Number.isFinite(micros) && micros <= thresholdMicros;
@@ -1253,7 +1260,7 @@ function CreditsSettingsPanel({ apiBaseUrl = "", locale }) {
             inDebt ? `\u2212${formatCreditMicros(balance.debtMicros, currency, locale)}` : formatCreditMicros(balance.remainingMicros, currency, locale),
             updating && /* @__PURE__ */ jsx7("span", { className: "ml-2 text-[11px] font-normal text-muted-foreground", "aria-live": "polite", children: "Updating\u2026" })
           ] }) }),
-          /* @__PURE__ */ jsx7(DetailLine, { label: "Used so far", children: /* @__PURE__ */ jsx7("p", { style: { fontVariantNumeric: "tabular-nums" }, children: formatCreditMicros(balance.usedMicros, currency, locale) }) })
+          /* @__PURE__ */ jsx7(DetailLine, { label: "Used so far", children: /* @__PURE__ */ jsx7("p", { style: { fontVariantNumeric: "tabular-nums" }, children: formatCreditMicros(balance.usedMicros, currency, locale, { highPrecision: true }) }) })
         ] }),
         showBuy && packs.length > 0 && /* @__PURE__ */ jsxs6("fieldset", { className: "space-y-2", children: [
           /* @__PURE__ */ jsx7("legend", { className: "text-[12px] font-medium text-foreground", children: "Buy credits" }),
@@ -1322,7 +1329,7 @@ function CreditsSettingsPanel({ apiBaseUrl = "", locale }) {
                 {
                   style: { fontVariantNumeric: "tabular-nums" },
                   className: e.amountMicros >= 0 ? "text-foreground" : "text-muted-foreground",
-                  children: formatSignedCreditMicros(e.amountMicros, currency, locale)
+                  children: formatSignedCreditMicros(e.amountMicros, currency, locale, e.kind === "usage" ? { highPrecision: true } : void 0)
                 }
               )
             ] }, e.id)) })

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));