@opengeni/core 1.0.1 → 2.2.0-canary.0

package/src/application/session-commands.ts

@@ -16,11 +16,7 @@ import type {
   WorkspaceInferenceControlRequest,
   WorkspaceInferenceControlResponse,
 } from "@opengeni/contracts";
-import {
-  DraftTimelineAnnotations,
-  latencyModeForMetadata,
-  reasoningEffortForMetadata,
-} from "@opengeni/contracts";
+import { DraftTimelineAnnotations } from "@opengeni/contracts";
 import {
   deleteSessionQueueItemInTransaction,
   editQueuedTurnInTransaction,
@@ -39,6 +35,7 @@ import {
   serializeEffectiveSessionControl,
   steerAgentSessionInTransaction,
   steerQueuedTurnInTransaction,
+  workspaceControlRequestLockTimeoutMs,
   withWorkspaceRls,
   withWorkspaceSessionActivityRls,
   withWorkspaceSubjectRls,
@@ -185,18 +182,68 @@ async function runSessionCommandPersistenceTransaction<T>(
   );
 }
 
-async function publishAndWakeAgentCommand(
+type SessionCommandPostCommitDeps = {
+  /** Historical name; now schedules replayable follow-up for every interactive session command. */
+  schedulePromptPostCommit?: ((task: () => Promise<void>) => void) | undefined;
+};
+
+type SessionCommandPostCommitStep = {
+  kind: "session_event_fanout" | "workspace_control_fanout" | "workflow_wake";
+  run: () => Promise<void>;
+};
+
+/**
+ * A committed interactive command must never wait for ephemeral fanout or an
+ * immediate Temporal nudge. Durable events and wake outboxes are the recovery
+ * contract; these steps only reduce propagation latency.
+ */
+function scheduleSessionCommandPostCommit(
+  deps: SessionCommandPostCommitDeps,
+  operation: string,
+  steps: SessionCommandPostCommitStep[],
+): void {
+  const task = async () => {
+    await Promise.all(
+      steps.map(async (step) => {
+        try {
+          await step.run();
+        } catch {
+          console.warn("[session-commands] replayable post-commit step failed", {
+            errorClass: "SessionCommandPostCommitError",
+            errorCode: "session_command_post_commit_failed",
+            origin: "core",
+            operation,
+            step: step.kind,
+          });
+        }
+      }),
+    );
+  };
+  try {
+    const schedule =
+      deps.schedulePromptPostCommit ??
+      ((pending: () => Promise<void>) => {
+        void pending();
+      });
+    schedule(task);
+  } catch {
+    console.warn("[session-commands] post-commit scheduling failed", {
+      errorClass: "SessionCommandPostCommitScheduleError",
+      errorCode: "session_command_post_commit_schedule_failed",
+      origin: "core",
+      operation,
+    });
+  }
+}
+
+async function wakeSessionCommand(
   deps: {
-    db: Database;
-    bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
-    sessionAuthorization?: SessionAuthorizationPort | null;
   },
   input: {
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    eventIds: string[];
     workflowId: string;
     wakeRevision: number | null;
     shouldSignal: boolean;
@@ -204,7 +251,6 @@ async function publishAndWakeAgentCommand(
     controlRequested?: boolean;
   },
 ): Promise<void> {
-  await publishSessionEventIds(deps, input.workspaceId, input.sessionId, input.eventIds);
   if (!input.shouldSignal || input.wakeRevision === null) return;
   try {
     await deps.workflowClient.wakeSessionWorkflow({
@@ -218,14 +264,11 @@ async function publishAndWakeAgentCommand(
         : {}),
     });
   } catch {
-    console.warn(
-      "[session-commands] immediate Agent command wake failed; durable outbox will retry",
-      {
-        errorClass: "WorkflowWakeOperationError",
-        errorCode: "agent_command_wake_failed",
-        origin: "core",
-      },
-    );
+    console.warn("[session-commands] immediate command wake failed; durable outbox will retry", {
+      errorClass: "WorkflowWakeOperationError",
+      errorCode: "session_command_wake_failed",
+      origin: "core",
+    });
   }
 }
 
@@ -293,7 +336,7 @@ export async function sendAgentSessionMessage(
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: AgentSessionCommandContext,
   input: { targetSessionId: string; text: string; idempotencyKey: string },
 ) {
@@ -312,20 +355,44 @@ export async function sendAgentSessionMessage(
           actor: agentActor(context),
           operationKey: input.idempotencyKey,
           text: input.text,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
-  await publishAndWakeAgentCommand(deps, {
-    accountId: context.accountId,
-    workspaceId: context.workspaceId,
-    sessionId: input.targetSessionId,
-    eventIds: result.eventIds,
-    workflowId: result.workflowId,
-    wakeRevision: result.wakeRevision,
-    shouldSignal: result.shouldSignal,
-    interruptionCount: 0,
-  });
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  scheduleSessionCommandPostCommit(deps, "agent_message", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(
+          deps,
+          context.workspaceId,
+          input.targetSessionId,
+          result.eventIds,
+        ),
+    },
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () =>
+        await wakeSessionCommand(deps, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: input.targetSessionId,
+          workflowId: result.workflowId,
+          wakeRevision: result.wakeRevision,
+          shouldSignal: result.shouldSignal,
+          interruptionCount: 0,
+        }),
+    },
+  ]);
   return result;
 }
 
@@ -335,7 +402,7 @@ export async function steerAgentSession(
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: AgentSessionCommandContext,
   input: {
     targetSessionId: string;
@@ -358,21 +425,45 @@ export async function steerAgentSession(
           actor: agentActor(context),
           operationKey: input.idempotencyKey,
           instruction: input.instruction,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
-  await publishAndWakeAgentCommand(deps, {
-    accountId: context.accountId,
-    workspaceId: context.workspaceId,
-    sessionId: input.targetSessionId,
-    eventIds: result.eventIds,
-    workflowId: result.workflowId,
-    wakeRevision: result.wakeRevision,
-    shouldSignal: result.shouldSignal,
-    interruptionCount: result.interruptionCount,
-    controlRequested: true,
-  });
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  scheduleSessionCommandPostCommit(deps, "agent_steer", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(
+          deps,
+          context.workspaceId,
+          input.targetSessionId,
+          result.eventIds,
+        ),
+    },
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () =>
+        await wakeSessionCommand(deps, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: input.targetSessionId,
+          workflowId: result.workflowId,
+          wakeRevision: result.wakeRevision,
+          shouldSignal: result.shouldSignal,
+          interruptionCount: result.interruptionCount,
+          controlRequested: true,
+        }),
+    },
+  ]);
   return result;
 }
 
@@ -380,9 +471,12 @@ export async function controlAgentSessionWorkstream(
   deps: {
     db: Database;
     bus: EventBus;
-    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    workflowClient: Pick<
+      SessionWorkflowClient,
+      "requestSessionWorkflowWakeDispatch" | "wakeSessionWorkflow"
+    >;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: AgentSessionCommandContext,
   input: {
     targetSessionId: string;
@@ -412,14 +506,48 @@ export async function controlAgentSessionWorkstream(
           operationKey: input.idempotencyKey,
           action: input.action,
           reason: input.reason ?? null,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
-  await publishSessionEventIds(deps, context.workspaceId, input.targetSessionId, [
-    result.sessionControlEventId,
+  scheduleSessionCommandPostCommit(deps, "agent_control", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, input.targetSessionId, [
+          result.sessionControlEventId,
+        ]),
+    },
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () => await requestControlWakeDispatch(deps, result.wakeCount),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () => {
+        if (!result.workflowWake) return;
+        await wakeSessionCommand(deps, {
+          accountId: result.workflowWake.accountId,
+          workspaceId: result.workflowWake.workspaceId,
+          sessionId: result.workflowWake.sessionId,
+          workflowId: result.workflowWake.temporalWorkflowId,
+          wakeRevision: result.workflowWake.wakeRevision,
+          shouldSignal: true,
+          interruptionCount: result.interruptionCount,
+          controlRequested: true,
+        });
+      },
+    },
   ]);
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
-  await requestControlWakeDispatch(deps, result.wakeCount);
   return { ...result, authorization };
 }
 
@@ -479,7 +607,7 @@ export async function moveHumanQueuePrompt(
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: MoveSessionQueueItemRequest,
@@ -499,6 +627,7 @@ export async function moveHumanQueuePrompt(
           expectedQueueVersion: input.expectedQueueVersion,
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -511,7 +640,13 @@ export async function moveHumanQueuePrompt(
       authorization?.relatedSessionAccess ?? "root",
     ),
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  scheduleSessionCommandPostCommit(deps, "human_queue_move", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+  ]);
   return response;
 }
 
@@ -520,7 +655,7 @@ export async function deleteHumanQueuePrompt(
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: DeleteSessionQueueItemRequest,
@@ -540,6 +675,7 @@ export async function deleteHumanQueuePrompt(
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
           reason: input.reason ?? null,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -552,7 +688,13 @@ export async function deleteHumanQueuePrompt(
       authorization?.relatedSessionAccess ?? "root",
     ),
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  scheduleSessionCommandPostCommit(deps, "human_queue_delete", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+  ]);
   return response;
 }
 
@@ -561,7 +703,7 @@ export async function editHumanQueuePrompt(
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: EditSessionQueueItemRequest,
@@ -582,6 +724,7 @@ export async function editHumanQueuePrompt(
           replaceDraft: input.replaceDraft,
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -595,7 +738,13 @@ export async function editHumanQueuePrompt(
     ),
     draft: composerDraft(result.draft)!,
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  scheduleSessionCommandPostCommit(deps, "human_queue_edit", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+  ]);
   return response;
 }
 
@@ -603,8 +752,9 @@ export async function steerHumanQueuePrompt(
   deps: {
     db: Database;
     bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: SteerSessionQueueItemRequest,
@@ -624,6 +774,7 @@ export async function steerHumanQueuePrompt(
           controlEtag: input.controlEtag ?? null,
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -636,8 +787,36 @@ export async function steerHumanQueuePrompt(
       authorization?.relatedSessionAccess ?? "root",
     ),
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  scheduleSessionCommandPostCommit(deps, "human_queue_steer", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () =>
+        await wakeSessionCommand(deps, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: context.sessionId,
+          workflowId: result.workflowId,
+          wakeRevision: result.wakeRevision,
+          shouldSignal: true,
+          interruptionCount: result.interruptionCount,
+          controlRequested: true,
+        }),
+    },
+  ]);
   return response;
 }
 
@@ -645,9 +824,12 @@ export async function controlHumanSessionWorkstreamWithOutcome(
   deps: {
     db: Database;
     bus: EventBus;
-    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    workflowClient: Pick<
+      SessionWorkflowClient,
+      "requestSessionWorkflowWakeDispatch" | "wakeSessionWorkflow"
+    >;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   input: SessionControlRequest,
 ): Promise<{ response: SessionControlResponse; replay: boolean }> {
@@ -670,6 +852,7 @@ export async function controlHumanSessionWorkstreamWithOutcome(
           action: input.action,
           reason: input.reason ?? null,
           expectedControlEtag: input.expectedControlEtag ?? null,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -685,11 +868,47 @@ export async function controlHumanSessionWorkstreamWithOutcome(
     cancelledSessionCount: result.cancelledSessionCount,
     cancelledTurnCount: result.cancelledTurnCount,
   };
-  for (const affected of result.affectedSessionEvents) {
-    await publishSessionEventIds(deps, context.workspaceId, affected.sessionId, affected.eventIds);
-  }
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
-  await requestControlWakeDispatch(deps, result.wakeCount);
+  scheduleSessionCommandPostCommit(deps, "human_control", [
+    ...result.affectedSessionEvents.map((affected) => ({
+      kind: "session_event_fanout" as const,
+      run: async () =>
+        await publishSessionEventIds(
+          deps,
+          context.workspaceId,
+          affected.sessionId,
+          affected.eventIds,
+        ),
+    })),
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () => await requestControlWakeDispatch(deps, result.wakeCount),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () => {
+        if (!result.workflowWake) return;
+        await wakeSessionCommand(deps, {
+          accountId: result.workflowWake.accountId,
+          workspaceId: result.workflowWake.workspaceId,
+          sessionId: result.workflowWake.sessionId,
+          workflowId: result.workflowWake.temporalWorkflowId,
+          wakeRevision: result.workflowWake.wakeRevision,
+          shouldSignal: true,
+          interruptionCount: result.interruptionCount,
+          controlRequested: true,
+        });
+      },
+    },
+  ]);
   return { response, replay: result.replay };
 }
 
@@ -707,7 +926,7 @@ export async function controlHumanWorkspace(
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
-  },
+  } & SessionCommandPostCommitDeps,
   context: Omit<HumanSessionCommandContext, "sessionId">,
   input: WorkspaceInferenceControlRequest,
 ): Promise<WorkspaceInferenceControlResponse> {
@@ -721,6 +940,7 @@ export async function controlHumanWorkspace(
         action: input.action,
         reason: input.reason ?? null,
         expectedRevision: input.expectedRevision ?? null,
+        controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
       }),
     ),
   );
@@ -731,8 +951,21 @@ export async function controlHumanWorkspace(
     interruptionCount: result.interruptionCount,
     wakeCount: result.wakeCount,
   };
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
-  await requestControlWakeDispatch(deps, result.wakeCount);
+  scheduleSessionCommandPostCommit(deps, "human_workspace_control", [
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () => await requestControlWakeDispatch(deps, result.wakeCount),
+    },
+  ]);
   return response;
 }
 
@@ -762,8 +995,8 @@ export async function getHumanComposerDraft(
     annotations: [],
     resources: [],
     model: session.model,
-    reasoningEffort: reasoningEffortForMetadata(session.metadata, "medium"),
-    latencyMode: latencyModeForMetadata(session.metadata, "standard"),
+    reasoningEffort: session.reasoningEffort,
+    latencyMode: session.latencyMode,
     sourceTurnId: null,
     sourceTurnVersion: null,
     updatedAt: null,
@@ -794,6 +1027,7 @@ export async function saveHumanComposerDraft(
           annotations,
           resources: normalizeResources(input.resources),
           subjectId: context.subjectId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
       ),
   );