@opengeni/db 0.36.0 → 0.36.1

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   canonicalSessionVisibilityTransitionHash,
   forkSessionContent,
   transitionSessionVisibility
-} from "./chunk-F32YT7MP.js";
+} from "./chunk-FPVAD4CO.js";
 import {
   migrate,
   runMigrations
@@ -39,7 +39,7 @@ import {
   getCanonicalHumanIdentityProjection,
   synchronizeCanonicalHumanLoginBindings,
   validateCanonicalHumanSession
-} from "./chunk-TAUTWOS5.js";
+} from "./chunk-GYO7ED2Q.js";
 import {
   EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
   EDITABLE_ARTIFACT_KERNEL_TAIL_MAX_BYTES,
@@ -50,7 +50,7 @@ import {
   PostgresEditableArtifactStore,
   listEditableArtifactIdsForSession,
   touchEditableArtifactSessionLink
-} from "./chunk-P3RE4D2B.js";
+} from "./chunk-HSOWSYOX.js";
 import {
   ACTIVE_VIDEO_GENERATION_STATUSES,
   VideoGenerationCapacityError,
@@ -82,7 +82,7 @@ import {
   settleVideoGenerationFailure,
   settleVideoGenerationReady,
   updateWorkspaceVideoGenerationPolicy
-} from "./chunk-CQZ4QSP5.js";
+} from "./chunk-VTPRIXKG.js";
 import {
   SandboxProviderReadLockUnavailableError,
   SessionEventPersistenceError,
@@ -90,6 +90,7 @@ import {
   databaseFailureCode,
   dbBindingFor,
   isDatabasePersistenceFailure,
+  isRetryableDatabaseTransportFailure,
   isRetryablePersistenceSqlState,
   isSessionEventPersistenceError,
   nestedPostgresSqlState,
@@ -116,7 +117,7 @@ import {
   withWorkspaceSubjectRls,
   withWorkspaceSubjectSessionActivityRls,
   withWorkspaceUsageLock
-} from "./chunk-JC5QPLUM.js";
+} from "./chunk-Z7VYMNPZ.js";
 import {
   LOSSLESS_CONTENT_CODEC_VERSION,
   LOSSLESS_TEXT_PREFIX,
@@ -59876,7 +59877,7 @@ async function materializeGoalContinuation(db, input) {
           eq43(sessionGoals.sessionId, input.sessionId)
         )
       ).for("update").limit(1);
-      if (!goalRead || goalRead.status !== "active" || session.status === "cancelled" || effectiveControl.state !== "active") {
+      if (!goalRead || goalRead.status !== "active" || session.status === "failed" || session.status === "cancelled" || effectiveControl.state !== "active") {
         return { action: "none", events: [] };
       }
       const malformedGoalVersionEvidence = sql39`
@@ -60870,9 +60871,14 @@ async function goalSnapshotForAcceptedTurnInTransaction(tx, row) {
 }
 async function claimSessionWorkForAttempt(db, workspaceId, input) {
   const { sessionId, workflowId } = input;
-  return await withWorkspaceSessionActivityRls(
+  return await retrySessionActivityRls(
     db,
     workspaceId,
+    {
+      stage: "session_attempts.claim",
+      eventTypes: ["session.turn.attempt_claimed"],
+      maxAttempts: 3
+    },
     async (scopedDb) => await withSessionActivitySavepoint(scopedDb, async (tx) => {
       const deliverPendingUpdates = async (accountId, turnId, turnGeneration, nextSequence, occurredAt, triggerEventId, expectedXaiAuthority) => {
         const [agentSteer] = await tx.select().from(sessionSystemUpdates).where(
@@ -63026,6 +63032,317 @@ async function peekSessionWork(db, workspaceId, sessionId) {
     return pendingAgentSteer ? { kind: "runnable" } : { kind: "idle" };
   });
 }
+async function failSessionWorkBeforeAttemptClaim(db, workspaceId, input) {
+  return await retrySessionActivityRls(
+    db,
+    workspaceId,
+    {
+      stage: "session_lifecycle_outbox.fail_before_attempt_claim",
+      eventTypes: ["child_terminal_result", "session.status.changed", "turn.failed"],
+      maxAttempts: 3
+    },
+    async (scopedDb) => await scopedDb.transaction(async (tx) => {
+      const baseLocks = await lockChildLifecycleOutboxWriteRowsTx(
+        tx,
+        workspaceId,
+        { sessionId: input.sessionId }
+      );
+      const session = baseLocks.session;
+      if (session.accountId !== input.accountId) {
+        throw new SessionControlInvariantError(
+          `Session ${input.sessionId} does not belong to account ${input.accountId}`
+        );
+      }
+      if (session.status === "failed" || session.status === "cancelled") {
+        return { action: "terminal", turnId: null, events: [] };
+      }
+      if (session.temporalWorkflowId !== null && session.temporalWorkflowId !== input.workflowId) {
+        return { action: "stale", turnId: null, events: [] };
+      }
+      const effectiveControl = await evaluateSessionControl(
+        tx,
+        workspaceId,
+        input.sessionId,
+        { workspaceControl: baseLocks.control ?? void 0 }
+      );
+      if (!baseLocks.workspace || effectiveControl.state !== "active") {
+        return { action: "stale", turnId: null, events: [] };
+      }
+      const [liveAttempt] = await tx.select({ id: sessionTurnAttempts.id }).from(sessionTurnAttempts).where(
+        and42(
+          eq43(sessionTurnAttempts.workspaceId, workspaceId),
+          eq43(sessionTurnAttempts.sessionId, input.sessionId),
+          inArray25(sessionTurnAttempts.state, ["claimed", "running"])
+        )
+      ).limit(1);
+      if (liveAttempt) {
+        return { action: "stale", turnId: null, events: [] };
+      }
+      let turn = null;
+      if (session.activeTurnId) {
+        const exactLocks = await lockSessionEventWriteRows(tx, {
+          workspaceId,
+          controlLock: "already_locked",
+          workspaceLock: "already_locked",
+          turnIds: [session.activeTurnId]
+        });
+        turn = exactLocks.turns[0] ?? null;
+        if (!turn || turn.accountId !== session.accountId || turn.sessionId !== input.sessionId) {
+          turn = null;
+        }
+        if (turn && isTerminalSessionTurnStatus(turn.status)) {
+          turn = null;
+        } else if (turn && input.trigger.kind === "approval") {
+          if (turn.status !== "requires_action" || !await isNewerApprovalTrigger(
+            tx,
+            workspaceId,
+            input.sessionId,
+            turn.triggerEventId,
+            input.trigger.triggerEventId
+          )) {
+            return { action: "stale", turnId: null, events: [] };
+          }
+        } else if (turn) {
+          if (turn.status === "requires_action") {
+            return { action: "stale", turnId: null, events: [] };
+          }
+          if (turn.status === "waiting_capacity") {
+            const [codexWaiter] = await tx.select({ id: codexCapacityWaiters.id }).from(codexCapacityWaiters).where(
+              and42(
+                eq43(codexCapacityWaiters.workspaceId, workspaceId),
+                eq43(codexCapacityWaiters.sessionId, input.sessionId),
+                eq43(codexCapacityWaiters.status, "waiting")
+              )
+            ).limit(1);
+            const xaiWaiter = await getXaiCapacityWaitForSessionInTransaction(
+              tx,
+              workspaceId,
+              input.sessionId
+            );
+            if (codexWaiter || xaiWaiter) {
+              return { action: "stale", turnId: null, events: [] };
+            }
+          }
+        }
+      } else {
+        if (input.trigger.kind === "approval") {
+          return { action: "stale", turnId: null, events: [] };
+        }
+        const [pendingAgentSteer] = await tx.select({ id: sessionSystemUpdates.id }).from(sessionSystemUpdates).where(
+          and42(
+            eq43(sessionSystemUpdates.workspaceId, workspaceId),
+            eq43(sessionSystemUpdates.sessionId, input.sessionId),
+            eq43(sessionSystemUpdates.kind, "agent_steer_instruction"),
+            eq43(sessionSystemUpdates.state, "pending")
+          )
+        ).orderBy(
+          desc17(sessionSystemUpdates.createdAt),
+          desc17(sessionSystemUpdates.id)
+        ).limit(1);
+        const queuedRows = await rawRows(
+          tx,
+          sql39`select id from session_turns
+                where workspace_id = ${workspaceId} and session_id = ${input.sessionId}
+                  and status = 'queued' and source in ('user', 'api')
+                  and (
+                    ${Boolean(pendingAgentSteer)} = false
+                    or metadata->>'delivery' = 'steer'
+                  )
+                order by position asc, created_at asc, id asc
+                limit 1`
+        );
+        const queuedPreview = queuedRows[0];
+        if (queuedPreview) {
+          const exactLocks = await lockSessionEventWriteRows(tx, {
+            workspaceId,
+            controlLock: "already_locked",
+            workspaceLock: "already_locked",
+            turnIds: [queuedPreview.id]
+          });
+          turn = exactLocks.turns[0] ?? null;
+          if (!turn || turn.accountId !== session.accountId || turn.sessionId !== input.sessionId || turn.status !== "queued" || turn.activeAttemptId !== null) {
+            return { action: "stale", turnId: null, events: [] };
+          }
+        } else if (!session.compactRequested) {
+          if (!pendingAgentSteer && await latestFinishedTurnHasFailureCodeTx(
+            tx,
+            workspaceId,
+            input.sessionId,
+            "context_compaction_failed"
+          )) {
+            return { action: "stale", turnId: null, events: [] };
+          }
+          const [pendingUpdate] = await tx.select({ id: sessionSystemUpdates.id }).from(sessionSystemUpdates).where(
+            and42(
+              eq43(sessionSystemUpdates.workspaceId, workspaceId),
+              eq43(sessionSystemUpdates.sessionId, input.sessionId),
+              eq43(sessionSystemUpdates.state, "pending")
+            )
+          ).limit(1).for("update");
+          if (!pendingUpdate) {
+            return { action: "stale", turnId: null, events: [] };
+          }
+        }
+      }
+      const now = /* @__PURE__ */ new Date();
+      let sequence = session.lastSequence;
+      let closedToolEvents = [];
+      if (turn) {
+        await cancelTurnInteractionInterventionsInTransaction(tx, {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId: input.sessionId,
+          turnId: turn.id
+        });
+        const closedTools = await closePendingSessionToolCallsInTransaction(
+          tx,
+          {
+            accountId: session.accountId,
+            workspaceId,
+            sessionId: input.sessionId,
+            turnId: turn.id,
+            reason: "turn_failed",
+            sequence,
+            now
+          }
+        );
+        sequence = closedTools.sequence;
+        closedToolEvents = closedTools.events;
+        await tx.update(sessionHumanInputRequests).set({
+          status: "cancelled",
+          response: { outcome: "cancelled" },
+          respondedBy: "system:turn_failed",
+          respondedAt: now,
+          updatedAt: now
+        }).where(
+          and42(
+            eq43(sessionHumanInputRequests.workspaceId, workspaceId),
+            eq43(sessionHumanInputRequests.sessionId, input.sessionId),
+            eq43(sessionHumanInputRequests.turnId, turn.id),
+            eq43(sessionHumanInputRequests.status, "pending")
+          )
+        );
+      }
+      await settleSessionMaintenanceInTransaction(tx, {
+        accountId: session.accountId,
+        workspaceId,
+        sessionId: input.sessionId
+      });
+      if (!turn) {
+        await tx.update(sessionSystemUpdates).set({ state: "failed" }).where(
+          and42(
+            eq43(sessionSystemUpdates.workspaceId, workspaceId),
+            eq43(sessionSystemUpdates.sessionId, input.sessionId),
+            eq43(sessionSystemUpdates.state, "pending")
+          )
+        );
+      }
+      const values = [
+        ...turn ? [
+          {
+            accountId: session.accountId,
+            workspaceId,
+            sessionId: input.sessionId,
+            sequence: ++sequence,
+            type: "turn.failed",
+            payload: {
+              triggerEventId: turn.triggerEventId,
+              code: "pre_claim_failure",
+              error: input.error
+            },
+            turnId: turn.id,
+            turnGeneration: turn.executionGeneration,
+            turnAttemptId: null,
+            turnAssociation: "current",
+            occurredAt: now
+          }
+        ] : [],
+        {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId: input.sessionId,
+          sequence: ++sequence,
+          type: "session.status.changed",
+          payload: { status: "failed", code: "pre_claim_failure" },
+          turnId: turn?.id ?? null,
+          turnGeneration: turn?.executionGeneration ?? null,
+          turnAttemptId: null,
+          turnAssociation: turn ? "current" : null,
+          occurredAt: now
+        }
+      ];
+      const inserted = await tx.insert(sessionEvents).values(withLosslessContentWriteVersion(values, "payload", "payloadCodecVersion")).returning();
+      if (turn) {
+        const failedEvent = inserted.find((event) => event.type === "turn.failed");
+        if (!failedEvent) {
+          throw new SessionControlInvariantError(
+            `Pre-claim failure for turn ${turn.id} has no terminal event`
+          );
+        }
+        await projectSessionRealtimeDelegationTerminalInTransaction(tx, {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId: input.sessionId,
+          turnId: turn.id,
+          turnStatus: "failed",
+          terminalEvent: {
+            id: failedEvent.id,
+            type: "turn.failed",
+            payload: sessionEventPayloadRecord(
+              failedEvent.payload,
+              failedEvent.payloadCodecVersion
+            )
+          },
+          now
+        });
+        await tx.update(sessionTurns).set({
+          status: "failed",
+          activeAttemptId: null,
+          version: turn.version + 1,
+          finishedAt: now,
+          updatedAt: now
+        }).where(
+          and42(
+            eq43(sessionTurns.workspaceId, workspaceId),
+            eq43(sessionTurns.sessionId, input.sessionId),
+            eq43(sessionTurns.id, turn.id)
+          )
+        );
+        await enqueueFailedChildOutboxForTurnTx(
+          tx,
+          workspaceId,
+          session,
+          turn
+        );
+      } else {
+        await enqueueFailedChildOutboxWithoutTurnTx(
+          tx,
+          workspaceId,
+          session,
+          sequence
+        );
+      }
+      await tx.update(sessions).set({
+        status: "failed",
+        activeTurnId: null,
+        compactRequested: false,
+        lastSequence: sequence,
+        queueVersion: session.queueVersion + 1,
+        updatedAt: now
+      }).where(
+        and42(
+          eq43(sessions.workspaceId, workspaceId),
+          eq43(sessions.id, input.sessionId)
+        )
+      );
+      return {
+        action: "failed",
+        turnId: turn?.id ?? null,
+        events: [...closedToolEvents, ...inserted.map(mapEvent2)]
+      };
+    })
+  );
+}
 async function lockChildLifecycleOutboxWriteRowsTx(tx, workspaceId, input) {
   const prefix = await lockSessionEventWriteRows(tx, {
     workspaceId,
@@ -65004,9 +65321,8 @@ function queuedSteerReplacementAttemptId(metadata) {
   }
   return null;
 }
-async function enqueueFailedChildOutboxForTurnTx(tx, workspaceId, session, turn) {
+async function enqueueFailedChildOutboxTx(tx, workspaceId, session, input) {
   if (!session.parentSessionId) return;
-  const dedupeKey = `child-completion:${turn.sessionId}:turn:${turn.id}`;
   const personalConnectionDelegations = session.parentTurnId ? await personalConnectionDelegationsForTurnInTransaction(
     tx,
     workspaceId,
@@ -65038,26 +65354,26 @@ async function enqueueFailedChildOutboxForTurnTx(tx, workspaceId, session, turn)
     withLosslessContentWriteVersion(
       withLosslessContentWriteVersion(
         {
-          accountId: turn.accountId,
+          accountId: session.accountId,
           workspaceId,
-          sourceSessionId: turn.sessionId,
+          sourceSessionId: session.id,
           targetSessionId: session.parentSessionId,
-          dedupeKey,
+          dedupeKey: input.dedupeKey,
           kind: "child_terminal_result",
           classification: "failure",
-          sourceId: turn.sessionId,
+          sourceId: session.id,
           summary: "Child session failed; inspect the durable child timeline.",
           payload: {
             type: "child_terminal_result",
-            childSessionId: turn.sessionId,
+            childSessionId: session.id,
             status: "failed",
-            turnId: turn.id
+            ...input.turnId ? { turnId: input.turnId } : {}
           },
           lineage: {
-            childSessionId: turn.sessionId,
+            childSessionId: session.id,
             parentSessionId: session.parentSessionId,
             ...session.parentTurnId ? { parentTurnId: session.parentTurnId } : {},
-            turnId: turn.id,
+            ...input.turnId ? { turnId: input.turnId } : {},
             ...xaiAuthoritySubjectId ? { xaiAuthoritySubjectId } : {}
           },
           personalConnectionDelegations,
@@ -65076,6 +65392,23 @@ async function enqueueFailedChildOutboxForTurnTx(tx, workspaceId, session, turn)
     ]
   });
 }
+async function enqueueFailedChildOutboxForTurnTx(tx, workspaceId, session, turn) {
+  if (turn.accountId !== session.accountId || turn.sessionId !== session.id) {
+    throw new SessionControlInvariantError(
+      `Failed child turn ${turn.id} lost session ${session.id} ownership`
+    );
+  }
+  await enqueueFailedChildOutboxTx(tx, workspaceId, session, {
+    turnId: turn.id,
+    dedupeKey: `child-completion:${turn.sessionId}:turn:${turn.id}`
+  });
+}
+async function enqueueFailedChildOutboxWithoutTurnTx(tx, workspaceId, session, terminalSequence) {
+  await enqueueFailedChildOutboxTx(tx, workspaceId, session, {
+    turnId: null,
+    dedupeKey: `child-completion:${session.id}:pre-claim:${terminalSequence}`
+  });
+}
 function parseChildTerminalResultPayload(input) {
   const payload = SessionSystemUpdatePayload.parse(input);
   if (payload.type !== "child_terminal_result") {
@@ -65177,10 +65510,19 @@ async function enqueueSessionWorkflowWakeInTransaction(tx, input) {
       controlRevision: input.controlRequested ? sql39`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql39`${sessionWorkflowWakeOutbox.controlRevision}`,
       reason: input.reason,
       attempts: 0,
-      // Coalescing a delayed retry must never postpone an already-due wake
-      // owned by another producer. A later revision makes the batch richer;
-      // it does not revoke the earlier delivery obligation.
-      nextAttemptAt: sql39`least(${sessionWorkflowWakeOutbox.nextAttemptAt}, ${nextAttemptAt.toISOString()}::timestamptz)`,
+      // Coalescing a delayed retry must never postpone an undelivered wake
+      // owned by another producer. Once every prior revision is delivered,
+      // however, this is a new obligation and must honor its own deadline;
+      // retaining the old (usually past) deadline would defeat backoff.
+      nextAttemptAt: sql39`case
+          when ${sessionWorkflowWakeOutbox.wakeRevision}
+            > ${sessionWorkflowWakeOutbox.deliveredRevision}
+          then least(
+            ${sessionWorkflowWakeOutbox.nextAttemptAt},
+            ${nextAttemptAt.toISOString()}::timestamptz
+          )
+          else ${nextAttemptAt.toISOString()}::timestamptz
+        end`,
       lastError: null,
       updatedAt: now
     }
@@ -68019,6 +68361,7 @@ export {
   failMemorySlackPublication,
   failSandboxRematerialization,
   failSessionRealtimeConnectionInTransaction,
+  failSessionWorkBeforeAttemptClaim,
   failTranscriptionRecordingAssembly,
   failTranscriptionRecordingSegment,
   failWarmingToCold,
@@ -68243,6 +68586,7 @@ export {
   isMemoryScopeApplicable,
   isMemoryTextTooLong,
   isPrivateAddress,
+  isRetryableDatabaseTransportFailure,
   isRetryablePersistenceSqlState,
   isSessionCompactionRequested,
   isSessionEventPersistenceError,