@hachej/boring-core 0.1.63 → 0.1.65

package/dist/{chunk-BVZ2YT3M.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),
@@ -1711,6 +1775,22 @@ import { eq as eq2, sql as sql5 } from "drizzle-orm";
 function normalizeEmail2(email) {
   return email.trim().toLowerCase();
 }
+function jsonbPath(path) {
+  return sql5`ARRAY[${sql5.join(path.map((part) => sql5`${part}`), sql5`, `)}]::text[]`;
+}
+function jsonbSetPathExpression(path, value) {
+  let expression = sql5`${userSettings.settings}`;
+  for (let i = 1; i < path.length; i += 1) {
+    const prefixPath = jsonbPath(path.slice(0, i));
+    const existingObject = sql5`CASE
+      WHEN jsonb_typeof(${userSettings.settings} #> ${prefixPath}) = 'object'
+      THEN ${userSettings.settings} #> ${prefixPath}
+      ELSE '{}'::jsonb
+    END`;
+    expression = sql5`jsonb_set(${expression}, ${prefixPath}, ${existingObject}, true)`;
+  }
+  return sql5`jsonb_set(${expression}, ${jsonbPath(path)}, ${JSON.stringify(value)}::jsonb, true)`;
+}
 function rowToUser(row) {
   return {
     id: row.id,
@@ -1797,6 +1877,60 @@ var PostgresUserStore = class {
       settings: rows[0].settings ?? {}
     };
   }
+  async putClientUserSettings(userId, appId, updates) {
+    if (!updates.settings) return await this.putUserSettings(userId, appId, { displayName: updates.displayName });
+    const current = await this.getUserSettings(userId, appId);
+    const clientSettings = Object.fromEntries(
+      Object.entries(updates.settings).filter(([key]) => !key.startsWith("__server"))
+    );
+    const nextDisplayName = updates.displayName ?? current.displayName;
+    const nextEmail = current.email;
+    const rows = await this.db.insert(userSettings).values({
+      userId,
+      appId,
+      displayName: nextDisplayName,
+      email: nextEmail,
+      settings: clientSettings
+    }).onConflictDoUpdate({
+      target: [userSettings.userId, userSettings.appId],
+      set: {
+        displayName: nextDisplayName,
+        settings: sql5`(
+            SELECT COALESCE(jsonb_object_agg(key, value), '{}'::jsonb)
+            FROM jsonb_each(${userSettings.settings})
+            WHERE left(key, 8) = '__server'
+          ) || ${JSON.stringify(clientSettings)}::jsonb`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    }).returning();
+    return {
+      displayName: rows[0].displayName,
+      email: rows[0].email,
+      settings: rows[0].settings ?? {}
+    };
+  }
+  async patchUserSettingsJsonPath(userId, appId, path, value) {
+    if (path.length === 0) throw new Error("settings JSON path must not be empty");
+    const user = await this.getById(userId);
+    const rows = await this.db.transaction(async (tx) => {
+      await tx.insert(userSettings).values({
+        userId,
+        appId,
+        displayName: user?.name ?? "",
+        email: user?.email ?? "",
+        settings: {}
+      }).onConflictDoNothing({ target: [userSettings.userId, userSettings.appId] });
+      return await tx.update(userSettings).set({
+        settings: jsonbSetPathExpression(path, value),
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(sql5`${userSettings.userId} = ${userId} AND ${userSettings.appId} = ${appId}`).returning();
+    });
+    return {
+      displayName: rows[0].displayName,
+      email: rows[0].email,
+      settings: rows[0].settings ?? {}
+    };
+  }
 };
 
 // src/server/db/stores/PostgresMeteringStore.ts
@@ -2318,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,
@@ -2340,5 +2733,7 @@ export {
   PostgresWorkspaceStore,
   PostgresUserStore,
   InsufficientCreditError,
-  PostgresMeteringStore
+  PostgresMeteringStore,
+  ModelBudgetExceededError,
+  PostgresModelBudgetStore
 };

package/dist/{connection-B1iC6B-w.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';
 
@@ -37,13 +37,30 @@ interface UserStore {
         email: string;
         settings: Record<string, unknown>;
     }>;
+    putClientUserSettings?(userId: string, appId: string, updates: {
+        displayName?: string;
+        settings?: Record<string, unknown>;
+    }): Promise<{
+        displayName: string;
+        email: string;
+        settings: Record<string, unknown>;
+    }>;
+    patchUserSettingsJsonPath?(userId: string, appId: string, path: string[], value: unknown): Promise<{
+        displayName: string;
+        email: string;
+        settings: Record<string, unknown>;
+    }>;
 }
 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;
@@ -60,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;
     }>;