@opengeni/db 6.2.0-canary.36855269964001 → 6.2.0

package/dist/canonical-human-identities.js

@@ -11,9 +11,9 @@ import {
   getCanonicalHumanIdentityProjection,
   synchronizeCanonicalHumanLoginBindings,
   validateCanonicalHumanSession
-} from "./chunk-AF5VZI4C.js";
-import "./chunk-WAOVZEDU.js";
-import "./chunk-JPH5OE3M.js";
+} from "./chunk-73ZUIXCL.js";
+import "./chunk-RTVDWDBS.js";
+import "./chunk-VHPOPKEZ.js";
 import "./chunk-S2TZ3F4L.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/capability-reconciliation.js

@@ -1,7 +1,7 @@
 import {
   withWorkspaceRls
-} from "./chunk-WAOVZEDU.js";
-import "./chunk-JPH5OE3M.js";
+} from "./chunk-RTVDWDBS.js";
+import "./chunk-VHPOPKEZ.js";
 import "./chunk-S2TZ3F4L.js";
 import "./chunk-PZ5AY32C.js";
 

package/dist/{chunk-LNXRHVDB.js → chunk-3I4SGUQX.js}

@@ -1,12 +1,8 @@
-import {
-  external_exports
-} from "./chunk-4UJCXBR2.js";
 import {
   rawRows,
-  setSubjectRlsContext,
   withRlsContext,
   withWorkspaceRls
-} from "./chunk-WAOVZEDU.js";
+} from "./chunk-RTVDWDBS.js";
 import {
   connections,
   creditLedgerEntries,
@@ -18,7 +14,7 @@ import {
   workspaceVideoGenerationPolicies,
   workspaceVideoGenerationQuotas,
   workspaces
-} from "./chunk-JPH5OE3M.js";
+} from "./chunk-VHPOPKEZ.js";
 
 // src/video-generation.ts
 import {
@@ -30,295 +26,7 @@ import {
   VideoGenerationOperationSummary,
   retainedGeneratedVideoReferenceFromFile
 } from "@opengeni/contracts";
-import { and, eq, inArray, sql as sql3 } from "drizzle-orm";
-
-// src/usage-allowances.ts
-import { sql as sql2 } from "drizzle-orm";
-
-// src/credit-debit-attribution.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { sql } from "drizzle-orm";
-var creditDebitAttributionContext = new AsyncLocalStorage();
-function currentCreditDebitAttribution() {
-  return creditDebitAttributionContext.getStore() ?? { kind: "unknown" };
-}
-function withCreditDebitAttribution(attribution, fn) {
-  return creditDebitAttributionContext.run(
-    Object.freeze(CreditDebitAttribution.parse(attribution)),
-    fn
-  );
-}
-async function creditDebitAttributionForTurn(db, input) {
-  return withRlsContext(db, input, async (tx) => {
-    const [turn] = await rawRows(
-      tx,
-      sql`SELECT initiating_human_subject_id AS "initiatingHumanSubjectId"
-        FROM session_turns WHERE account_id=${input.accountId}::uuid
-          AND workspace_id=${input.workspaceId}::uuid AND id=${input.turnId}::uuid`
-    );
-    if (!turn) throw new Error("Paid credit debit initiating turn is unavailable");
-    return CreditDebitAttribution.parse({
-      kind: "turn",
-      turnId: input.turnId,
-      initiatingHumanSubjectId: turn.initiatingHumanSubjectId
-    });
-  });
-}
-var CreditDebitAttribution = external_exports.discriminatedUnion("kind", [
-  external_exports.object({
-    kind: external_exports.literal("turn"),
-    turnId: external_exports.uuid(),
-    initiatingHumanSubjectId: external_exports.string().min(1).max(1024).nullable()
-  }),
-  external_exports.object({
-    kind: external_exports.literal("human"),
-    initiatingHumanSubjectId: external_exports.string().min(1).max(1024)
-  }),
-  external_exports.object({ kind: external_exports.literal("service") }),
-  external_exports.object({ kind: external_exports.literal("unknown") })
-]);
-function creditDebitAttributionMetadata(attribution) {
-  switch (attribution.kind) {
-    case "turn":
-      return {
-        turnId: attribution.turnId,
-        ...attribution.initiatingHumanSubjectId ? { initiatingHumanSubjectId: attribution.initiatingHumanSubjectId } : {}
-      };
-    case "human":
-      return { initiatingHumanSubjectId: attribution.initiatingHumanSubjectId };
-    case "service":
-      return {};
-    case "unknown":
-      throw new Error("Paid credit debit has no frozen initiating attribution");
-  }
-}
-
-// src/usage-allowances.ts
-var UsageAllowanceVersionConflictError = class extends Error {
-  constructor() {
-    super("Usage allowance version conflict");
-    this.name = "UsageAllowanceVersionConflictError";
-  }
-};
-function amount(value, name, positive = false) {
-  if (!Number.isSafeInteger(value) || value < (positive ? 1 : 0)) {
-    throw new Error(
-      `${name} must be ${positive ? "a positive" : "a non-negative"} safe integer in USD micros`
-    );
-  }
-}
-function validateMemberAllowanceRule(rule) {
-  if (rule === null) return;
-  if ("credits" in rule) {
-    if (Object.keys(rule).length !== 1)
-      throw new Error("Member rule must have only credits or share");
-    amount(rule.credits, "credits");
-  } else if ("share" in rule) {
-    if (Object.keys(rule).length !== 1 || !Number.isFinite(rule.share) || rule.share < 0) {
-      throw new Error("share must be a finite non-negative number");
-    }
-  } else {
-    throw new Error("Member rule must have credits or share");
-  }
-}
-function validateWorkspaceAllowanceConfig(config) {
-  amount(config.includedCredits, "includedCredits");
-  if (config.period !== "monthly" && config.period !== "none")
-    throw new Error("Invalid allowance period");
-  if (config.anchorDay !== void 0 && (!Number.isInteger(config.anchorDay) || config.anchorDay < 1 || config.anchorDay > 31)) {
-    throw new Error("anchorDay must be an integer from 1 to 31");
-  }
-  if (config.memberDefault !== void 0 && config.memberDefault !== "none" && config.memberDefault !== "equal_share") {
-    validateMemberAllowanceRule(config.memberDefault);
-  }
-  for (const list of [config.thresholds?.workspace, config.thresholds?.member]) {
-    if (list !== void 0 && (list.length > 16 || list.some((threshold) => !Number.isFinite(threshold) || threshold <= 0 || threshold > 1))) {
-      throw new Error(
-        "thresholds must contain at most 16 fractions greater than zero and at most one"
-      );
-    }
-  }
-}
-async function command(db, input) {
-  if (["set", "clear", "member", "grant"].includes(String(input.action)) && currentCreditDebitAttribution().kind === "turn") {
-    throw new Error("Agent attempts cannot change usage allowances");
-  }
-  try {
-    const mutation = ["set", "clear", "member", "grant"].includes(String(input.action));
-    return await withRlsContext(
-      db,
-      input,
-      async (scoped) => {
-        if (mutation) {
-          await scoped.execute(sql2`select pg_advisory_xact_lock(
-          hashtextextended(${`organization-membership:${input.accountId}`},0))`);
-          await scoped.execute(sql2`select pg_advisory_xact_lock_shared(
-          hashtextextended(${`session-tenancy:${input.workspaceId}`},0))`);
-        }
-        if (typeof input.actorSubjectId === "string")
-          await setSubjectRlsContext(scoped, input.actorSubjectId);
-        const [row] = await rawRows(
-          scoped,
-          sql2`select usage_allowance_command(${JSON.stringify(input)}::jsonb) as result`
-        );
-        if (!row) throw new Error("Usage allowance command returned no result");
-        return row.result;
-      },
-      void 0,
-      mutation ? "none" : "shared"
-    );
-  } catch (error) {
-    const cause = error;
-    if ((cause.code ?? cause.cause?.code) === "40001")
-      throw new UsageAllowanceVersionConflictError();
-    throw error;
-  }
-}
-function actor(input) {
-  return { actorSubjectId: input.actorSubjectId, actorType: input.actorType ?? "subject" };
-}
-function version(value) {
-  amount(value, "expectedVersion");
-}
-async function getWorkspaceAllowance(db, input) {
-  return await command(db, { ...input, action: "get" });
-}
-async function getWorkspaceAllowanceState(db, input) {
-  return await command(db, { ...input, action: "state" });
-}
-async function setWorkspaceAllowance(db, input) {
-  const { accountId, workspaceId, expectedVersion, actorSubjectId, actorType } = input;
-  const config = {
-    includedCredits: input.includedCredits,
-    period: input.period,
-    ...input.anchorDay === void 0 ? {} : { anchorDay: input.anchorDay },
-    ...input.memberDefault === void 0 ? {} : { memberDefault: input.memberDefault },
-    ...input.thresholds === void 0 ? {} : { thresholds: input.thresholds }
-  };
-  version(expectedVersion);
-  validateWorkspaceAllowanceConfig(config);
-  return await command(db, {
-    accountId,
-    workspaceId,
-    expectedVersion,
-    ...actor({ actorSubjectId, actorType }),
-    action: "set",
-    config
-  });
-}
-async function clearWorkspaceAllowance(db, input) {
-  version(input.expectedVersion);
-  if (input.expectedVersion === 0) throw new UsageAllowanceVersionConflictError();
-  if (input.operationId !== void 0 && (!input.operationId.trim() || new TextEncoder().encode(input.operationId).length > 256))
-    throw new Error("operationId must be non-empty and at most 256 bytes");
-  return await command(db, { ...input, ...actor(input), action: "clear" });
-}
-async function grantWorkspaceCredits(db, input) {
-  amount(input.credits, "credits", true);
-  if (!input.operationId.trim() || new TextEncoder().encode(input.operationId).length > 256) {
-    throw new Error("operationId must be non-empty and at most 256 bytes");
-  }
-  if (input.expiresAt != null && !Number.isFinite(Date.parse(input.expiresAt)))
-    throw new Error("Invalid grant expiresAt");
-  return await command(db, {
-    ...input,
-    ...actor(input),
-    expiresAt: input.expiresAt ?? null,
-    action: "grant"
-  });
-}
-async function setMemberAllowance(db, input) {
-  version(input.expectedVersion);
-  validateMemberAllowanceRule(input.rule);
-  return await command(db, { ...input, ...actor(input), action: "member" });
-}
-function allowanceUsage(limit, used, resetsAt, thresholds = [0.8, 1]) {
-  const fraction = limit === null ? null : limit === 0 ? 1 : used / limit;
-  const remaining = limit === null ? null : Math.max(0, limit - used);
-  return {
-    limit,
-    used,
-    remaining,
-    fraction,
-    status: remaining === 0 ? "exhausted" : fraction !== null && thresholds.some((t) => fraction >= t) ? "warning" : "ok",
-    resetsAt
-  };
-}
-async function getWorkspaceUsage(db, input) {
-  if (input.period !== void 0 && input.period !== "current" && !/^\d{4}-(0[1-9]|1[0-2])$/.test(input.period)) {
-    throw new Error("period must be current or YYYY-MM");
-  }
-  const pageSize = Math.min(500, Math.max(1, Math.trunc(input.limit ?? 100)));
-  const raw = await command(db, { ...input, limit: pageSize, action: "usage" });
-  return projectUsage(raw, pageSize);
-}
-function projectUsage(raw, pageSize) {
-  const config = raw.config;
-  const pool = config ? config.includedCredits + Number(raw.grantsUsed) + Number(raw.grantsRemaining) : null;
-  const memberPool = config ? config.includedCredits + Number(raw.grantsRemaining) : null;
-  const resetsAt = config ? raw.period.end : null;
-  const members = raw.members.slice(0, pageSize).map((member) => {
-    let rule = member.rule;
-    if (rule === null) {
-      const fallback = config?.memberDefault ?? "none";
-      rule = fallback === "none" ? null : fallback === "equal_share" ? { share: raw.memberCount > 0 ? 1 / Number(raw.memberCount) : 0 } : fallback;
-    }
-    const limit = rule === null ? null : "credits" in rule ? rule.credits : memberPool === null ? null : Math.min(Number.MAX_SAFE_INTEGER, Math.floor(memberPool * rule.share));
-    return {
-      ...member,
-      rule: member.rule,
-      ...allowanceUsage(limit, Number(member.used), resetsAt, config?.thresholds?.member)
-    };
-  });
-  return {
-    period: config ? raw.period : { start: null, end: null },
-    workspace: {
-      ...allowanceUsage(pool, Number(raw.used), resetsAt, config?.thresholds?.workspace),
-      includedCredits: config?.includedCredits ?? 0,
-      grantsRemaining: Number(raw.grantsRemaining)
-    },
-    members,
-    nextCursor: raw.members.length > pageSize ? members.at(-1).subjectId : null
-  };
-}
-async function checkWorkspaceAllowance(db, input) {
-  const raw = await command(db, {
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    ...input.subjectId ? { subjectId: input.subjectId } : {},
-    limit: 1,
-    action: "check"
-  });
-  const usage = projectUsage(raw, 1);
-  if (usage.workspace.status === "exhausted") {
-    return {
-      code: "allowance_exhausted",
-      scope: "workspace",
-      resetsAt: usage.workspace.resetsAt,
-      message: "The workspace usage allowance is exhausted."
-    };
-  }
-  const member = input.subjectId ? usage.members.find((row) => row.subjectId === input.subjectId) : null;
-  if (member?.status === "exhausted") {
-    return {
-      code: "allowance_exhausted",
-      scope: "member",
-      subjectId: member.subjectId,
-      resetsAt: member.resetsAt,
-      message: "The member usage allowance is exhausted."
-    };
-  }
-  return null;
-}
-async function maintainWorkspaceAllowances(db, input = {}) {
-  const [row] = await rawRows(
-    db,
-    sql2`select maintain_usage_allowances(${input.limit ?? 20}::integer,${input.memberLimit ?? 100}::integer) as processed`
-  );
-  return Number(row?.processed ?? 0);
-}
-
-// src/video-generation.ts
+import { and, eq, inArray, sql } from "drizzle-orm";
 var ACTIVE_VIDEO_GENERATION_STATUSES = [
   "preparing",
   "prepared",
@@ -400,7 +108,7 @@ async function admitVideoGenerationOperation(db, input) {
     { accountId: input.accountId, workspaceId: input.workspaceId },
     async (scopedDb) => await scopedDb.transaction(async (tx) => {
       await tx.execute(
-        sql3`select pg_advisory_xact_lock(hashtextextended(${`video-generation:${input.admissionKey}`}, 0))`
+        sql`select pg_advisory_xact_lock(hashtextextended(${`video-generation:${input.admissionKey}`}, 0))`
       );
       const [existing] = await tx.select().from(videoGenerationOperations).where(
         and(
@@ -487,7 +195,7 @@ async function admitVideoGenerationOperation(db, input) {
         );
       }
       await tx.update(workspaceVideoGenerationQuotas).set({
-        reservedBytes: sql3`${workspaceVideoGenerationQuotas.reservedBytes} + ${reservedBytes}`,
+        reservedBytes: sql`${workspaceVideoGenerationQuotas.reservedBytes} + ${reservedBytes}`,
         updatedAt: /* @__PURE__ */ new Date()
       }).where(eq(workspaceVideoGenerationQuotas.workspaceId, input.workspaceId));
       return { operation, created: true };
@@ -615,7 +323,7 @@ async function cancelUnacceptedVideoGenerationsForToolCallsInTransaction(tx, inp
       inArray(videoGenerationOperations.toolCallId, toolCallIds),
       eq(videoGenerationOperations.admissionOutputState, "pending"),
       inArray(videoGenerationOperations.status, ["preparing", "prepared"]),
-      sql3`${videoGenerationOperations.providerRequestSentAt} is null`
+      sql`${videoGenerationOperations.providerRequestSentAt} is null`
     )
   ).orderBy(videoGenerationOperations.id).for("update");
   const cancelled = [];
@@ -648,7 +356,7 @@ async function cancelUnacceptedVideoGenerationsForToolCallsInTransaction(tx, inp
 async function claimVideoGenerationOperations(db, input) {
   const rows = await rawRows(
     db,
-    sql3`select * from opengeni_private.claim_video_generation_operations(
+    sql`select * from opengeni_private.claim_video_generation_operations(
       ${input.owner}, ${input.leaseSeconds}, ${input.limit}
     )`
   );
@@ -839,7 +547,7 @@ async function settleVideoGenerationReady(db, input) {
         throw new Error("Video artifact and File identities must be distinct");
       }
       await tx.execute(
-        sql3`SELECT set_config('opengeni.private_file_owner',${operation.privateFileOwnerSubjectId ?? ""},true)`
+        sql`SELECT set_config('opengeni.private_file_owner',${operation.privateFileOwnerSubjectId ?? ""},true)`
       );
       const now = /* @__PURE__ */ new Date();
       await tx.insert(files).values({
@@ -883,8 +591,8 @@ async function settleVideoGenerationReady(db, input) {
       }).returning();
       if (!artifact) throw new Error("Generated video artifact was not persisted");
       await tx.update(workspaceVideoGenerationQuotas).set({
-        reservedBytes: sql3`${workspaceVideoGenerationQuotas.reservedBytes} - ${operation.reservedBytes}`,
-        readyBytes: sql3`${workspaceVideoGenerationQuotas.readyBytes} + ${input.sizeBytes}`,
+        reservedBytes: sql`${workspaceVideoGenerationQuotas.reservedBytes} - ${operation.reservedBytes}`,
+        readyBytes: sql`${workspaceVideoGenerationQuotas.readyBytes} + ${input.sizeBytes}`,
         updatedAt: now
       }).where(eq(workspaceVideoGenerationQuotas.workspaceId, input.workspaceId));
       const [updated] = await tx.update(videoGenerationOperations).set({
@@ -933,7 +641,7 @@ async function listSessionGeneratedVideoArtifacts(db, workspaceId, sessionId) {
       and(
         eq(generatedVideoArtifacts.workspaceId, workspaceId),
         eq(generatedVideoArtifacts.sessionId, sessionId),
-        sql3`${generatedVideoArtifacts.deletedAt} is null`
+        sql`${generatedVideoArtifacts.deletedAt} is null`
       )
     ).orderBy(generatedVideoArtifacts.createdAt, generatedVideoArtifacts.id)
   );
@@ -1076,7 +784,7 @@ async function getVideoGenerationOperationSummary(db, workspaceId, operationId)
       workspaceId,
       (tx) => rawRows(
         tx,
-        sql3`SELECT nullif(current_setting('opengeni.private_file_owner',true),'') AS owner`
+        sql`SELECT nullif(current_setting('opengeni.private_file_owner',true),'') AS owner`
       )
     );
     if (context?.owner !== operation.privateFileOwnerSubjectId) return null;
@@ -1119,9 +827,9 @@ async function mutateOperation(db, input, mutate) {
 async function releaseReservedQuota(tx, operation, ready) {
   if (operation.quotaState !== "reserved") return;
   await tx.update(workspaceVideoGenerationQuotas).set({
-    reservedBytes: sql3`${workspaceVideoGenerationQuotas.reservedBytes} - ${operation.reservedBytes}`,
+    reservedBytes: sql`${workspaceVideoGenerationQuotas.reservedBytes} - ${operation.reservedBytes}`,
     ...ready ? {
-      readyBytes: sql3`${workspaceVideoGenerationQuotas.readyBytes} + ${operation.reservedBytes}`
+      readyBytes: sql`${workspaceVideoGenerationQuotas.readyBytes} + ${operation.reservedBytes}`
     } : {},
     updatedAt: /* @__PURE__ */ new Date()
   }).where(eq(workspaceVideoGenerationQuotas.workspaceId, operation.workspaceId));
@@ -1130,23 +838,9 @@ async function debitVideoGenerationCredits(tx, operation) {
   if (operation.pricedCostMicros <= 0 || operation.fundingSource !== "opengeni_credits") {
     throw new Error("Managed video credit debit has an invalid funding binding");
   }
-  if (!operation.turnId) {
-    throw new VideoGenerationCreditError("Paid video initiating turn is unavailable");
-  }
-  await tx.execute(sql3`select pg_advisory_xact_lock(hashtext(${operation.accountId}))`);
-  const attribution = await creditDebitAttributionForTurn(tx, {
-    accountId: operation.accountId,
-    workspaceId: operation.workspaceId,
-    turnId: operation.turnId
-  });
-  const refusal = await checkWorkspaceAllowance(tx, {
-    accountId: operation.accountId,
-    workspaceId: operation.workspaceId,
-    subjectId: attribution.kind === "turn" ? attribution.initiatingHumanSubjectId : null
-  });
-  if (refusal) throw Object.assign(new VideoGenerationCreditError(refusal.message), refusal);
+  await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${operation.accountId}))`);
   const [balanceRow] = await tx.select({
-    balanceMicros: sql3`coalesce(sum(${creditLedgerEntries.amountMicros}), 0)`
+    balanceMicros: sql`coalesce(sum(${creditLedgerEntries.amountMicros}), 0)`
   }).from(creditLedgerEntries).where(eq(creditLedgerEntries.accountId, operation.accountId));
   const balanceMicros = Number(balanceRow?.balanceMicros ?? 0);
   if (!Number.isSafeInteger(balanceMicros) || balanceMicros < operation.pricedCostMicros) {
@@ -1162,7 +856,6 @@ async function debitVideoGenerationCredits(tx, operation) {
     sourceId: operation.id,
     idempotencyKey: `credit:video_generation_debit:${operation.id}`,
     metadata: {
-      turnId: operation.turnId,
       modelId: operation.modelId,
       sourceMode: operation.sourceMode,
       pricedCostMicros: operation.pricedCostMicros
@@ -1192,7 +885,7 @@ async function refundVideoGenerationCredits(tx, operation, now) {
   if (operation.fundingSource !== "opengeni_credits" || operation.pricedCostMicros <= 0) {
     throw new Error("Video generation credit refund has an invalid funding binding");
   }
-  await tx.execute(sql3`select pg_advisory_xact_lock(hashtext(${operation.accountId}))`);
+  await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${operation.accountId}))`);
   const inserted = await tx.insert(creditLedgerEntries).values({
     accountId: operation.accountId,
     workspaceId: operation.workspaceId,
@@ -1202,7 +895,6 @@ async function refundVideoGenerationCredits(tx, operation, now) {
     sourceId: operation.id,
     idempotencyKey: `credit:video_generation_refund:${operation.id}`,
     metadata: {
-      turnId: operation.turnId,
       modelId: operation.modelId,
       sourceMode: operation.sourceMode,
       pricedCostMicros: operation.pricedCostMicros
@@ -1283,24 +975,6 @@ function boundPrivateError(value) {
 }
 
 export {
-  currentCreditDebitAttribution,
-  withCreditDebitAttribution,
-  creditDebitAttributionForTurn,
-  CreditDebitAttribution,
-  creditDebitAttributionMetadata,
-  UsageAllowanceVersionConflictError,
-  validateMemberAllowanceRule,
-  validateWorkspaceAllowanceConfig,
-  getWorkspaceAllowance,
-  getWorkspaceAllowanceState,
-  setWorkspaceAllowance,
-  clearWorkspaceAllowance,
-  grantWorkspaceCredits,
-  setMemberAllowance,
-  allowanceUsage,
-  getWorkspaceUsage,
-  checkWorkspaceAllowance,
-  maintainWorkspaceAllowances,
   ACTIVE_VIDEO_GENERATION_STATUSES,
   VideoGenerationConflictError,
   VideoGenerationCapacityError,
@@ -1332,4 +1006,4 @@ export {
   mediaGenerationResultForStoredOperation,
   getVideoGenerationOperationSummary
 };
-//# sourceMappingURL=chunk-LNXRHVDB.js.map
+//# sourceMappingURL=chunk-3I4SGUQX.js.map