@opengeni/api-router 0.5.4 → 0.5.6

package/src/routes/sessions.ts

@@ -2,9 +2,10 @@ import {
   AcknowledgeStreamRequest,
   AttachViewerRequest,
   ClearSessionContextRequest,
-  CancelSessionQueueItemRequest,
   ClientSessionEvent,
   CompactSessionContextRequest,
+  DeleteSessionQueueItemRequest,
+  EditSessionQueueItemRequest,
   FsDeleteRequest,
   FsListRequest,
   FsMkdirRequest,
@@ -15,11 +16,14 @@ import {
   GitLogRequest,
   GitShowRequest,
   GitStatusRequest,
+  MoveSessionQueueItemRequest,
   PtyCloseRequest,
   PtyOpenRequest,
   PtyResizeRequest,
   PtyWriteRequest,
   SessionControlRequest,
+  SaveComposerDraftRequest,
+  SteerSessionQueueItemRequest,
   SteerSessionMessageRequest,
   TerminalExecRequest,
   UpdateSessionPinRequest,
@@ -34,7 +38,6 @@ import {
 } from "@opengeni/contracts";
 import { streamTokenDegraded } from "@opengeni/config";
 import {
-  cancelQueuedSessionTurnWithVersion,
   acceptSessionApprovalDecision,
   clearSessionGoal,
   clearSessionContext,
@@ -64,8 +67,9 @@ import {
   revokeViewer,
   setSessionGoalStatus,
   updatePtySessionActivity,
-  requestSessionControl,
-  SessionQueueConflictError,
+  QueueCommandConflictError,
+  SessionCommandIdempotencyError,
+  SessionControlConflictError,
   SessionContextBusyError,
   latestWorkspaceCapture,
   workspaceCaptureAtRevision,
@@ -97,8 +101,15 @@ import {
 } from "../sandbox/viewer";
 import {
   acceptSessionUserMessage,
+  controlHumanSessionWorkstream,
   createSessionForRequest,
+  deleteHumanQueuePrompt,
+  editHumanQueuePrompt,
+  getHumanComposerDraft,
+  moveHumanQueuePrompt,
   readSessionLineage,
+  saveHumanComposerDraft,
+  steerHumanQueuePrompt,
   updateSessionTitle,
   workflowIdForSession,
 } from "@opengeni/core";
@@ -508,115 +519,136 @@ export function registerSessionRoutes(app: Hono, deps: ApiRouteDeps): void {
     return c.json(snapshot);
   });
 
-  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/queue/:turnId/cancel", async (c) => {
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/queue/:turnId/move", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
     await assertSessionExists(db, workspaceId, sessionId);
-    const payload = CancelSessionQueueItemRequest.parse(await c.req.json());
+    const payload = MoveSessionQueueItemRequest.parse(await c.req.json());
     try {
-      const result = await cancelQueuedSessionTurnWithVersion(
-        db,
-        workspaceId,
-        sessionId,
-        c.req.param("turnId"),
-        payload.expectedQueueVersion,
-        payload.expectedItemVersion,
-        grant.subjectId,
-        payload.reason ?? null,
+      return c.json(
+        await moveHumanQueuePrompt(
+          { db, bus },
+          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
+          c.req.param("turnId"),
+          payload,
+        ),
       );
-      await bus.publish(workspaceId, sessionId, result.events);
-      if (result.shouldWake) {
-        if (result.workflowWakeRevision === null) {
-          throw new Error("Queue continuation has no workflow wake revision");
-        }
-        await workflowClient.wakeSessionWorkflow({
-          accountId: grant.accountId,
-          workspaceId,
-          sessionId,
-          workflowId: workflowIdForSession(sessionId),
-          wakeRevision: result.workflowWakeRevision,
-        });
-      }
-      return c.json(result);
     } catch (error) {
-      throwQueueConflict(error);
+      return commandConflictResponse(c, error);
     }
   });
 
-  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/control", async (c) => {
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/queue/:turnId/edit", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
     const sessionId = c.req.param("sessionId");
-    const payload = SessionControlRequest.parse(await c.req.json());
-    let result;
+    await assertSessionExists(db, workspaceId, sessionId);
+    const payload = EditSessionQueueItemRequest.parse(await c.req.json());
     try {
-      result = await requestSessionControl(db, {
-        accountId: grant.accountId,
-        workspaceId,
-        sessionId,
-        actor: grant.subjectId,
-        mode: payload.mode,
-        reason: payload.reason ?? null,
-        clientEventId: payload.clientEventId ?? null,
-        ...(payload.expectedControlState !== undefined
-          ? { expectedControlState: payload.expectedControlState }
-          : {}),
-        ...(payload.expectedControlGeneration !== undefined
-          ? { expectedControlGeneration: payload.expectedControlGeneration }
-          : {}),
-        ...(payload.expectedWorkspaceInferenceGeneration !== undefined
-          ? {
-              expectedWorkspaceInferenceGeneration: payload.expectedWorkspaceInferenceGeneration,
-            }
-          : {}),
-      });
+      return c.json(
+        await editHumanQueuePrompt(
+          { db, bus },
+          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
+          c.req.param("turnId"),
+          payload,
+        ),
+      );
     } catch (error) {
-      throwQueueConflict(error);
+      return commandConflictResponse(c, error);
     }
-    await bus.publish(workspaceId, sessionId, result.events);
-    const workflowId = workflowIdForSession(sessionId);
-    if (result.shouldSignalControl) {
-      if (result.workflowWakeRevision === null) {
-        throw new Error("Session control has no workflow wake revision");
-      }
-      await workflowClient.signalSessionControl({
-        accountId: grant.accountId,
-        workspaceId,
-        sessionId,
-        eventId: result.event.id,
-        workflowId,
-        workflowWakeRevision: result.workflowWakeRevision,
-      });
-    } else if (result.shouldWake) {
-      if (result.workflowWakeRevision === null) {
-        throw new Error("Session resume has no workflow wake revision");
-      }
-      await workflowClient.wakeSessionWorkflow({
+  });
+
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/queue/:turnId/steer", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const sessionId = c.req.param("sessionId");
+    await assertSessionExists(db, workspaceId, sessionId);
+    const payload = SteerSessionQueueItemRequest.parse(await c.req.json());
+    try {
+      return c.json(
+        await steerHumanQueuePrompt(
+          { db, bus },
+          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
+          c.req.param("turnId"),
+          payload,
+        ),
+      );
+    } catch (error) {
+      return commandConflictResponse(c, error);
+    }
+  });
+
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/queue/:turnId/delete", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const sessionId = c.req.param("sessionId");
+    await assertSessionExists(db, workspaceId, sessionId);
+    const payload = DeleteSessionQueueItemRequest.parse(await c.req.json());
+    try {
+      return c.json(
+        await deleteHumanQueuePrompt(
+          { db, bus },
+          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
+          c.req.param("turnId"),
+          payload,
+        ),
+      );
+    } catch (error) {
+      return commandConflictResponse(c, error);
+    }
+  });
+
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/composer-draft", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:read");
+    const sessionId = c.req.param("sessionId");
+    return c.json(
+      await getHumanComposerDraft(db, {
         accountId: grant.accountId,
         workspaceId,
         sessionId,
-        workflowId,
-        wakeRevision: result.workflowWakeRevision,
-      });
-    }
-    return c.json(
-      {
-        operationId: result.operationId,
-        event: result.event,
-        controlState: result.controlState,
-        controlGeneration: result.controlGeneration,
-        expectedActiveTurnId: result.expectedActiveTurnId,
-        expectedExecutionGeneration: result.expectedExecutionGeneration,
-        expectedAttemptId: result.expectedAttemptId,
-        deliveryEventId: result.deliveryEventId,
-        shouldSignalControl: result.shouldSignalControl,
-        shouldWake: result.shouldWake,
-      },
-      202,
+        subjectId: grant.subjectId,
+      }),
     );
   });
 
+  app.put("/v1/workspaces/:workspaceId/sessions/:sessionId/composer-draft", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const sessionId = c.req.param("sessionId");
+    const payload = SaveComposerDraftRequest.parse(await c.req.json());
+    try {
+      return c.json(
+        await saveHumanComposerDraft(
+          db,
+          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
+          payload,
+        ),
+      );
+    } catch (error) {
+      return commandConflictResponse(c, error);
+    }
+  });
+
+  app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/control", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
+    const sessionId = c.req.param("sessionId");
+    const payload = SessionControlRequest.parse(await c.req.json());
+    try {
+      return c.json(
+        await controlHumanSessionWorkstream(
+          { db, bus, workflowClient },
+          { accountId: grant.accountId, workspaceId, sessionId, subjectId: grant.subjectId },
+          payload,
+        ),
+      );
+    } catch (error) {
+      return commandConflictResponse(c, error);
+    }
+  });
+
   app.post("/v1/workspaces/:workspaceId/sessions/:sessionId/steer", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:control");
@@ -634,13 +666,9 @@ export function registerSessionRoutes(app: Hono, deps: ApiRouteDeps): void {
       mcpCredentialUpdates: payload.mcpCredentialUpdates ?? [],
       delivery: "steer",
       origin: "human",
-      ...(payload.expectedControlGeneration !== undefined
-        ? { expectedControlGeneration: payload.expectedControlGeneration }
-        : {}),
-      ...(payload.expectedWorkspaceInferenceGeneration !== undefined
-        ? {
-            expectedWorkspaceInferenceGeneration: payload.expectedWorkspaceInferenceGeneration,
-          }
+      ...(payload.controlEtag !== undefined ? { controlEtag: payload.controlEtag } : {}),
+      ...(payload.expectedDraftRevision !== undefined
+        ? { expectedDraftRevision: payload.expectedDraftRevision }
         : {}),
       ...(payload.clientEventId ? { clientEventId: payload.clientEventId } : {}),
     });
@@ -662,6 +690,12 @@ export function registerSessionRoutes(app: Hono, deps: ApiRouteDeps): void {
         model: event.payload.model ?? null,
         reasoningEffort: event.payload.reasoningEffort ?? null,
         mcpCredentialUpdates: event.payload.mcpCredentialUpdates ?? [],
+        ...(event.payload.controlEtag !== undefined
+          ? { controlEtag: event.payload.controlEtag }
+          : {}),
+        ...(event.payload.expectedDraftRevision !== undefined
+          ? { expectedDraftRevision: event.payload.expectedDraftRevision }
+          : {}),
         ...(event.clientEventId ? { clientEventId: event.clientEventId } : {}),
       });
       return c.json(accepted, 202);
@@ -1629,17 +1663,15 @@ function userMessagePayloadHasOwnProperty(value: unknown, key: string): boolean
   return hasOwnProperty(payload, key);
 }
 
-function throwQueueConflict(error: unknown): never {
-  if (error instanceof SessionQueueConflictError) {
-    throw new HTTPException(409, {
-      message: JSON.stringify({
-        message: error.message,
-        currentQueueVersion: error.currentQueueVersion,
-        ...(error.currentItemVersion !== undefined
-          ? { currentItemVersion: error.currentItemVersion }
-          : {}),
-      }),
-    });
+function commandConflictResponse(c: Context, error: unknown): Response {
+  if (error instanceof QueueCommandConflictError) {
+    return c.json({ code: error.code, message: error.message, current: error.current }, 409);
+  }
+  if (error instanceof SessionControlConflictError) {
+    return c.json({ code: error.code, message: error.message }, 409);
+  }
+  if (error instanceof SessionCommandIdempotencyError) {
+    return c.json({ code: error.code, message: error.message }, 409);
   }
   throw error;
 }

package/src/routes/workspaces.ts

@@ -24,6 +24,7 @@ import {
   grantWorkspaceAccess,
   listScheduledTasks,
   listWorkspaceMembers,
+  listWorkspaceControlEvents,
   listWorkspacesForSubject,
   removeWorkspaceMember,
   requireWorkspace,
@@ -32,7 +33,6 @@ import {
   updateWorkspace,
   updateWorkspaceSettings,
   upsertWorkspaceModelPolicy,
-  setWorkspaceInferenceControl,
 } from "@opengeni/db";
 import type { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
@@ -42,8 +42,11 @@ import type { ApiRouteDeps } from "@opengeni/core";
 import {
   assertWorkspaceDeletable,
   assertWorkspaceMemberRemovable,
+  controlHumanWorkspace,
   resolveMemberSubjectId,
 } from "@opengeni/core";
+import { boundedLimit } from "../http/common";
+import { sseWorkspaceControlStream } from "../http/sse";
 
 export function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void {
   app.get("/v1/access/me", async (c) => {
@@ -169,52 +172,36 @@ export function registerWorkspaceRoutes(app: Hono, deps: ApiRouteDeps): void {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
     const payload = WorkspaceInferenceControlRequest.parse(await c.req.json());
-    const result = await setWorkspaceInferenceControl(deps.db, {
-      accountId: grant.accountId,
-      workspaceId,
-      actor: grant.subjectId,
-      state: payload.state,
-      reason: payload.reason,
-      clientEventId: payload.clientEventId,
-      expectedState: payload.expectedState,
-      expectedGeneration: payload.expectedGeneration,
-      exceptSessionIds: payload.exceptSessionIds,
-    });
-    for (const broadcast of result.broadcasts) {
-      await deps.bus.publish(workspaceId, broadcast.sessionId, broadcast.events);
-    }
-    for (const control of result.controls) {
-      await deps.workflowClient.signalSessionControl({
-        accountId: control.accountId,
-        workspaceId,
-        sessionId: control.sessionId,
-        eventId: control.eventId,
-        workflowId: control.workflowId,
-        workflowWakeRevision: control.workflowWakeRevision,
-      });
-    }
-    for (const wake of result.wakeSessions) {
-      await deps.workflowClient.wakeSessionWorkflow({
-        accountId: wake.accountId,
-        workspaceId,
-        sessionId: wake.sessionId,
-        workflowId: wake.workflowId,
-        wakeRevision: wake.workflowWakeRevision,
-      });
-    }
     return c.json(
-      {
-        operationId: result.operationId,
-        state: result.state,
-        generation: result.generation,
-        affectedSessionIds: result.affectedSessionIds,
-        controlSessionIds: result.controls.map((entry) => entry.sessionId),
-        exceptionSessionIds: result.exceptionSessionIds,
-      },
-      202,
+      await controlHumanWorkspace(
+        { db: deps.db, bus: deps.bus, workflowClient: deps.workflowClient },
+        { accountId: grant.accountId, workspaceId, subjectId: grant.subjectId },
+        payload,
+      ),
     );
   });
 
+  app.get("/v1/workspaces/:workspaceId/control-events", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    await requireAccessGrant(c, deps, workspaceId, "workspace:read");
+    const after = Math.max(0, Number.parseInt(c.req.query("after") ?? "0", 10) || 0);
+    return c.json(
+      await listWorkspaceControlEvents(
+        deps.db,
+        workspaceId,
+        after,
+        boundedLimit(c.req.query("limit")),
+      ),
+    );
+  });
+
+  app.get("/v1/workspaces/:workspaceId/control-events/stream", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    await requireAccessGrant(c, deps, workspaceId, "workspace:read");
+    const after = Math.max(0, Number.parseInt(c.req.query("after") ?? "0", 10) || 0);
+    return await sseWorkspaceControlStream(deps.db, deps.bus, workspaceId, after, c.req.raw.signal);
+  });
+
   app.put("/v1/workspaces/:workspaceId/default-rig", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "rigs:manage");