@opengeni/core 0.4.6 → 0.4.8

package/src/billing/limits.ts

@@ -12,6 +12,8 @@ import {
 import { HTTPException } from "hono/http-exception";
 import type { ApiRouteDeps } from "../dependencies";
 
+export type LimitDependencies = Pick<ApiRouteDeps, "db" | "settings">;
+
 export type LimitCheckInput = {
   accountId: string;
   workspaceId?: string;
@@ -26,20 +28,30 @@ export type LimitCheckInput = {
   model?: string | null;
 };
 
-export async function requireLimit(deps: ApiRouteDeps, input: LimitCheckInput): Promise<void> {
+export async function requireLimit(deps: LimitDependencies, input: LimitCheckInput): Promise<void> {
   const decision = await checkLimit(deps, input);
   if (decision.allowed) {
     return;
   }
-  throw new HTTPException(decision.code === "insufficient_credits" ? 402 : 429, { message: decision.message });
+  throw new HTTPException(decision.code === "insufficient_credits" ? 402 : 429, {
+    message: decision.message,
+  });
 }
 
-export async function checkLimit(deps: ApiRouteDeps, input: LimitCheckInput): Promise<LimitDecision> {
+export async function checkLimit(
+  deps: LimitDependencies,
+  input: LimitCheckInput,
+): Promise<LimitDecision> {
   // Resolve the canonical codex-billed predicate ONCE. Returns false for any
   // action that carries no model (infra caps) or any codex/<slug> model without
   // an active credential — so the bypass never triggers on the prefix alone.
   const codexBilled = input.workspaceId
-    ? await isCodexBilledTurn({ db: deps.db, settings: deps.settings, workspaceId: input.workspaceId, model: input.model })
+    ? await isCodexBilledTurn({
+        db: deps.db,
+        settings: deps.settings,
+        workspaceId: input.workspaceId,
+        model: input.model,
+      })
     : false;
   const creditDecision = await checkCreditBalance(deps, input, codexBilled);
   if (!creditDecision.allowed) {
@@ -51,7 +63,11 @@ export async function checkLimit(deps: ApiRouteDeps, input: LimitCheckInput): Pr
   return await checkStaticCaps(deps, input, codexBilled);
 }
 
-async function checkCreditBalance(deps: ApiRouteDeps, input: LimitCheckInput, codexBilled: boolean): Promise<LimitDecision> {
+async function checkCreditBalance(
+  deps: LimitDependencies,
+  input: LimitCheckInput,
+  codexBilled: boolean,
+): Promise<LimitDecision> {
   if (codexBilled) {
     return { allowed: true }; // paid by the user's ChatGPT/Codex plan — zero OpenGeni credits
   }
@@ -65,7 +81,11 @@ async function checkCreditBalance(deps: ApiRouteDeps, input: LimitCheckInput, co
   return { allowed: false, code: "insufficient_credits", message: "insufficient OpenGeni credits" };
 }
 
-async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codexBilled: boolean): Promise<LimitDecision> {
+async function checkStaticCaps(
+  deps: LimitDependencies,
+  input: LimitCheckInput,
+  codexBilled: boolean,
+): Promise<LimitDecision> {
   const limits = configuredStaticUsageLimits(deps.settings);
   if (limits.maxMonthlyCostMicrosPerAccount && isCostlyAction(input.action) && !codexBilled) {
     const used = await sumUsageQuantity(deps.db, {
@@ -74,7 +94,10 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       since: startOfUtcMonth(),
     });
     if (used >= limits.maxMonthlyCostMicrosPerAccount) {
-      return blocked("max_monthly_cost_micros_per_account", `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`);
+      return blocked(
+        "max_monthly_cost_micros_per_account",
+        `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`,
+      );
     }
   }
   switch (input.action) {
@@ -85,7 +108,10 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       const count = await countWorkspacesForAccount(deps.db, input.accountId);
       return count < limits.maxWorkspacesPerAccount
         ? { allowed: true }
-        : blocked("max_workspaces_per_account", `workspace limit reached (${limits.maxWorkspacesPerAccount})`);
+        : blocked(
+            "max_workspaces_per_account",
+            `workspace limit reached (${limits.maxWorkspacesPerAccount})`,
+          );
     }
     case "api_key:create": {
       if (!limits.maxApiKeysPerWorkspace || !input.workspaceId) {
@@ -94,7 +120,10 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       const count = await countActiveApiKeysForWorkspace(deps.db, input.workspaceId);
       return count < limits.maxApiKeysPerWorkspace
         ? { allowed: true }
-        : blocked("max_api_keys_per_workspace", `API key limit reached (${limits.maxApiKeysPerWorkspace})`);
+        : blocked(
+            "max_api_keys_per_workspace",
+            `API key limit reached (${limits.maxApiKeysPerWorkspace})`,
+          );
     }
     case "schedule:create": {
       if (!limits.maxSchedulesPerWorkspace || !input.workspaceId) {
@@ -103,7 +132,10 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       const count = await countScheduledTasksForWorkspace(deps.db, input.workspaceId);
       return count < limits.maxSchedulesPerWorkspace
         ? { allowed: true }
-        : blocked("max_schedules_per_workspace", `scheduled task limit reached (${limits.maxSchedulesPerWorkspace})`);
+        : blocked(
+            "max_schedules_per_workspace",
+            `scheduled task limit reached (${limits.maxSchedulesPerWorkspace})`,
+          );
     }
     case "file:upload": {
       if (!limits.maxFileUploadBytes || !input.quantity) {
@@ -111,7 +143,10 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       }
       return input.quantity <= limits.maxFileUploadBytes
         ? { allowed: true }
-        : blocked("max_file_upload_bytes", `file upload exceeds static limit of ${limits.maxFileUploadBytes} bytes`);
+        : blocked(
+            "max_file_upload_bytes",
+            `file upload exceeds static limit of ${limits.maxFileUploadBytes} bytes`,
+          );
     }
     case "agent_run:create": {
       if (!limits.maxMonthlyAgentRunsPerWorkspace || !input.workspaceId) {
@@ -125,7 +160,10 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       const requested = input.quantity ?? 0;
       return used + requested <= limits.maxMonthlyAgentRunsPerWorkspace
         ? { allowed: true }
-        : blocked("max_monthly_agent_runs_per_workspace", `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`);
+        : blocked(
+            "max_monthly_agent_runs_per_workspace",
+            `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`,
+          );
     }
     case "tokens:consume": {
       if (codexBilled || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
@@ -139,7 +177,10 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       const requested = input.quantity ?? 0;
       return used + requested <= limits.maxMonthlyTokensPerWorkspace
         ? { allowed: true }
-        : blocked("max_monthly_tokens_per_workspace", `monthly token limit reached (${limits.maxMonthlyTokensPerWorkspace})`);
+        : blocked(
+            "max_monthly_tokens_per_workspace",
+            `monthly token limit reached (${limits.maxMonthlyTokensPerWorkspace})`,
+          );
     }
     case "document:index": {
       if (!limits.maxDocumentIndexedChunksPerWorkspace || !input.workspaceId) {
@@ -153,26 +194,28 @@ async function checkStaticCaps(deps: ApiRouteDeps, input: LimitCheckInput, codex
       const requested = input.quantity ?? 0;
       return used + requested <= limits.maxDocumentIndexedChunksPerWorkspace
         ? { allowed: true }
-        : blocked("max_document_indexed_chunks_per_workspace", `monthly document indexing limit reached (${limits.maxDocumentIndexedChunksPerWorkspace} chunks)`);
+        : blocked(
+            "max_document_indexed_chunks_per_workspace",
+            `monthly document indexing limit reached (${limits.maxDocumentIndexedChunksPerWorkspace} chunks)`,
+          );
     }
   }
 }
 
-export async function recordWorkspaceUsage(deps: ApiRouteDeps, input: {
-  accountId: string;
-  workspaceId: string;
-  subjectId?: string | null;
-  eventType:
-    | "agent_run.created"
-    | "file.uploaded"
-    | "document.indexed"
-    | "scheduled_task.fired";
-  quantity: number;
-  unit: string;
-  sourceResourceType: string;
-  sourceResourceId: string;
-  idempotencyKey: string;
-}): Promise<void> {
+export async function recordWorkspaceUsage(
+  deps: LimitDependencies,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId?: string | null;
+    eventType: "agent_run.created" | "file.uploaded" | "document.indexed" | "scheduled_task.fired";
+    quantity: number;
+    unit: string;
+    sourceResourceType: string;
+    sourceResourceId: string;
+    idempotencyKey: string;
+  },
+): Promise<void> {
   await recordUsageEvent(deps.db, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -186,15 +229,14 @@ export async function recordWorkspaceUsage(deps: ApiRouteDeps, input: {
   });
 }
 
-function usesCreditLimits(deps: ApiRouteDeps): boolean {
+function usesCreditLimits(deps: LimitDependencies): boolean {
   return deps.settings.billingMode === "stripe" || deps.settings.usageLimitsMode === "managed";
 }
 
 function isCostlyAction(action: LimitAction): boolean {
-  return action === "agent_run:create"
-    || action === "tokens:consume"
-    || action === "file:upload"
-    || action === "document:index";
+  return (
+    action === "agent_run:create" || action === "tokens:consume" || action === "document:index"
+  );
 }
 
 function blocked(code: string, message: string): LimitDecision {

package/src/dependencies.ts

@@ -9,26 +9,62 @@ import type { ManagedAuth } from "./managed-auth-type";
 import type { ApiSandboxClient, ResumeBoxByIdInput, ResumedSandboxSession } from "./sandbox-types";
 
 export type SessionWorkflowClient = {
-  signalUserMessage: (input: { sessionId: string; eventId: string; workflowId: string }) => Promise<void>;
-  wakeSessionWorkflow: (input: { accountId: string; workspaceId: string; sessionId: string; workflowId: string }) => Promise<void>;
-  signalApprovalDecision: (input: { sessionId: string; eventId: string; workflowId: string }) => Promise<void>;
-  // Interrupt must reach the workflow whether or not an execution is currently
-  // running: a long-lived session that has gone idle (its workflow returned
-  // after markSessionIdle) has NO running execution, so a plain
-  // getHandle().signal() throws WorkflowNotFoundError -> a 500 that leaves an
-  // operator unable to stop a session. signalWithStart start-or-signals, so it
-  // needs the session-workflow args (accountId/workspaceId) to start a fresh
-  // run when none is live; the buffered `interrupt` signal is then honored by
-  // the workflow's idle-interrupt path (pause goal + mark idle).
-  signalInterrupt: (input: { accountId: string; workspaceId: string; sessionId: string; eventId: string; workflowId: string }) => Promise<void>;
+  signalUserMessage: (input: {
+    sessionId: string;
+    eventId: string;
+    workflowId: string;
+  }) => Promise<void>;
+  wakeSessionWorkflow: (input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    workflowId: string;
+    wakeRevision: number;
+    interruptionRequested?: boolean;
+  }) => Promise<void>;
+  /** Trigger one bounded drain of already-committed workflow-wake revisions. */
+  requestSessionWorkflowWakeDispatch: () => Promise<void>;
+  // Dedicated, revision-carrying nudge for a durable Codex capacity waiter.
+  // Optional for embedded/back-compat clients: callers may fall back to the
+  // generic queueChanged wake because Postgres wakeRevision is authoritative.
+  signalCodexCapacity?: (input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    workflowId: string;
+    wakeRevision: number;
+    workflowWakeRevision: number;
+  }) => Promise<void>;
+  signalApprovalDecision: (input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    eventId: string;
+    workflowId: string;
+    workflowWakeRevision: number;
+  }) => Promise<void>;
   syncScheduledTask: (input: { task: ScheduledTask }) => Promise<void>;
   deleteScheduledTaskSchedule: (input: { temporalScheduleId: string }) => Promise<void>;
-  triggerScheduledTask: (input: { task: ScheduledTask; agentRunUsageIdempotencyKey?: string; triggerWorkflowId?: string }) => Promise<void>;
+  triggerScheduledTask: (input: {
+    task: ScheduledTask;
+    agentRunUsageIdempotencyKey?: string;
+    triggerWorkflowId?: string;
+  }) => Promise<void>;
+  startRigVerification: (input: {
+    workspaceId: string;
+    changeId?: string;
+    versionId?: string;
+    workflowId?: string;
+  }) => Promise<void>;
   check?: () => Promise<void>;
 };
 
 export type DocumentIndexClient = {
-  indexDocument: (input: { accountId: string; workspaceId: string; documentId: string }) => Promise<Document | void>;
+  indexDocument: (input: {
+    accountId: string;
+    workspaceId: string;
+    documentId: string;
+  }) => Promise<Document | void>;
 };
 
 export type AppDependencies = {
@@ -36,6 +72,8 @@ export type AppDependencies = {
   db: Database;
   bus: EventBus;
   workflowClient: SessionWorkflowClient;
+  /** Optional provider override for deterministic API/object-storage tests. */
+  objectStorage?: ObjectStorageDependency;
   documentIndexer?: DocumentIndexClient;
   documentServices?: DocumentServices;
   observability?: Observability;
@@ -70,3 +108,18 @@ export type ApiRouteDeps = AppDependencies & {
   // resumeBoxById (it throws SandboxResumeError when sandboxBackend=none).
   resumeBoxById: (input: ResumeBoxByIdInput) => Promise<ResumedSandboxSession>;
 };
+
+/**
+ * The exact dependency slice used by `acceptSessionUserMessage`.
+ *
+ * Keeping this narrower than `ApiRouteDeps` lets control-plane callers reuse
+ * the canonical admission path without constructing unrelated HTTP, document,
+ * or sandbox services. The public API still passes its `ApiRouteDeps` superset.
+ */
+export type AcceptSessionUserMessageDependencies = Pick<
+  AppDependencies,
+  "settings" | "db" | "bus"
+> & {
+  workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+  objectStorage: ObjectStorageDependency;
+};