@opengeni/db 0.27.7 → 0.27.8

package/dist/index.d.ts

@@ -6375,6 +6375,7 @@ export type RequestSessionTurnRecoveryInput = {
     attemptId: string;
     reason: string;
     detail?: Record<string, unknown>;
+    providerRecoveryCount?: number;
     fromStatuses?: SessionTurnStatus[];
     providerArtifactInvalidation?: {
         codexCredentialId: string;
@@ -6501,6 +6502,7 @@ export declare function enqueueSessionWorkflowWakeInTransaction(tx: Database, in
     temporalWorkflowId: string;
     reason: string;
     notBefore?: Date;
+    controlRequested?: boolean;
 }): Promise<number>;
 /** Standalone transactional producer for operations not already in a DB txn. */
 export declare function enqueueSessionWorkflowWake(db: Database, input: {
@@ -6510,6 +6512,7 @@ export declare function enqueueSessionWorkflowWake(db: Database, input: {
     temporalWorkflowId: string;
     reason: string;
     notBefore?: Date;
+    controlRequested?: boolean;
 }): Promise<number>;
 /**
  * Re-deliver already-committed session work only when admission currently
@@ -6523,6 +6526,7 @@ export declare function enqueueSessionWorkflowWakeIfRunnable(db: Database, input
     temporalWorkflowId: string;
     reason: string;
     notBefore?: Date;
+    controlRequested?: boolean;
 }): Promise<number | null>;
 /** Claim only explicit, undelivered wake revisions; never infer work by scan. */
 export declare function claimPendingSessionWorkflowWakes(db: Database, limit?: number): Promise<SessionWorkflowWake[]>;

package/dist/index.js

@@ -114,7 +114,7 @@ import {
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces
-} from "./chunk-EX7CDSGH.js";
+} from "./chunk-M6EOXYHK.js";
 import {
   migrate,
   runMigrations
@@ -2319,12 +2319,13 @@ async function registerContinuableWakes(db, input) {
       )
     ), upserted as (
       insert into ${sessionWorkflowWakeOutbox} (
-        session_id, account_id, workspace_id, temporal_workflow_id, reason
+        session_id, account_id, workspace_id, temporal_workflow_id, reason, control_revision
       )
-      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}
+      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}, 1
       from eligible
       on conflict (session_id) do update set
         wake_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        control_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
         temporal_workflow_id = excluded.temporal_workflow_id,
         reason = excluded.reason,
         attempts = 0,
@@ -2405,12 +2406,13 @@ async function registerCancellationWakes(db, input) {
         and session.id in (${sessionIds})
     ), upserted as (
       insert into ${sessionWorkflowWakeOutbox} (
-        session_id, account_id, workspace_id, temporal_workflow_id, reason
+        session_id, account_id, workspace_id, temporal_workflow_id, reason, control_revision
       )
-      select session_id, account_id, workspace_id, temporal_workflow_id, 'session_cancelled'
+      select session_id, account_id, workspace_id, temporal_workflow_id, 'session_cancelled', 1
       from eligible
       on conflict (session_id) do update set
         wake_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        control_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
         temporal_workflow_id = excluded.temporal_workflow_id,
         reason = excluded.reason,
         attempts = 0,
@@ -2429,12 +2431,14 @@ async function registerSessionWorkflowWakeInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: input.temporalWorkflowId,
+    controlRevision: input.controlRequested ? 1 : 0,
     reason: input.reason
   }).onConflictDoUpdate({
     target: sessionWorkflowWakeOutbox.sessionId,
     set: {
       temporalWorkflowId: input.temporalWorkflowId,
       wakeRevision: sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
+      controlRevision: input.controlRequested ? sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql3`${sessionWorkflowWakeOutbox.controlRevision}`,
       reason: input.reason,
       attempts: 0,
       nextAttemptAt: /* @__PURE__ */ new Date(),
@@ -4206,7 +4210,8 @@ async function steerQueuedTurnInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: session.temporalWorkflowId ?? `session-${input.sessionId}`,
-    reason: "queue_steer"
+    reason: "queue_steer",
+    controlRequested: true
   });
   const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
     controlRevision: resumed.revision,
@@ -4626,7 +4631,8 @@ async function submitHumanPromptInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: workflowId,
-    reason: input.delivery === "steer" ? "prompt_steer" : "prompt_send"
+    reason: input.delivery === "steer" ? "prompt_steer" : "prompt_send",
+    controlRequested: input.delivery === "steer"
   });
   await db.insert(auditEvents).values({
     accountId: input.accountId,
@@ -5011,7 +5017,8 @@ async function steerAgentSessionInTransaction(db, input) {
     workspaceId: input.workspaceId,
     sessionId: input.targetSessionId,
     temporalWorkflowId: workflowId,
-    reason: "agent_steer"
+    reason: "agent_steer",
+    controlRequested: true
   });
   await db.update(sessions).set({
     activeTurnId: supersession.liveCurrentTurnId,
@@ -35641,7 +35648,8 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
             "pending",
             "delivered",
             "acknowledged",
-            "settled"
+            "settled",
+            "rejected_stale"
           ]),
           isNull6(sessionTurnAttempts.quiescedAt)
         )
@@ -36334,24 +36342,6 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           turn: mapSessionTurnForExecution(internalTurn)
         };
       }
-      const predecessorAttemptId = queuedSteerReplacementAttemptId(queuedTurn.metadata);
-      if (predecessorAttemptId) {
-        const [predecessor] = await tx.select({ quiescedAt: sessionTurnAttempts.quiescedAt }).from(sessionTurnAttempts).where(
-          and17(
-            eq17(sessionTurnAttempts.workspaceId, workspaceId),
-            eq17(sessionTurnAttempts.sessionId, sessionId),
-            eq17(sessionTurnAttempts.id, predecessorAttemptId)
-          )
-        ).limit(1);
-        if (!predecessor) {
-          throw new SessionControlInvariantError(
-            `Queued Steer ${id} points to missing predecessor attempt ${predecessorAttemptId}`
-          );
-        }
-        if (!predecessor.quiescedAt) {
-          return { action: "unclaimed", reason: "control-pending" };
-        }
-      }
       const now = /* @__PURE__ */ new Date();
       const queuedDispatch = readTurnDispatchMetadata(queuedTurn?.metadata);
       if (queuedDispatch.kind === "malformed") {
@@ -36776,6 +36766,14 @@ async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, att
             interruptions.map((interruption) => interruption.id)
           )
         );
+        await enqueueSessionWorkflowWakeInTransaction(tx, {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId,
+          temporalWorkflowId: session.temporalWorkflowId ?? `session-${sessionId}`,
+          reason: "attempt_interruption_rejected_stale",
+          controlRequested: true
+        });
         return {
           action: effectiveControl.state === "paused" ? "paused" : "continue",
           events: [],
@@ -36926,6 +36924,14 @@ async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, att
           interruptions.map((interruption) => interruption.id)
         )
       );
+      await enqueueSessionWorkflowWakeInTransaction(tx, {
+        accountId: session.accountId,
+        workspaceId,
+        sessionId,
+        temporalWorkflowId: session.temporalWorkflowId ?? `session-${sessionId}`,
+        reason: "attempt_interruption_settled",
+        controlRequested: true
+      });
       return {
         action: effectiveControl.state === "paused" ? "paused" : "continue",
         events: [...closedTools.events, ...eventRows.map(mapEvent2)],
@@ -36936,6 +36942,30 @@ async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, att
     })
   );
 }
+async function nextSessionAttemptAwaitingQuiescence(db, workspaceId, sessionId) {
+  const [row] = await db.select({
+    attemptId: sessionTurnAttempts.id
+  }).from(sessionTurnAttempts).innerJoin(
+    sessionAttemptInterruptions,
+    and17(
+      eq17(sessionAttemptInterruptions.workspaceId, sessionTurnAttempts.workspaceId),
+      eq17(sessionAttemptInterruptions.sessionId, sessionTurnAttempts.sessionId),
+      eq17(sessionAttemptInterruptions.attemptId, sessionTurnAttempts.id)
+    )
+  ).where(
+    and17(
+      eq17(sessionTurnAttempts.workspaceId, workspaceId),
+      eq17(sessionTurnAttempts.sessionId, sessionId),
+      eq17(sessionTurnAttempts.state, "closed"),
+      isNull6(sessionTurnAttempts.quiescedAt),
+      inArray11(sessionAttemptInterruptions.state, ["settled", "rejected_stale"])
+    )
+  ).orderBy(
+    asc8(sessionAttemptInterruptions.requestedAt),
+    asc8(sessionAttemptInterruptions.id)
+  ).limit(1);
+  return row ?? null;
+}
 async function latestSessionAttemptInterruption(db, workspaceId, sessionId) {
   const [latestAttempt] = await db.select({
     attemptId: sessionTurnAttempts.id,
@@ -36962,6 +36992,32 @@ async function latestSessionAttemptInterruption(db, workspaceId, sessionId) {
     interruptionState: interruption.state
   } : null;
 }
+async function queuedSteerHasUnquiescedPredecessor(db, workspaceId, sessionId, predecessorAttemptIds) {
+  if (predecessorAttemptIds.length === 0) return false;
+  const [row] = await db.select({ attemptId: sessionTurnAttempts.id }).from(sessionTurnAttempts).innerJoin(
+    sessionAttemptInterruptions,
+    and17(
+      eq17(sessionAttemptInterruptions.workspaceId, sessionTurnAttempts.workspaceId),
+      eq17(sessionAttemptInterruptions.sessionId, sessionTurnAttempts.sessionId),
+      eq17(sessionAttemptInterruptions.attemptId, sessionTurnAttempts.id)
+    )
+  ).where(
+    and17(
+      eq17(sessionTurnAttempts.workspaceId, workspaceId),
+      eq17(sessionTurnAttempts.sessionId, sessionId),
+      inArray11(sessionTurnAttempts.id, predecessorAttemptIds),
+      isNull6(sessionTurnAttempts.quiescedAt),
+      inArray11(sessionAttemptInterruptions.state, [
+        "pending",
+        "delivered",
+        "acknowledged",
+        "settled",
+        "rejected_stale"
+      ])
+    )
+  ).limit(1);
+  return row !== void 0;
+}
 async function peekSessionWork(db, workspaceId, sessionId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const effectiveControl = await evaluateSessionControl(scopedDb, workspaceId, sessionId, {
@@ -36990,15 +37046,15 @@ async function peekSessionWork(db, workspaceId, sessionId) {
       };
     }
     if (effectiveControl.state !== "active") return { kind: "idle" };
-    const latestInterruption = await latestSessionAttemptInterruption(
+    const awaitingQuiescence = await nextSessionAttemptAwaitingQuiescence(
       scopedDb,
       workspaceId,
       sessionId
     );
-    if (latestInterruption && latestInterruption.quiescedAt === null && latestInterruption.interruptionState === "settled") {
+    if (awaitingQuiescence) {
       return {
         kind: "cancellation-wait",
-        attemptId: latestInterruption.attemptId
+        attemptId: awaitingQuiescence.attemptId
       };
     }
     const [capacityWait] = await scopedDb.select().from(codexCapacityWaiters).where(
@@ -38325,7 +38381,19 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
         { workspaceControl: locks.control ?? void 0 }
       );
       const turnStatus = turn?.status ?? null;
-      if (!locks.workspace || !turn || !attempt || turn.accountId !== session.accountId || turn.sessionId !== input.sessionId || attempt.accountId !== session.accountId || attempt.sessionId !== input.sessionId || attempt.turnId !== input.turnId || attempt.executionGeneration !== turn.executionGeneration || effectiveControl.state !== "active" || session.activeTurnId !== input.turnId || !fromStatuses.includes(turnStatus) || turn.activeAttemptId !== input.attemptId) {
+      const [pendingInterruption] = attempt ? await tx.select({ id: sessionAttemptInterruptions.id }).from(sessionAttemptInterruptions).where(
+        and17(
+          eq17(sessionAttemptInterruptions.workspaceId, workspaceId),
+          eq17(sessionAttemptInterruptions.sessionId, input.sessionId),
+          eq17(sessionAttemptInterruptions.attemptId, input.attemptId),
+          inArray11(sessionAttemptInterruptions.state, [
+            "pending",
+            "delivered",
+            "acknowledged"
+          ])
+        )
+      ).limit(1).for("update") : [];
+      if (!locks.workspace || !turn || !attempt || turn.accountId !== session.accountId || turn.sessionId !== input.sessionId || attempt.accountId !== session.accountId || attempt.sessionId !== input.sessionId || attempt.turnId !== input.turnId || attempt.executionGeneration !== turn.executionGeneration || effectiveControl.state !== "active" || session.activeTurnId !== input.turnId || !fromStatuses.includes(turnStatus) || turn.activeAttemptId !== input.attemptId || pendingInterruption !== void 0) {
         return {
           action: "stale",
           events: [],
@@ -38334,6 +38402,9 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
         };
       }
       const now = /* @__PURE__ */ new Date();
+      if (input.providerRecoveryCount !== void 0 && (!Number.isSafeInteger(input.providerRecoveryCount) || input.providerRecoveryCount <= 0)) {
+        throw new Error("providerRecoveryCount must be a positive safe integer");
+      }
       let providerArtifactsInvalidated = 0;
       if (input.providerArtifactInvalidation) {
         const invalidatedHistory = await tx.update(sessionHistoryItems).set({
@@ -38451,7 +38522,10 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
         cancelledBy: null,
         cancelReason: null,
         version: turn.version + 1,
-        metadata: metadataWithoutTurnDispatchAttempt(turn.metadata),
+        metadata: {
+          ...metadataWithoutTurnDispatchAttempt(turn.metadata),
+          ...input.providerRecoveryCount !== void 0 ? { providerRecoveryCount: input.providerRecoveryCount } : {}
+        },
         updatedAt: now
       }).where(
         and17(
@@ -38880,12 +38954,19 @@ async function getSessionQueueSnapshot(db, workspaceId, sessionId) {
       asc8(sessionSystemUpdates.createdAt),
       asc8(sessionSystemUpdates.id)
     );
+    const items = rows.map(mapSessionTurn);
     const latestInterruption = await latestSessionAttemptInterruption(
       scopedDb,
       workspaceId,
       sessionId
     );
-    const items = rows.map(mapSessionTurn);
+    const queuedSteerPredecessorIds = items.map((turn) => queuedSteerReplacementAttemptId(turn.metadata)).filter((attemptId) => attemptId !== null);
+    const stoppingPreviousAttempt = latestInterruption !== null && latestInterruption.interruptionState !== "rejected_stale" && latestInterruption.quiescedAt === null || await queuedSteerHasUnquiescedPredecessor(
+      scopedDb,
+      workspaceId,
+      sessionId,
+      queuedSteerPredecessorIds
+    );
     const nextInputBatch = selectBoundedSystemUpdateBatch(pendingInputs);
     const hasPendingAgentSteer = pendingInputs.some(
       (update) => update.kind === "agent_steer_instruction"
@@ -38895,7 +38976,7 @@ async function getSessionQueueSnapshot(db, workspaceId, sessionId) {
       version: session.queueVersion,
       effectiveControl: serializeEffectiveSessionControl(effectiveControl),
       activePersonalConnections,
-      stoppingPreviousAttempt: latestInterruption !== null && latestInterruption.interruptionState !== "rejected_stale" && latestInterruption.quiescedAt === null,
+      stoppingPreviousAttempt,
       items,
       pendingInputs: pendingInputs.map((update) => {
         const canonical = mapSessionSystemUpdate(update);
@@ -38924,7 +39005,7 @@ function queuedSteerReplacementAttemptId(metadata) {
   if (typeof attemptId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(attemptId) && typeof interruptionCount === "number" && Number.isSafeInteger(interruptionCount) && interruptionCount > 0) {
     return attemptId;
   }
-  throw new SessionControlInvariantError("Queued Steer has malformed predecessor metadata");
+  return null;
 }
 async function enqueueFailedChildOutboxForTurnTx(tx, workspaceId, session, turn) {
   if (!session.parentSessionId) return;
@@ -39045,6 +39126,7 @@ async function enqueueSessionWorkflowWakeInTransaction(tx, input) {
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: input.temporalWorkflowId,
+    controlRevision: input.controlRequested ? 1 : 0,
     reason: input.reason,
     nextAttemptAt
   }).onConflictDoUpdate({
@@ -39052,6 +39134,7 @@ async function enqueueSessionWorkflowWakeInTransaction(tx, input) {
     set: {
       temporalWorkflowId: input.temporalWorkflowId,
       wakeRevision: sql14`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
+      controlRevision: input.controlRequested ? sql14`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql14`${sessionWorkflowWakeOutbox.controlRevision}`,
       reason: input.reason,
       attempts: 0,
       // Coalescing a delayed retry must never postpone an already-due wake