@hachej/boring-core 0.1.64 → 0.1.65

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

@@ -12,7 +12,7 @@ import {
   workspaceRuntimes,
   workspaceSettings,
   workspaces
-} from "./chunk-6ZY63QYN.js";
+} from "./chunk-EFM5IWTK.js";
 import {
   noopTelemetry,
   safeCapture
@@ -599,6 +599,30 @@ async function closeDbPoolIfPresent(app) {
 }
 function installShutdownHandlers(app) {
   let shuttingDown = false;
+  const activeRequests = /* @__PURE__ */ new Set();
+  const drainWaiters = /* @__PURE__ */ new Set();
+  const notifyRequestDrained = () => {
+    if (activeRequests.size > 0) return;
+    for (const resolve3 of drainWaiters) resolve3();
+    drainWaiters.clear();
+  };
+  app.addHook("onRequest", async (request) => {
+    activeRequests.add(request.id);
+  });
+  app.addHook("onResponse", async (request) => {
+    activeRequests.delete(request.id);
+    notifyRequestDrained();
+  });
+  app.addHook("onError", async (request) => {
+    activeRequests.delete(request.id);
+    notifyRequestDrained();
+  });
+  const waitForInflightRequests = async () => {
+    if (activeRequests.size === 0) return;
+    await new Promise((resolve3) => {
+      drainWaiters.add(resolve3);
+    });
+  };
   const onSignal = async (signal) => {
     if (shuttingDown) return;
     shuttingDown = true;
@@ -606,7 +630,7 @@ function installShutdownHandlers(app) {
     try {
       let timeoutHandle;
       const result = await Promise.race([
-        app.close(),
+        Promise.all([app.close(), waitForInflightRequests()]).then(() => "closed"),
         new Promise((resolve3) => {
           timeoutHandle = setTimeout(() => {
             resolve3("timeout");
@@ -1757,14 +1781,14 @@ function createPostSignupHook(deps) {
 import { betterAuth, APIError } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
 import { magicLink } from "better-auth/plugins/magic-link";
-import { zxcvbn, zxcvbnOptions } from "@zxcvbn-ts/core";
+import { ZxcvbnFactory } from "@zxcvbn-ts/core";
 import * as zxcvbnCommon from "@zxcvbn-ts/language-common";
 import * as zxcvbnEn from "@zxcvbn-ts/language-en";
 var MIN_ZXCVBN_SCORE = 2;
-var zxcvbnInitialized = false;
-function ensureZxcvbn() {
-  if (zxcvbnInitialized) return;
-  zxcvbnOptions.setOptions({
+var zxcvbnInstance = null;
+function getZxcvbn() {
+  if (zxcvbnInstance) return zxcvbnInstance;
+  zxcvbnInstance = new ZxcvbnFactory({
     translations: zxcvbnEn.translations,
     graphs: zxcvbnCommon.adjacencyGraphs,
     dictionary: {
@@ -1772,11 +1796,10 @@ function ensureZxcvbn() {
       ...zxcvbnEn.dictionary
     }
   });
-  zxcvbnInitialized = true;
+  return zxcvbnInstance;
 }
 function validatePasswordStrength(password) {
-  ensureZxcvbn();
-  const result = zxcvbn(password);
+  const result = getZxcvbn().check(password);
   if (result.score < MIN_ZXCVBN_SCORE) {
     return {
       valid: false,
@@ -1790,6 +1813,29 @@ function buildMailTransport(config) {
   const env = process.env.NODE_ENV === "production" ? "production" : process.env.NODE_ENV === "test" ? "test" : "development";
   return createMailTransport(config.auth.mail.transportUrl, config.auth.mail.from, env);
 }
+async function createReplayableRequest(request) {
+  if (request.bodyUsed || request.method === "GET" || request.method === "HEAD") return request;
+  const body2 = await request.text();
+  const init = {
+    method: request.method,
+    headers: request.headers,
+    body: body2,
+    redirect: request.redirect,
+    referrer: request.referrer,
+    referrerPolicy: request.referrerPolicy,
+    integrity: request.integrity,
+    keepalive: request.keepalive,
+    credentials: request.credentials,
+    cache: request.cache,
+    mode: request.mode
+  };
+  const replayable = new Request(request.url, init);
+  Object.defineProperty(replayable, "clone", {
+    configurable: true,
+    value: () => new Request(request.url, init)
+  });
+  return replayable;
+}
 function createAuth(config, db, opts) {
   const transport = buildMailTransport(config);
   const telemetry = opts?.telemetry ?? noopTelemetry;
@@ -1848,7 +1894,7 @@ function createAuth(config, db, opts) {
       }
     } : {}
   };
-  return betterAuth({
+  const auth = betterAuth({
     database: drizzleAdapter(db, { provider: "pg", schema: schema_exports }),
     secret: config.auth.secret,
     baseURL: config.auth.url,
@@ -1953,6 +1999,9 @@ function createAuth(config, db, opts) {
     socialProviders,
     plugins
   });
+  const handler = auth.handler.bind(auth);
+  auth.handler = async (request) => handler(await createReplayableRequest(request));
+  return auth;
 }
 
 // src/server/auth/authHook.ts
@@ -2082,6 +2131,7 @@ var updateWorkspaceBody = z3.object({
 
 // src/server/routes/workspaces.ts
 var DEFAULT_WORKSPACE_NAME = "Default workspace";
+var COMPANY_CONTEXT_WORKSPACE_MANAGED_BY = "company-context";
 var workspaceRoutesPlugin = async (app) => {
   const store = app.workspaceStore;
   const provisioner = app.provisioner;
@@ -2235,6 +2285,23 @@ var workspaceRoutesPlugin = async (app) => {
     async (request) => {
       const { id } = request.params;
       request.log.info({ workspaceId: id }, "workspace.delete.start");
+      const workspace = await store.get(id);
+      if (!workspace) {
+        throw new HttpError({
+          status: 404,
+          code: ERROR_CODES.NOT_FOUND,
+          message: "Workspace not found",
+          requestId: request.id
+        });
+      }
+      if (workspace.managedBy === COMPANY_CONTEXT_WORKSPACE_MANAGED_BY) {
+        throw new HttpError({
+          status: 403,
+          code: ERROR_CODES.FORBIDDEN,
+          message: "Managed workspace cannot be deleted",
+          requestId: request.id
+        });
+      }
       if (provisioner) {
         try {
           await provisioner.destroy(id);

package/dist/{chunk-6ZY63QYN.js → chunk-EFM5IWTK.js}

@@ -13,13 +13,13 @@ function createDatabase(config) {
   if (!config.databaseUrl) {
     throw new Error("databaseUrl is required to create a database connection");
   }
-  const sql7 = postgres(config.databaseUrl, {
+  const sql8 = postgres(config.databaseUrl, {
     max: 10,
     idle_timeout: 20,
     connect_timeout: 10
   });
-  const db = drizzle(sql7);
-  return { db, sql: sql7 };
+  const db = drizzle(sql8);
+  return { db, sql: sql8 };
 }
 
 // src/server/db/migrate.ts
@@ -151,15 +151,19 @@ var LocalWorkspaceStore = class {
   wsSettings = /* @__PURE__ */ new Map();
   uiStates = /* @__PURE__ */ new Map();
   async create(userId, name, appId, opts) {
+    const id = opts?.id ?? randomUUID();
+    const existing = opts?.id ? this.workspaces.get(id) : void 0;
+    if (existing) return existing;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const ws = {
-      id: randomUUID(),
+      id,
       appId,
       name,
       createdBy: userId,
       createdAt: now,
       deletedAt: null,
-      isDefault: opts?.isDefault ?? false
+      isDefault: opts?.isDefault ?? false,
+      managedBy: opts?.managedBy ?? null
     };
     this.workspaces.set(ws.id, ws);
     const memberKey = `${ws.id}:${userId}`;
@@ -210,6 +214,16 @@ var LocalWorkspaceStore = class {
     if (!ws || ws.deletedAt) return null;
     return ws;
   }
+  async getIncludingDeleted(id) {
+    return this.workspaces.get(id) ?? null;
+  }
+  async restore(id) {
+    const ws = this.workspaces.get(id);
+    if (!ws) return null;
+    ws.deletedAt = null;
+    this.workspaces.set(id, ws);
+    return ws;
+  }
   async update(id, updates) {
     const ws = this.workspaces.get(id);
     if (!ws || ws.deletedAt) return null;
@@ -297,11 +311,11 @@ var LocalWorkspaceStore = class {
     this.members.set(key, updated);
     return { member: updated };
   }
-  async removeMember(workspaceId, userId) {
+  async removeMember(workspaceId, userId, opts) {
     const key = `${workspaceId}:${userId}`;
     const membership = this.members.get(key);
     if (!membership) return { removed: false, code: ERROR_CODES.NOT_MEMBER };
-    if (membership.role === "owner") {
+    if (!opts?.allowLastOwner && membership.role === "owner") {
       let otherOwnerExists = false;
       for (const m of this.members.values()) {
         if (m.workspaceId === workspaceId && m.userId !== userId && m.role === "owner") {
@@ -542,6 +556,7 @@ __export(schema_exports, {
   creditGrants: () => creditGrants,
   creditPurchases: () => creditPurchases,
   idempotencyKeys: () => idempotencyKeys,
+  modelBudgetReservations: () => modelBudgetReservations,
   sessions: () => sessions,
   sessionsRelations: () => sessionsRelations,
   telemetryEvents: () => telemetryEvents,
@@ -685,7 +700,8 @@ var workspaces = pgTable2(
     createdBy: uuid2("created_by").notNull().references(() => users.id),
     createdAt: timestamp2("created_at").defaultNow().notNull(),
     deletedAt: timestamp2("deleted_at"),
-    isDefault: boolean2("is_default").notNull().default(false)
+    isDefault: boolean2("is_default").notNull().default(false),
+    managedBy: text2("managed_by")
   },
   (table) => [
     index2("workspaces_created_by_idx").on(table.createdBy),
@@ -952,6 +968,33 @@ var usageReservations = pgTable2(
     )
   ]
 );
+var modelBudgetReservations = pgTable2(
+  "boring_model_budget_reservations",
+  {
+    id: uuid2("id").default(sql3`gen_random_uuid()`).primaryKey(),
+    userId: text2("user_id").notNull(),
+    workspaceId: text2("workspace_id"),
+    sessionId: text2("session_id"),
+    runId: text2("run_id").notNull(),
+    provider: text2("provider").notNull(),
+    model: text2("model").notNull(),
+    period: text2("period").notNull(),
+    amountMicros: bigint("amount_micros", { mode: "number" }).notNull(),
+    status: text2("status").notNull().default("active"),
+    createdAt: timestamp2("created_at").defaultNow().notNull(),
+    expiresAt: timestamp2("expires_at").notNull()
+  },
+  (table) => [
+    uniqueIndex("boring_model_budget_reservations_active_user_run_idx").on(table.userId, table.runId).where(sql3`${table.status} = 'active'`),
+    index2("boring_model_budget_reservations_budget_idx").on(table.userId, table.provider, table.model, table.period, table.status),
+    index2("boring_model_budget_reservations_stale_idx").on(table.status, table.expiresAt),
+    check("boring_model_budget_reservations_amount_check", sql3`${table.amountMicros} > 0`),
+    check(
+      "boring_model_budget_reservations_status_check",
+      sql3`${table.status} IN ('active', 'settled', 'released', 'expired')`
+    )
+  ]
+);
 var usageLedger = pgTable2(
   "boring_usage_ledger",
   {
@@ -1095,7 +1138,8 @@ function toWorkspace(row) {
     createdBy: row.createdBy,
     createdAt: row.createdAt.toISOString(),
     deletedAt: row.deletedAt?.toISOString() ?? null,
-    isDefault: row.isDefault
+    isDefault: row.isDefault,
+    managedBy: row.managedBy
   };
 }
 var PostgresWorkspaceStore = class {
@@ -1117,12 +1161,24 @@ var PostgresWorkspaceStore = class {
   // ---------------------------------------------------------------------------
   async create(userId, name, appId, opts) {
     return this.db.transaction(async (tx) => {
-      const [row] = await tx.insert(workspaces).values({ appId, name, createdBy: userId, isDefault: opts?.isDefault ?? false }).returning();
-      await tx.insert(workspaceMembers).values({
-        workspaceId: row.id,
-        userId,
-        role: "owner"
+      const insert = tx.insert(workspaces).values({
+        ...opts?.id ? { id: opts.id } : {},
+        appId,
+        name,
+        createdBy: userId,
+        isDefault: opts?.isDefault ?? false,
+        managedBy: opts?.managedBy ?? null
       });
+      const insertedRows = opts?.id ? await insert.onConflictDoNothing().returning() : await insert.returning();
+      const row = insertedRows[0] ?? (opts?.id ? (await tx.select().from(workspaces).where(eq(workspaces.id, opts.id)).limit(1))[0] : void 0);
+      if (!row) throw new Error(`Workspace ${opts?.id ?? name} was not created`);
+      if (insertedRows.length > 0) {
+        await tx.insert(workspaceMembers).values({
+          workspaceId: row.id,
+          userId,
+          role: "owner"
+        });
+      }
       return toWorkspace(row);
     });
   }
@@ -1140,6 +1196,14 @@ var PostgresWorkspaceStore = class {
     const rows = await this.db.select().from(workspaces).where(and(eq(workspaces.id, id), isNull(workspaces.deletedAt))).limit(1);
     return rows.length > 0 ? toWorkspace(rows[0]) : null;
   }
+  async getIncludingDeleted(id) {
+    const rows = await this.db.select().from(workspaces).where(eq(workspaces.id, id)).limit(1);
+    return rows.length > 0 ? toWorkspace(rows[0]) : null;
+  }
+  async restore(id) {
+    const rows = await this.db.update(workspaces).set({ deletedAt: null }).where(eq(workspaces.id, id)).returning();
+    return rows.length > 0 ? toWorkspace(rows[0]) : null;
+  }
   async update(id, updates) {
     const rows = await this.db.update(workspaces).set(updates).where(and(eq(workspaces.id, id), isNull(workspaces.deletedAt))).returning();
     return rows.length > 0 ? toWorkspace(rows[0]) : null;
@@ -1253,7 +1317,7 @@ var PostgresWorkspaceStore = class {
       return { member: toWorkspaceMember(updated) };
     });
   }
-  async removeMember(workspaceId, userId) {
+  async removeMember(workspaceId, userId, opts) {
     return this.db.transaction(async (tx) => {
       await tx.execute(sql4`
         SELECT user_id
@@ -1270,7 +1334,7 @@ var PostgresWorkspaceStore = class {
       ).limit(1);
       const role = memberRows[0]?.role;
       if (!role) return { removed: false, code: ERROR_CODES.NOT_MEMBER };
-      if (role === "owner") {
+      if (!opts?.allowLastOwner && role === "owner") {
         const [{ count }] = await tx.select({ count: sql4`count(*)::int` }).from(workspaceMembers).where(
           and(
             eq(workspaceMembers.workspaceId, workspaceId),
@@ -2388,6 +2452,265 @@ function describeUsage(source) {
   return { kind: "usage", description: "Agent usage" };
 }
 
+// src/server/db/stores/PostgresModelBudgetStore.ts
+import { and as and3, eq as eq4, inArray as inArray2, lt as lt2, or as or2, sql as sql7 } from "drizzle-orm";
+var ModelBudgetExceededError = class extends Error {
+  constructor(usedMicros, heldMicros, budgetMicros, requestedMicros) {
+    super("Budget reached for this model.");
+    this.usedMicros = usedMicros;
+    this.heldMicros = heldMicros;
+    this.budgetMicros = budgetMicros;
+    this.requestedMicros = requestedMicros;
+    this.name = "ModelBudgetExceededError";
+  }
+  usedMicros;
+  heldMicros;
+  budgetMicros;
+  requestedMicros;
+  statusCode = 402;
+  code = "MODEL_BUDGET_EXCEEDED";
+};
+var UPDATE_ID_BATCH_SIZE = 1e3;
+function assertPositiveSafeInteger(name, value) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`${name} must be a positive safe integer`);
+}
+function monthPeriodUtc(now) {
+  const year = now.getUTCFullYear();
+  const month = now.getUTCMonth();
+  return {
+    period: `${year}-${String(month + 1).padStart(2, "0")}`,
+    start: new Date(Date.UTC(year, month, 1, 0, 0, 0, 0)),
+    end: new Date(Date.UTC(year, month + 1, 1, 0, 0, 0, 0))
+  };
+}
+function requireFinishKey(input) {
+  if (input.reservationId) return eq4(modelBudgetReservations.id, input.reservationId);
+  if (!input.runId || !input.userId) throw new Error("finish requires reservationId or runId+userId");
+  return and3(eq4(modelBudgetReservations.runId, input.runId), eq4(modelBudgetReservations.userId, input.userId));
+}
+function chunkIds(ids) {
+  const chunks = [];
+  for (let index3 = 0; index3 < ids.length; index3 += UPDATE_ID_BATCH_SIZE) {
+    chunks.push(ids.slice(index3, index3 + UPDATE_ID_BATCH_SIZE));
+  }
+  return chunks;
+}
+function modelBudgetAdvisoryLockKey(target) {
+  return `model-budget:${target.userId}:${target.provider}:${target.model}:${target.period}`;
+}
+async function lockModelBudgetTargets(executor, targets) {
+  const keys = Array.from(new Set(targets.map(modelBudgetAdvisoryLockKey))).sort();
+  for (const key of keys) {
+    await executor.execute(sql7`SELECT pg_advisory_xact_lock(hashtext(${key}))`);
+  }
+}
+var PostgresModelBudgetStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  static monthPeriodUtc(now = /* @__PURE__ */ new Date()) {
+    return monthPeriodUtc(now).period;
+  }
+  async sweepExpired(now = /* @__PURE__ */ new Date()) {
+    return this.db.transaction(async (tx) => {
+      const expired = await tx.select({
+        id: modelBudgetReservations.id,
+        userId: modelBudgetReservations.userId,
+        provider: modelBudgetReservations.provider,
+        model: modelBudgetReservations.model,
+        period: modelBudgetReservations.period
+      }).from(modelBudgetReservations).where(and3(eq4(modelBudgetReservations.status, "active"), lt2(modelBudgetReservations.expiresAt, now)));
+      if (expired.length === 0) return 0;
+      await lockModelBudgetTargets(tx, expired);
+      let count = 0;
+      for (const ids of chunkIds(expired.map((row) => row.id))) {
+        const rows = await tx.update(modelBudgetReservations).set({ status: "expired" }).where(and3(
+          inArray2(modelBudgetReservations.id, ids),
+          eq4(modelBudgetReservations.status, "active"),
+          lt2(modelBudgetReservations.expiresAt, now)
+        )).returning({ id: modelBudgetReservations.id });
+        count += rows.length;
+      }
+      return count;
+    });
+  }
+  async reserve(input) {
+    if (!input.userId) throw new Error("reserve requires userId");
+    if (!input.provider || !input.model) throw new Error("reserve requires provider/model");
+    assertPositiveSafeInteger("budgetMicros", input.budgetMicros);
+    assertPositiveSafeInteger("holdMicros", input.holdMicros);
+    if (!Number.isSafeInteger(input.ttlSeconds) || input.ttlSeconds <= 0) throw new Error("ttlSeconds must be a positive safe integer");
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    const period = monthPeriodUtc(now);
+    const expiresAt = new Date(now.getTime() + input.ttlSeconds * 1e3);
+    return this.db.transaction(async (tx) => {
+      const expired = await tx.select({
+        id: modelBudgetReservations.id,
+        userId: modelBudgetReservations.userId,
+        provider: modelBudgetReservations.provider,
+        model: modelBudgetReservations.model,
+        period: modelBudgetReservations.period
+      }).from(modelBudgetReservations).where(and3(
+        eq4(modelBudgetReservations.status, "active"),
+        lt2(modelBudgetReservations.expiresAt, now),
+        or2(
+          and3(
+            eq4(modelBudgetReservations.userId, input.userId),
+            eq4(modelBudgetReservations.provider, input.provider),
+            eq4(modelBudgetReservations.model, input.model),
+            eq4(modelBudgetReservations.period, period.period)
+          ),
+          and3(
+            eq4(modelBudgetReservations.userId, input.userId),
+            eq4(modelBudgetReservations.runId, input.runId)
+          )
+        )
+      ));
+      await lockModelBudgetTargets(tx, [
+        { userId: input.userId, provider: input.provider, model: input.model, period: period.period },
+        ...expired
+      ]);
+      for (const ids of chunkIds(expired.map((row) => row.id))) {
+        await tx.update(modelBudgetReservations).set({ status: "expired" }).where(and3(
+          inArray2(modelBudgetReservations.id, ids),
+          eq4(modelBudgetReservations.status, "active"),
+          lt2(modelBudgetReservations.expiresAt, now)
+        ));
+      }
+      const existing = await tx.select({
+        id: modelBudgetReservations.id,
+        provider: modelBudgetReservations.provider,
+        model: modelBudgetReservations.model,
+        period: modelBudgetReservations.period
+      }).from(modelBudgetReservations).where(and3(
+        eq4(modelBudgetReservations.status, "active"),
+        eq4(modelBudgetReservations.userId, input.userId),
+        eq4(modelBudgetReservations.runId, input.runId)
+      )).limit(1);
+      const prior = existing[0];
+      if (prior) {
+        if (prior.provider !== input.provider || prior.model !== input.model || prior.period !== period.period) {
+          throw new Error(`active model budget reservation for run ${input.runId} has conflicting tuple`);
+        }
+        return { reservationId: prior.id, created: false, period: period.period };
+      }
+      const periodStartIso = period.start.toISOString();
+      const periodEndIso = period.end.toISOString();
+      const usageRows = await tx.execute(sql7`
+        SELECT COALESCE(SUM(${usageLedger.billedCostMicros}), 0)::text AS total
+        FROM ${usageLedger}
+        WHERE ${usageLedger.userId} = ${input.userId}
+          AND ${usageLedger.provider} = ${input.provider}
+          AND ${usageLedger.model} = ${input.model}
+          AND (
+            (
+              EXISTS (
+                SELECT 1 FROM ${modelBudgetReservations} r
+                WHERE r.user_id = ${usageLedger.userId}
+                  AND r.provider = ${usageLedger.provider}
+                  AND r.model = ${usageLedger.model}
+                  AND r.run_id = ${usageLedger.runId}
+                  AND r.period = ${period.period}
+                  AND r.status NOT IN ('active', 'settled')
+                  AND (
+                    ${usageLedger.metadata}->>'modelBudgetReservationId' = r.id::text
+                    OR (
+                      ${usageLedger.metadata}->>'modelBudgetReservationId' IS NULL
+                      AND r.created_at <= ${usageLedger.createdAt}
+                      AND NOT EXISTS (
+                        SELECT 1 FROM ${modelBudgetReservations} newer
+                        WHERE newer.user_id = r.user_id
+                          AND newer.provider = r.provider
+                          AND newer.model = r.model
+                          AND newer.run_id = r.run_id
+                          AND newer.created_at <= ${usageLedger.createdAt}
+                          AND (
+                            newer.created_at > r.created_at
+                            OR (newer.created_at = r.created_at AND newer.id > r.id)
+                          )
+                      )
+                    )
+                  )
+              )
+            )
+            OR (
+              ${usageLedger.createdAt} >= ${periodStartIso}::timestamp
+              AND ${usageLedger.createdAt} < ${periodEndIso}::timestamp
+              AND ${usageLedger.metadata}->>'modelBudgetReservationId' IS NULL
+              AND NOT EXISTS (
+                SELECT 1 FROM ${modelBudgetReservations} r
+                WHERE r.user_id = ${usageLedger.userId}
+                  AND r.provider = ${usageLedger.provider}
+                  AND r.model = ${usageLedger.model}
+                  AND r.run_id = ${usageLedger.runId}
+                  AND r.created_at <= ${usageLedger.createdAt}
+              )
+            )
+          )
+      `);
+      const heldRows = await tx.execute(sql7`
+        SELECT COALESCE(SUM(amount_micros), 0)::text AS total
+        FROM ${modelBudgetReservations}
+        WHERE status = 'active'
+          AND user_id = ${input.userId}
+          AND provider = ${input.provider}
+          AND model = ${input.model}
+          AND period = ${period.period}
+      `);
+      const settledFallbackRows = await tx.execute(sql7`
+        SELECT COALESCE(SUM(amount_micros), 0)::text AS total
+        FROM ${modelBudgetReservations}
+        WHERE status = 'settled'
+          AND user_id = ${input.userId}
+          AND provider = ${input.provider}
+          AND model = ${input.model}
+          AND period = ${period.period}
+      `);
+      const usedMicros = Number(usageRows[0]?.total ?? 0) + Number(settledFallbackRows[0]?.total ?? 0);
+      const heldMicros = Number(heldRows[0]?.total ?? 0);
+      if (usedMicros + heldMicros + input.holdMicros > input.budgetMicros) {
+        throw new ModelBudgetExceededError(usedMicros, heldMicros, input.budgetMicros, input.holdMicros);
+      }
+      const inserted = await tx.insert(modelBudgetReservations).values({
+        userId: input.userId,
+        workspaceId: input.workspaceId ?? null,
+        sessionId: input.sessionId ?? null,
+        runId: input.runId,
+        provider: input.provider,
+        model: input.model,
+        period: period.period,
+        amountMicros: input.holdMicros,
+        expiresAt
+      }).returning({ id: modelBudgetReservations.id });
+      return { reservationId: inserted[0].id, created: true, period: period.period };
+    });
+  }
+  async settle(input) {
+    await this.finish(input, "settled");
+  }
+  async release(input) {
+    await this.finish(input, "released");
+  }
+  async finish(input, status) {
+    await this.db.transaction(async (tx) => {
+      const active = await tx.select({
+        id: modelBudgetReservations.id,
+        userId: modelBudgetReservations.userId,
+        provider: modelBudgetReservations.provider,
+        model: modelBudgetReservations.model,
+        period: modelBudgetReservations.period
+      }).from(modelBudgetReservations).where(and3(requireFinishKey(input), eq4(modelBudgetReservations.status, "active")));
+      if (active.length === 0) return;
+      await lockModelBudgetTargets(tx, active);
+      await tx.update(modelBudgetReservations).set({ status }).where(and3(
+        inArray2(modelBudgetReservations.id, active.map((row) => row.id)),
+        eq4(modelBudgetReservations.status, "active")
+      ));
+    });
+  }
+};
+
 export {
   users,
   verification_tokens,
@@ -2410,5 +2733,7 @@ export {
   PostgresWorkspaceStore,
   PostgresUserStore,
   InsufficientCreditError,
-  PostgresMeteringStore
+  PostgresMeteringStore,
+  ModelBudgetExceededError,
+  PostgresModelBudgetStore
 };

package/dist/{connection-B5wXGP69.d.ts → connection-D9s7Td0I.d.ts}

@@ -1,4 +1,4 @@
-import { C as CoreConfig, c as Workspace, E as ERROR_CODES, M as MemberRole, d as WorkspaceMember, U as User, e as WorkspaceInvite, f as WorkspaceRuntime, W as WorkspaceRuntimeResourceSelector, a as WorkspaceRuntimeResource, b as WorkspaceRuntimeResourceInput, g as CapabilitiesResponse } from './types-Bb7I-83I.js';
+import { C as CoreConfig, c as Workspace, E as ERROR_CODES, M as MemberRole, d as WorkspaceMember, U as User, e as WorkspaceInvite, f as WorkspaceRuntime, W as WorkspaceRuntimeResourceSelector, a as WorkspaceRuntimeResource, b as WorkspaceRuntimeResourceInput, g as CapabilitiesResponse } from './types-DVgeIw1d.js';
 import { drizzle } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
 
@@ -54,9 +54,13 @@ interface UserStore {
 interface WorkspaceStore {
     create(userId: string, name: string, appId: string, opts?: {
         isDefault?: boolean;
+        id?: string;
+        managedBy?: string;
     }): Promise<Workspace>;
     list(userId: string, appId: string): Promise<Workspace[]>;
     get(id: string): Promise<Workspace | null>;
+    getIncludingDeleted(id: string): Promise<Workspace | null>;
+    restore(id: string): Promise<Workspace | null>;
     update(id: string, updates: Partial<Pick<Workspace, 'name'>>): Promise<Workspace | null>;
     delete(id: string): Promise<{
         removed: boolean;
@@ -73,7 +77,9 @@ interface WorkspaceStore {
         member?: WorkspaceMember;
         code?: typeof ERROR_CODES.LAST_OWNER | typeof ERROR_CODES.NOT_MEMBER;
     }>;
-    removeMember(workspaceId: string, userId: string): Promise<{
+    removeMember(workspaceId: string, userId: string, opts?: {
+        allowLastOwner?: boolean;
+    }): Promise<{
         removed: boolean;
         code?: typeof ERROR_CODES.LAST_OWNER | typeof ERROR_CODES.NOT_MEMBER;
     }>;