@opengeni/api-router 0.23.1 → 0.30.0

package/src/routes/transcription-recordings.ts

@@ -362,12 +362,18 @@ export function registerResumableTranscriptionRoutes(app: Hono, deps: ApiRouteDe
         if (
           !deps.objectStorage ||
           !service ||
-          !(await service.available({ workspaceId: authority.workspaceId }))
+          !(await service.available({
+            workspaceId: authority.workspaceId,
+            subjectId: authority.subjectId,
+          }))
         ) {
           return c.json({ code: "unavailable" }, 503);
         }
         const selectedProvider = service.selectProvider
-          ? await service.selectProvider({ workspaceId: authority.workspaceId })
+          ? await service.selectProvider({
+              workspaceId: authority.workspaceId,
+              subjectId: authority.subjectId,
+            })
           : "host";
         if (!selectedProvider) return c.json({ code: "unavailable" }, 503);
         attemptId = correlationId(c);
@@ -418,6 +424,7 @@ export function registerResumableTranscriptionRoutes(app: Hono, deps: ApiRouteDe
         const result = await service.transcribe({
           workspaceId: authority.workspaceId,
           accountId: authority.accountId,
+          subjectId: authority.subjectId,
           audio: stored.bytes,
           mimeType: "audio/wav",
           durationSeconds: claim.segment.durationMilliseconds / 1_000,

package/src/routes/transcriptions.ts

@@ -18,7 +18,7 @@ export function registerTranscriptionRoutes(app: Hono, deps: ApiRouteDeps): void
       return c.json({ code: "policy_blocked" }, 403);
     }
     const service = deps.transcription;
-    if (!service || !(await service.available())) {
+    if (!service || !(await service.available({ workspaceId, subjectId: grant.subjectId }))) {
       return c.json({ code: "unavailable" }, 503);
     }
     try {
@@ -26,6 +26,7 @@ export function registerTranscriptionRoutes(app: Hono, deps: ApiRouteDeps): void
       const result = await service.transcribe({
         workspaceId,
         accountId: grant.accountId,
+        subjectId: grant.subjectId,
         audio: body.audio,
         mimeType: body.mimeType,
         durationSeconds: body.durationSeconds,

package/src/routes/video-generation.ts

@@ -0,0 +1,162 @@
+import {
+  UpdateVideoGenerationPolicyRequest,
+  VideoGenerationOperationSummary,
+  VideoGenerationPolicy,
+  WorkspaceVideoGenerationSettings,
+} from "@opengeni/contracts";
+import {
+  getVideoGenerationOperationSummary,
+  getWorkspaceVercelAiGatewayConnectionMetadata,
+  getWorkspaceVideoGenerationPolicy,
+  updateWorkspaceVideoGenerationPolicy,
+  VideoGenerationConflictError,
+  workspaceXaiSubscriptionActive,
+} from "@opengeni/db";
+import {
+  requireAccessGrant,
+  VIDEO_GENERATION_MODEL_CATALOG,
+  videoGenerationModelSupportsFundingSource,
+  videoGenerationCapabilitiesForPolicy,
+  type ApiRouteDeps,
+} from "@opengeni/core";
+import type { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+
+export function registerVideoGenerationRoutes(app: Hono, deps: ApiRouteDeps): void {
+  app.get("/v1/workspaces/:workspaceId/video-generation", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:read");
+    const [policy, connection, supergrokConfigured] = await Promise.all([
+      getWorkspaceVideoGenerationPolicy(deps.db, workspaceId),
+      getWorkspaceVercelAiGatewayConnectionMetadata(deps.db, workspaceId),
+      workspaceXaiSubscriptionActive(deps.db, deps.settings, workspaceId, grant.subjectId),
+    ]);
+    const fundingOptions = videoGenerationFundingOptions({
+      managedConfigured: managedVideoGenerationConfigured(deps),
+      workspaceGatewayConfigured: connection !== null,
+      supergrokConfigured,
+    });
+    const selectedFunding = fundingOptions.find((option) => option.source === policy.fundingSource);
+    const capabilities =
+      selectedFunding?.available && policy.defaultModelId && policy.enabledModelIds.length > 0
+        ? videoGenerationCapabilitiesForPolicy({
+            policy,
+            credentialVersion:
+              policy.fundingSource === "workspace_gateway" ? (connection?.version ?? 0) : 1,
+          })
+        : null;
+    return c.json(
+      WorkspaceVideoGenerationSettings.parse({
+        schemaVersion: 1,
+        policy,
+        fundingOptions,
+        availableModels: VIDEO_GENERATION_MODEL_CATALOG,
+        capabilities,
+      }),
+    );
+  });
+
+  app.put("/v1/workspaces/:workspaceId/video-generation/policy", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
+    const payload = UpdateVideoGenerationPolicyRequest.parse(await c.req.json());
+    const [connection, supergrokConfigured] = await Promise.all([
+      getWorkspaceVercelAiGatewayConnectionMetadata(deps.db, workspaceId),
+      workspaceXaiSubscriptionActive(deps.db, deps.settings, workspaceId, grant.subjectId),
+    ]);
+    const fundingOptions = videoGenerationFundingOptions({
+      managedConfigured: managedVideoGenerationConfigured(deps),
+      workspaceGatewayConfigured: connection !== null,
+      supergrokConfigured,
+    });
+    const selectedFunding = fundingOptions.find(
+      (option) => option.source === payload.fundingSource,
+    );
+    if (payload.enabledModelIds.length > 0 && !selectedFunding?.available) {
+      throw new HTTPException(422, {
+        message: selectedFunding?.unavailableReason ?? "Video generation funding is unavailable",
+      });
+    }
+    if (
+      payload.enabledModelIds.some(
+        (modelId) => !videoGenerationModelSupportsFundingSource(modelId, payload.fundingSource),
+      )
+    ) {
+      throw new HTTPException(422, {
+        message: "The selected video model is unavailable for this funding source",
+      });
+    }
+    try {
+      const policy = await updateWorkspaceVideoGenerationPolicy(deps.db, {
+        accountId: grant.accountId,
+        workspaceId,
+        subjectId: grant.subjectId,
+        ...payload,
+      });
+      return c.json(VideoGenerationPolicy.parse(policy));
+    } catch (error) {
+      if (error instanceof VideoGenerationConflictError) {
+        throw new HTTPException(409, { message: error.message });
+      }
+      if (error instanceof Error && error.message.startsWith("Unknown video generation model:")) {
+        throw new HTTPException(422, { message: error.message });
+      }
+      throw error;
+    }
+  });
+
+  app.get("/v1/workspaces/:workspaceId/video-generation/operations/:operationId", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    await requireAccessGrant(c, deps, workspaceId, "workspace:read");
+    const summary = await getVideoGenerationOperationSummary(
+      deps.db,
+      workspaceId,
+      c.req.param("operationId"),
+    );
+    if (!summary)
+      throw new HTTPException(404, {
+        message: "video generation operation not found",
+      });
+    return c.json(VideoGenerationOperationSummary.parse(summary));
+  });
+}
+
+function managedVideoGenerationConfigured(deps: ApiRouteDeps): boolean {
+  return Boolean(deps.settings.vercelAiGatewayApiKey && deps.settings.environmentsEncryptionKey);
+}
+
+function videoGenerationFundingOptions(input: {
+  managedConfigured: boolean;
+  workspaceGatewayConfigured: boolean;
+  supergrokConfigured: boolean;
+}) {
+  return [
+    {
+      source: "opengeni_credits" as const,
+      label: "OpenGeni",
+      description: "Uses OpenGeni credits through the managed Gateway route.",
+      available: input.managedConfigured,
+      unavailableReason: input.managedConfigured
+        ? null
+        : "OpenGeni-managed video generation is not configured.",
+    },
+    {
+      source: "supergrok_subscription" as const,
+      label: "SuperGrok",
+      description: "Uses your connected SuperGrok subscription.",
+      available: input.supergrokConfigured,
+      unavailableReason: input.supergrokConfigured
+        ? null
+        : "Connect an eligible SuperGrok account first.",
+    },
+    {
+      source: "workspace_gateway" as const,
+      label: "Your Gateway",
+      description: "Uses your workspace Vercel AI Gateway key.",
+      available: input.workspaceGatewayConfigured,
+      unavailableReason: input.workspaceGatewayConfigured
+        ? null
+        : "Connect a workspace Vercel AI Gateway key first.",
+    },
+  ];
+}

package/src/routes/workspaces.ts

@@ -19,14 +19,11 @@ import {
 } from "@opengeni/contracts";
 import {
   allWorkspacePermissions,
-  countActiveSessionsForWorkspace,
-  countWorkspacesForAccount,
   createWorkspace,
-  deleteWorkspace,
+  deleteWorkspaceIfQuiescent,
   getManagedUserByEmail,
   getWorkspaceModelPolicy,
   grantWorkspaceAccess,
-  listScheduledTasks,
   listWorkspaceMembers,
   listWorkspaceControlEvents,
   listWorkspacesForSubject,
@@ -38,6 +35,7 @@ import {
   updateWorkspaceSettings,
   upsertWorkspaceModelPolicy,
   workspaceCodexSubscriptionActive,
+  workspaceXaiSubscriptionActive,
   workspaceVercelAiGatewayConnectionActive,
 } from "@opengeni/db";
 import { boundWorkspaceControlHttpPage } from "@opengeni/events";
@@ -47,7 +45,6 @@ import { hasPermission, requireAccessContext, requireAccessGrant } from "@openge
 import { requireLimit } from "@opengeni/core";
 import type { ApiRouteDeps } from "@opengeni/core";
 import {
-  assertWorkspaceDeletable,
   assertWorkspaceMemberRemovable,
   controlHumanWorkspace,
   resolveMemberSubjectId,
@@ -55,9 +52,11 @@ import {
 import { boundedLimit } from "../http/common";
 import { sseWorkspaceControlStream } from "../http/sse";
 import { buildWorkspaceModelCatalog } from "../model-catalog";
+import { processTemporalScheduleCleanupClaims } from "../temporal-schedule-cleanup";
 import {
   AI_GATEWAY_REALTIME_MODELS,
   CODEX_REALTIME_MODEL_ID,
+  SUPERGROK_REALTIME_MODEL_ID,
   canonicalizeConfiguredModelId,
   type Settings,
 } from "@opengeni/config";
@@ -168,10 +167,16 @@ export function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void {
   // so bearer/federated definitions intentionally fail closed as not ready.
   app.get("/v1/workspaces/:workspaceId/model-catalog", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant(c, deps, workspaceId, "workspace:read");
-    const [policy, codexSubscriptionActive, workspaceGatewayConnectionActive] = await Promise.all([
+    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:read");
+    const [
+      policy,
+      codexSubscriptionActive,
+      xaiSubscriptionActive,
+      workspaceGatewayConnectionActive,
+    ] = await Promise.all([
       getWorkspaceModelPolicy(deps.db, workspaceId),
       workspaceCodexSubscriptionActive(deps.db, deps.settings, workspaceId),
+      workspaceXaiSubscriptionActive(deps.db, deps.settings, workspaceId, grant.subjectId),
       workspaceVercelAiGatewayConnectionActive(deps.db, workspaceId),
     ]);
     c.header("cache-control", "private, no-store");
@@ -181,6 +186,7 @@ export function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void {
           settings: deps.settings,
           policy,
           codexSubscriptionActive,
+          xaiSubscriptionActive,
           workspaceGatewayConnectionActive,
         }),
       ),
@@ -189,9 +195,10 @@ export function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.get("/v1/workspaces/:workspaceId/realtime-model-catalog", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant(c, deps, workspaceId, "workspace:read");
-    const [codexConnected, workspaceGatewayConnected] = await Promise.all([
+    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:read");
+    const [codexConnected, supergrokConnected, workspaceGatewayConnected] = await Promise.all([
       workspaceCodexSubscriptionActive(deps.db, deps.settings, workspaceId),
+      workspaceXaiSubscriptionActive(deps.db, deps.settings, workspaceId, grant.subjectId),
       workspaceVercelAiGatewayConnectionActive(deps.db, workspaceId),
     ]);
     const availability = (
@@ -223,6 +230,14 @@ export function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void {
         ...availability(codexConnected, "Connect Codex to use this voice model"),
         recommended: false,
       },
+      {
+        id: SUPERGROK_REALTIME_MODEL_ID,
+        label: "Grok Voice Think Fast 2.0",
+        provider: "Connected SuperGrok" as const,
+        description: "Direct SuperGrok speech-to-speech",
+        ...availability(supergrokConnected, "Connect SuperGrok to use this voice model"),
+        recommended: false,
+      },
       ...gatewayModels.map((model) => ({
         id: model.workspaceModelId,
         label: model.label,
@@ -330,26 +345,51 @@ export function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void {
   app.delete("/v1/workspaces/:workspaceId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
-    // Refuse before any external/DB mutation: never delete the account's only
-    // workspace, and never delete while a session could still be running in
-    // Temporal (there is no clean per-session terminate to call, so deleting
-    // the row would orphan the workflow — the operator must stop them first).
-    const [workspaceCountForAccount, activeSessionCount] = await Promise.all([
-      countWorkspacesForAccount(deps.db, grant.accountId),
-      countActiveSessionsForWorkspace(deps.db, workspaceId),
-    ]);
-    assertWorkspaceDeletable({ workspaceCountForAccount, activeSessionCount });
-    // Clean external Temporal state the FK cascade can't reach: every scheduled
-    // task's schedule (best-effort, mirroring the scheduled-task delete path).
-    const tasks = await listScheduledTasks(deps.db, workspaceId, 1000);
-    await Promise.all(
-      tasks.map((task) =>
-        deps.workflowClient
-          .deleteScheduledTaskSchedule({ temporalScheduleId: task.temporalScheduleId })
-          .catch(() => undefined),
-      ),
+    // The DB transaction locks the account/workspace and every existing
+    // session/lease before checking runtime quiescence, then returns the exact
+    // external schedules removed by the cascade. A racing cold->warm transition
+    // can therefore never erase the only provider/capture ownership receipt.
+    const deleted = await deleteWorkspaceIfQuiescent(deps.db, {
+      accountId: grant.accountId,
+      workspaceId,
+    });
+    if (deleted.status === "not_found") {
+      throw new HTTPException(404, { message: "workspace not found" });
+    }
+    if (deleted.status === "only_workspace") {
+      throw new HTTPException(409, { message: "cannot delete the account's only workspace" });
+    }
+    if (deleted.status === "active_sessions") {
+      throw new HTTPException(409, {
+        message: "stop the workspace's running sessions before deleting it",
+      });
+    }
+    if (deleted.status === "active_video_generations") {
+      throw new HTTPException(409, {
+        message: "wait for the workspace's active video generations to finish before deleting it",
+      });
+    }
+    if (deleted.status === "live_sandboxes") {
+      throw new HTTPException(409, {
+        message: "wait for the workspace's active sandboxes to finish draining before deleting it",
+      });
+    }
+    if (deleted.status !== "deleted") {
+      throw new Error(`Unhandled workspace deletion outcome: ${deleted.status}`);
+    }
+    // The cleanup claims were inserted in the same transaction as the cascade.
+    // Try them immediately; failures are released to the replica-safe outbox
+    // pump, so a process crash or Temporal outage cannot orphan the schedules.
+    await processTemporalScheduleCleanupClaims(
+      {
+        db: deps.db,
+        deleteSchedule: async (temporalScheduleId) => {
+          await deps.workflowClient.deleteScheduledTaskSchedule({ temporalScheduleId });
+        },
+        ...(deps.observability ? { observability: deps.observability } : {}),
+      },
+      deleted.temporalScheduleCleanups,
     );
-    await deleteWorkspace(deps.db, workspaceId);
     return c.body(null, 204);
   });