@opengeni/db 3.4.0-canary.2 → 3.6.0

package/src/session-control.ts

@@ -2224,8 +2224,8 @@ export async function updateSessionCommandReceiptResult(
 export type SessionControlMutationResult = {
   receipt: SessionCommandReceiptRow;
   control: EffectiveSessionControl;
-  sessionControlEventId: string;
-  workspaceControlEventId: string;
+  sessionControlEventId: string | null;
+  workspaceControlEventId: string | null;
   interruptionCount: number;
   backgroundCommandCount: number;
   wakeCount: number;
@@ -2233,6 +2233,7 @@ export type SessionControlMutationResult = {
   cancelledTurnCount: number;
   affectedSessionEvents: Array<{ sessionId: string; eventIds: string[] }>;
   workflowWake: SessionControlWorkflowWake | null;
+  outcome: "changed" | "unchanged" | "replayed";
   replay: boolean;
 };
 
@@ -2278,6 +2279,115 @@ async function pendingSessionControlWorkflowWake(
   };
 }
 
+async function sessionPauseEffectsNeeded(
+  db: Database,
+  input: { workspaceId: string; sessionId: string; directPauseRevision: number },
+): Promise<boolean> {
+  const rows = await db.execute<{ needed: boolean }>(sql`
+    with recursive subtree(id, path, cycle) as (
+      select session.id, array[session.id]::uuid[], false
+      from ${schema.sessions} session
+      where session.workspace_id = ${input.workspaceId}
+        and session.id = ${input.sessionId}
+      union all
+      select child.id, parent.path || child.id, child.id = any(parent.path)
+      from subtree parent
+      join ${schema.sessions} child
+        on child.workspace_id = ${input.workspaceId}
+       and child.parent_session_id = parent.id
+      where not parent.cycle
+        and cardinality(parent.path) <= ${SESSION_ANCESTRY_LIMIT}
+    ), scoped_sessions as (
+      select session.id, session.subtree_run_override_revision
+      from subtree
+      join ${schema.sessions} session
+        on session.workspace_id = ${input.workspaceId}
+       and session.id = subtree.id
+      where not subtree.cycle
+    )
+    select exists (
+      select 1
+      from scoped_sessions session
+      where session.subtree_run_override_revision > ${input.directPauseRevision}
+      union all
+      select 1
+      from ${schema.sessionTurnAttempts} attempt
+      join scoped_sessions session on session.id = attempt.session_id
+      where attempt.workspace_id = ${input.workspaceId}
+        and attempt.state in ('claimed', 'running')
+        and not exists (
+          select 1
+          from ${schema.sessionAttemptInterruptions} interruption
+          where interruption.workspace_id = attempt.workspace_id
+            and interruption.attempt_id = attempt.id
+            and interruption.kind in ('session_pause', 'workspace_pause')
+            and interruption.state in ('pending', 'delivered', 'acknowledged')
+        )
+      union all
+      select 1
+      from ${schema.sessionBackgroundCommands} command
+      join scoped_sessions session on session.id = command.session_id
+      where command.workspace_id = ${input.workspaceId}
+        and command.state = 'running'
+    ) as needed
+  `);
+  return rows[0]?.needed ?? false;
+}
+
+async function workspacePauseEffectsNeeded(
+  db: Database,
+  input: { workspaceId: string; workspacePauseRevision: number },
+): Promise<boolean> {
+  const rows = await db.execute<{ needed: boolean }>(sql`
+    select exists (
+      select 1
+      from ${schema.sessions} session
+      where session.workspace_id = ${input.workspaceId}
+        and session.subtree_run_override_revision > ${input.workspacePauseRevision}
+      union all
+      select 1
+      from ${schema.sessionTurnAttempts} attempt
+      where attempt.workspace_id = ${input.workspaceId}
+        and attempt.state in ('claimed', 'running')
+        and not exists (
+          select 1
+          from ${schema.sessionAttemptInterruptions} interruption
+          where interruption.workspace_id = attempt.workspace_id
+            and interruption.attempt_id = attempt.id
+            and interruption.kind in ('session_pause', 'workspace_pause')
+            and interruption.state in ('pending', 'delivered', 'acknowledged')
+        )
+      union all
+      select 1
+      from ${schema.sessionBackgroundCommands} command
+      where command.workspace_id = ${input.workspaceId}
+        and command.state = 'running'
+    ) as needed
+  `);
+  return rows[0]?.needed ?? false;
+}
+
+async function continuableWakeRepairNeeded(
+  db: Database,
+  input: { workspaceId: string; rootSessionId: string | null },
+): Promise<boolean> {
+  const rows = await db.execute<{ needed: boolean }>(sql`
+    select exists (
+      select 1
+      from opengeni_private.list_continuable_sessions(
+        ${input.workspaceId}::uuid,
+        ${input.rootSessionId}::uuid
+      ) eligible
+      left join ${schema.sessionWorkflowWakeOutbox} wake
+        on wake.workspace_id = eligible.workspace_id
+       and wake.session_id = eligible.session_id
+      where wake.session_id is null
+        or wake.wake_revision <= wake.delivered_revision
+    ) as needed
+  `);
+  return rows[0]?.needed ?? false;
+}
+
 async function loadSessionSubtreeIds(
   db: Database,
   workspaceId: string,
@@ -3017,13 +3127,23 @@ export async function mutateSessionControlInTransaction(
     operationKey: input.operationKey,
     canonicalRequestHash: hash,
   });
-  if (reserved.replay && reserved.receipt.appliedControlRevision !== null) {
-    const workspaceControlEventId = String(reserved.receipt.result.workspaceControlEventId ?? "");
-    if (!workspaceControlEventId) {
+  if (reserved.replay) {
+    const storedOutcome = reserved.receipt.result.outcome;
+    const unchanged =
+      storedOutcome === "unchanged" && reserved.receipt.appliedControlRevision === null;
+    if (!unchanged && reserved.receipt.appliedControlRevision === null) {
+      throw new SessionControlInvariantError(
+        "Replayed session control receipt has no applied control revision",
+      );
+    }
+    const workspaceControlEventId = unchanged
+      ? null
+      : String(reserved.receipt.result.workspaceControlEventId ?? "");
+    if (!unchanged && !workspaceControlEventId) {
       throw new SessionControlInvariantError("Replayed session control receipt has no event");
     }
-    const sessionControlEventId = String(reserved.receipt.result.eventId ?? "");
-    if (!sessionControlEventId) {
+    const sessionControlEventId = unchanged ? null : String(reserved.receipt.result.eventId ?? "");
+    if (!unchanged && !sessionControlEventId) {
       throw new SessionControlInvariantError(
         "Replayed session control receipt has no session event",
       );
@@ -3046,13 +3166,16 @@ export async function mutateSessionControlInTransaction(
             sessionId: string;
             eventIds: string[];
           }>)
-        : [{ sessionId: input.sessionId, eventIds: [sessionControlEventId] }],
+        : sessionControlEventId
+          ? [{ sessionId: input.sessionId, eventIds: [sessionControlEventId] }]
+          : [],
       workflowWake: await pendingSessionControlWorkflowWake(
         db,
         input.workspaceId,
         input.sessionId,
         wakeCount,
       ),
+      outcome: "replayed",
       replay: true,
     };
   }
@@ -3074,6 +3197,59 @@ export async function mutateSessionControlInTransaction(
     throw new SessionControlConflictError();
   }
 
+  if (input.action !== "cancel") {
+    const targetSession = locks.sessions.find((session) => session.id === input.sessionId);
+    if (!targetSession) {
+      throw new SessionControlInvariantError(`Session ${input.sessionId} disappeared`);
+    }
+    const directPauseRevision = asSafeRevision(
+      targetSession.directPauseRevision,
+      "direct pause revision",
+    );
+    const changed =
+      input.action === "pause"
+        ? targetSession.directControlState !== "paused" ||
+          directPauseRevision === null ||
+          (await sessionPauseEffectsNeeded(db, {
+            workspaceId: input.workspaceId,
+            sessionId: input.sessionId,
+            directPauseRevision,
+          }))
+        : before.state === "paused" ||
+          (await continuableWakeRepairNeeded(db, {
+            workspaceId: input.workspaceId,
+            rootSessionId: input.sessionId,
+          }));
+    if (!changed) {
+      const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
+        result: {
+          outcome: "unchanged",
+          interruptionCount: 0,
+          backgroundCommandCount: 0,
+          wakeCount: 0,
+          cancelledSessionCount: 0,
+          cancelledTurnCount: 0,
+          affectedSessionEvents: [],
+        },
+      });
+      return {
+        receipt,
+        control: before,
+        sessionControlEventId: null,
+        workspaceControlEventId: null,
+        interruptionCount: 0,
+        backgroundCommandCount: 0,
+        wakeCount: 0,
+        cancelledSessionCount: 0,
+        cancelledTurnCount: 0,
+        affectedSessionEvents: [],
+        workflowWake: null,
+        outcome: "unchanged",
+        replay: false,
+      };
+    }
+  }
+
   const revision = nextRevision(workspace);
   await advanceWorkspaceRevision(db, input.workspaceId, revision);
   const updatedRows = await db
@@ -3281,6 +3457,7 @@ export async function mutateSessionControlInTransaction(
   const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
     controlRevision: revision,
     result: {
+      outcome: "changed",
       interruptionCount,
       backgroundCommandCount,
       wakeCount,
@@ -3311,6 +3488,7 @@ export async function mutateSessionControlInTransaction(
       input.sessionId,
       wakeCount,
     ),
+    outcome: "changed",
     replay: false,
   };
 }
@@ -3406,11 +3584,12 @@ export async function autoResumeSessionBranchInTransaction(
 export type WorkspaceControlMutationResult = {
   receipt: SessionCommandReceiptRow;
   revision: number;
-  workspaceControlEventId: string;
+  workspaceControlEventId: string | null;
   workspaceState: EffectiveControlState;
   interruptionCount: number;
   backgroundCommandCount: number;
   wakeCount: number;
+  outcome: "changed" | "unchanged" | "replayed";
   replay: boolean;
 };
 
@@ -3449,19 +3628,33 @@ export async function mutateWorkspaceControlInTransaction(
     operationKey: input.operationKey,
     canonicalRequestHash: hash,
   });
-  if (reserved.replay && reserved.receipt.appliedControlRevision !== null) {
-    const workspaceControlEventId = String(reserved.receipt.result.workspaceControlEventId ?? "");
-    if (!workspaceControlEventId) {
+  if (reserved.replay) {
+    const storedOutcome = reserved.receipt.result.outcome;
+    const unchanged =
+      storedOutcome === "unchanged" && reserved.receipt.appliedControlRevision === null;
+    if (!unchanged && reserved.receipt.appliedControlRevision === null) {
+      throw new SessionControlInvariantError(
+        "Replayed workspace control receipt has no applied control revision",
+      );
+    }
+    const workspaceControlEventId = unchanged
+      ? null
+      : String(reserved.receipt.result.workspaceControlEventId ?? "");
+    if (!unchanged && !workspaceControlEventId) {
       throw new SessionControlInvariantError("Replayed workspace control receipt has no event");
     }
     return {
       receipt: reserved.receipt,
-      revision: Number(reserved.receipt.appliedControlRevision),
-      workspaceControlEventId,
-      workspaceState: input.action === "pause" ? "paused" : "active",
+      revision:
+        reserved.receipt.appliedControlRevision === null
+          ? currentRevision
+          : Number(reserved.receipt.appliedControlRevision),
+      workspaceControlEventId: workspaceControlEventId || null,
+      workspaceState: workspace.workspaceState === "paused" ? "paused" : "active",
       interruptionCount: Number(reserved.receipt.result.interruptionCount ?? 0),
       backgroundCommandCount: Number(reserved.receipt.result.backgroundCommandCount ?? 0),
       wakeCount: Number(reserved.receipt.result.wakeCount ?? 0),
+      outcome: "replayed",
       replay: true,
     };
   }
@@ -3469,6 +3662,45 @@ export async function mutateWorkspaceControlInTransaction(
     if (input.expectedRevision !== currentRevision) throw new SessionControlConflictError();
   }
 
+  const workspacePauseRevision = asSafeRevision(
+    workspace.workspacePauseRevision,
+    "workspace pause revision",
+  );
+  const changed =
+    input.action === "pause"
+      ? workspace.workspaceState !== "paused" ||
+        workspacePauseRevision === null ||
+        (await workspacePauseEffectsNeeded(db, {
+          workspaceId: input.workspaceId,
+          workspacePauseRevision,
+        }))
+      : workspace.workspaceState !== "active" ||
+        (await continuableWakeRepairNeeded(db, {
+          workspaceId: input.workspaceId,
+          rootSessionId: null,
+        }));
+  if (!changed) {
+    const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
+      result: {
+        outcome: "unchanged",
+        interruptionCount: 0,
+        backgroundCommandCount: 0,
+        wakeCount: 0,
+      },
+    });
+    return {
+      receipt,
+      revision: currentRevision,
+      workspaceControlEventId: null,
+      workspaceState: workspace.workspaceState === "paused" ? "paused" : "active",
+      interruptionCount: 0,
+      backgroundCommandCount: 0,
+      wakeCount: 0,
+      outcome: "unchanged",
+      replay: false,
+    };
+  }
+
   const revision = nextRevision(workspace);
   const actor =
     input.actor.type === "agent_attempt"
@@ -3533,7 +3765,13 @@ export async function mutateWorkspaceControlInTransaction(
         });
   const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
     controlRevision: revision,
-    result: { interruptionCount, backgroundCommandCount, wakeCount, workspaceControlEventId },
+    result: {
+      outcome: "changed",
+      interruptionCount,
+      backgroundCommandCount,
+      wakeCount,
+      workspaceControlEventId,
+    },
   });
   return {
     receipt,
@@ -3543,6 +3781,7 @@ export async function mutateWorkspaceControlInTransaction(
     interruptionCount,
     backgroundCommandCount,
     wakeCount,
+    outcome: "changed",
     replay: false,
   };
 }

package/src/session-queue-commands.ts

@@ -1535,6 +1535,8 @@ export async function submitHumanPromptInTransaction(
     annotations?: TimelineAnnotation[];
     modelContext?: string | null;
     resources: ResourceRef[];
+    /** Actor-owned resources used only for the exact durable-draft fence. */
+    composerDraftResources?: ResourceRef[];
     model?: string | null;
     reasoningEffort?: ReasoningEffort | null;
     latencyMode?: LatencyMode | null;
@@ -1601,6 +1603,11 @@ export async function submitHumanPromptInTransaction(
     annotations,
     modelContext: input.modelContext ?? null,
     resources: withCanonicalResourceMountPaths(input.resources),
+    ...(input.composerDraftResources
+      ? {
+          composerDraftResources: withCanonicalResourceMountPaths(input.composerDraftResources),
+        }
+      : {}),
     model: input.model ?? null,
     reasoningEffort: input.reasoningEffort ?? null,
     latencyMode: input.latencyMode ?? null,
@@ -1777,7 +1784,9 @@ export async function submitHumanPromptInTransaction(
         canonicalSessionCommandHash({
           text: input.text,
           annotations: annotations.map(({ ordinal: _ordinal, ...annotation }) => annotation),
-          resources: withCanonicalResourceMountPaths(input.resources),
+          resources: withCanonicalResourceMountPaths(
+            input.composerDraftResources ?? input.resources,
+          ),
           model: input.model ?? session.model,
           reasoningEffort: input.reasoningEffort ?? input.reasoningEffortFallback,
           latencyMode: input.turnExecutionPolicy?.latencyMode ?? input.latencyMode ?? "standard",

package/src/session-tool-call-settlement.ts

@@ -15,7 +15,12 @@ export const TOOL_RESULT_TYPE_BY_CALL_TYPE: Readonly<Record<string, string>> = {
 };
 
 export function historyCallId(item: Record<string, unknown>): string | null {
-  const value = item.callId ?? item.call_id ?? item.id;
+  const providerData =
+    item.providerData && typeof item.providerData === "object" && !Array.isArray(item.providerData)
+      ? (item.providerData as Record<string, unknown>)
+      : null;
+  const value =
+    item.callId ?? item.call_id ?? providerData?.callId ?? providerData?.call_id ?? item.id;
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 

package/src/work-claims-schema.ts

@@ -0,0 +1,148 @@
+import { sql } from "drizzle-orm";
+import {
+  customType,
+  index,
+  integer,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from "drizzle-orm/pg-core";
+
+const xid8 = customType<{ data: string; driverData: string }>({
+  dataType: () => "xid8",
+});
+
+// Exact lifecycle-only mutation, immutable revisions, FORCE RLS, and runtime
+// grants are owned by the work-claim migration. The application role receives
+// SELECT on the compact head plus EXECUTE on exact-attempt mutation routines,
+// never direct DML authority.
+export const sessionWorkClaims = pgTable(
+  "session_work_claims",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    accountId: uuid("account_id").notNull(),
+    workspaceId: uuid("workspace_id").notNull(),
+    sessionId: uuid("session_id").notNull(),
+    rootSessionId: uuid("root_session_id").notNull(),
+    subjectNamespace: text("subject_namespace").notNull(),
+    subjectType: text("subject_type").notNull(),
+    canonicalKey: text("canonical_key").notNull(),
+    subjectDigest: text("subject_digest").notNull(),
+    displayLabel: text("display_label"),
+    role: text("role").notNull(),
+    state: text("state").notNull().default("active"),
+    revision: integer("revision").notNull().default(1),
+    provenance: text("provenance").notNull(),
+    versionKind: text("version_kind"),
+    versionValue: text("version_value"),
+    observedAt: timestamp("observed_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    settledAt: timestamp("settled_at", { withTimezone: true }),
+  },
+  (table) => ({
+    workspaceIdentity: uniqueIndex("session_work_claims_workspace_id_uq").on(
+      table.workspaceId,
+      table.id,
+    ),
+    activeIdentity: uniqueIndex("session_work_claims_active_identity_uq")
+      .on(
+        table.workspaceId,
+        table.sessionId,
+        table.subjectNamespace,
+        table.subjectType,
+        table.subjectDigest,
+        table.role,
+      )
+      .where(sql`${table.state} = 'active'`),
+    sessionState: index("session_work_claims_session_state_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.state,
+      table.updatedAt,
+      table.id,
+    ),
+    subjectState: index("session_work_claims_subject_state_idx").on(
+      table.workspaceId,
+      table.subjectNamespace,
+      table.subjectType,
+      table.subjectDigest,
+      table.state,
+      table.updatedAt,
+      table.id,
+    ),
+  }),
+);
+
+export const sessionWorkClaimRevisions = pgTable(
+  "session_work_claim_revisions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    accountId: uuid("account_id").notNull(),
+    workspaceId: uuid("workspace_id").notNull(),
+    claimId: uuid("claim_id").notNull(),
+    sessionId: uuid("session_id").notNull(),
+    rootSessionId: uuid("root_session_id").notNull(),
+    operationId: uuid("operation_id").notNull(),
+    inputHash: text("input_hash").notNull(),
+    mutationKind: text("mutation_kind").notNull(),
+    priorRevision: integer("prior_revision"),
+    resultingRevision: integer("resulting_revision").notNull(),
+    subjectNamespace: text("subject_namespace").notNull(),
+    subjectType: text("subject_type").notNull(),
+    canonicalKey: text("canonical_key").notNull(),
+    subjectDigest: text("subject_digest").notNull(),
+    displayLabel: text("display_label"),
+    role: text("role").notNull(),
+    state: text("state").notNull(),
+    provenance: text("provenance").notNull(),
+    versionKind: text("version_kind"),
+    versionValue: text("version_value"),
+    observedAt: timestamp("observed_at", { withTimezone: true }).notNull(),
+    claimCreatedAt: timestamp("claim_created_at", { withTimezone: true }).notNull(),
+    claimUpdatedAt: timestamp("claim_updated_at", { withTimezone: true }).notNull(),
+    settledAt: timestamp("settled_at", { withTimezone: true }),
+    actorKind: text("actor_kind").notNull(),
+    actorSubjectId: text("actor_subject_id").notNull(),
+    actorSessionId: uuid("actor_session_id"),
+    actorTurnId: uuid("actor_turn_id"),
+    actorAttemptId: uuid("actor_attempt_id"),
+    actorExecutionGeneration: integer("actor_execution_generation"),
+    reason: text("reason"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    operation: uniqueIndex("session_work_claim_revisions_workspace_operation_uq").on(
+      table.workspaceId,
+      table.operationId,
+    ),
+    claimRevision: uniqueIndex("session_work_claim_revisions_claim_revision_uq").on(
+      table.workspaceId,
+      table.claimId,
+      table.resultingRevision,
+    ),
+    sessionTimeline: index("session_work_claim_revisions_session_timeline_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.createdAt,
+      table.id,
+    ),
+  }),
+);
+
+export const sessionWorkClaimWriteCapabilities = pgTable(
+  "session_work_claim_write_capabilities",
+  {
+    backendPid: integer("backend_pid").notNull(),
+    transactionId: xid8("transaction_id").notNull(),
+    capabilityId: uuid("capability_id").notNull(),
+  },
+  (table) => ({
+    identity: primaryKey({
+      columns: [table.backendPid, table.transactionId, table.capabilityId],
+    }),
+  }),
+);