@opengeni/db 3.6.0 → 3.7.3-canary.0

package/src/session-queue-commands.ts

@@ -29,7 +29,7 @@ import {
   type TimelineAnnotation,
   type PersonalResourceAttachmentIntent,
 } from "@opengeni/contracts";
-import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
 import { setSubjectRlsContext, type Database, type SessionActivityDatabase } from "./database";
 import {
   fromPostgresLosslessJson,
@@ -345,11 +345,55 @@ async function lockSession(
 
 type SteerSupersessionResult = {
   interruptionCount: number;
+  steerTargetTurn: typeof schema.sessionTurns.$inferSelect | null;
   replacedTurn: typeof schema.sessionTurns.$inferSelect | null;
   liveCurrentTurnId: string | null;
+  deferredUntilCompaction: boolean;
   lastSequence: number;
 };
 
+async function turnAttemptIsCompacting(
+  db: Database,
+  input: {
+    workspaceId: string;
+    sessionId: string;
+    turn: typeof schema.sessionTurns.$inferSelect;
+  },
+): Promise<boolean> {
+  // A standalone operator compaction is maintenance rather than replaceable
+  // direction. Once claimed, let it finish even before its provider-visible
+  // started landmark is appended.
+  if (input.turn.source === "compaction") return true;
+  if (!input.turn.activeAttemptId) return false;
+
+  // Automatic/proactive/overflow compaction happens inside an ordinary turn.
+  // The latest exact-attempt landmark is durable state: `started` means the
+  // checkpoint provider call is still in flight, while compacted/skipped opens
+  // ordinary Steer interruption again. Multiple compactions in one attempt are
+  // therefore handled by the newest lifecycle event rather than a historical
+  // existence test.
+  const [latest] = await db
+    .select({ type: schema.sessionEvents.type })
+    .from(schema.sessionEvents)
+    .where(
+      and(
+        eq(schema.sessionEvents.workspaceId, input.workspaceId),
+        eq(schema.sessionEvents.sessionId, input.sessionId),
+        eq(schema.sessionEvents.turnId, input.turn.id),
+        eq(schema.sessionEvents.turnGeneration, input.turn.executionGeneration),
+        eq(schema.sessionEvents.turnAttemptId, input.turn.activeAttemptId),
+        inArray(schema.sessionEvents.type, [
+          "session.context.compaction.started",
+          "session.context.compacted",
+          "session.context.compaction.skipped",
+        ]),
+      ),
+    )
+    .orderBy(desc(schema.sessionEvents.sequence), desc(schema.sessionEvents.id))
+    .limit(1);
+  return latest?.type === "session.context.compaction.started";
+}
+
 /**
  * One canonical replacement transition shared by human row/new-prompt Steer
  * and Agent Steer. A live owner is interrupted and remains current until exact
@@ -371,8 +415,10 @@ export async function supersedeSessionCurrentDirectionInTransaction(
   if (!input.activeTurnId) {
     return {
       interruptionCount: 0,
+      steerTargetTurn: null,
       replacedTurn: null,
       liveCurrentTurnId: null,
+      deferredUntilCompaction: false,
       lastSequence: input.lastSequence,
     };
   }
@@ -391,6 +437,7 @@ export async function supersedeSessionCurrentDirectionInTransaction(
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
     workspaceLock: "already_locked",
+    sessionIds: [input.sessionId],
     turnIds: [input.activeTurnId],
     attemptIds: preview?.activeAttemptId ? [preview.activeAttemptId] : [],
   });
@@ -410,6 +457,26 @@ export async function supersedeSessionCurrentDirectionInTransaction(
       `Running turn ${current.id} has no first-class attempt owner`,
     );
   }
+  if (
+    current.activeAttemptId &&
+    (await turnAttemptIsCompacting(db, {
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turn: current,
+    }))
+  ) {
+    return {
+      interruptionCount: 0,
+      steerTargetTurn: current,
+      // An ordinary turn is superseded cooperatively as soon as its checkpoint
+      // settles. Standalone maintenance completes normally, then the Steer is
+      // already first in line.
+      replacedTurn: current.source === "compaction" ? null : current,
+      liveCurrentTurnId: current.id,
+      deferredUntilCompaction: true,
+      lastSequence: input.lastSequence,
+    };
+  }
   if (current.activeAttemptId) {
     if (current.status !== "running") {
       throw new SessionControlInvariantError(
@@ -431,8 +498,10 @@ export async function supersedeSessionCurrentDirectionInTransaction(
       .returning({ id: schema.sessionAttemptInterruptions.id });
     return {
       interruptionCount: interruption ? 1 : 0,
+      steerTargetTurn: current,
       replacedTurn: current,
       liveCurrentTurnId: current.id,
+      deferredUntilCompaction: false,
       lastSequence: input.lastSequence,
     };
   }
@@ -571,8 +640,10 @@ export async function supersedeSessionCurrentDirectionInTransaction(
   }
   return {
     interruptionCount: 0,
+    steerTargetTurn: current,
     replacedTurn: current,
     liveCurrentTurnId: null,
+    deferredUntilCompaction: false,
     lastSequence,
   };
 }
@@ -1388,9 +1459,11 @@ export async function steerQueuedTurnInTransaction(
     lastSequence: session.lastSequence,
   });
   const interruptionCount = supersession.interruptionCount;
+  const steerTargetTurn = supersession.steerTargetTurn;
   const supersededTurnId = supersession.replacedTurn?.id ?? null;
   const supersededAttemptId = supersession.replacedTurn?.activeAttemptId ?? null;
   const liveCurrentTurnId = supersession.liveCurrentTurnId;
+  const deferredUntilCompaction = supersession.deferredUntilCompaction;
 
   const withoutTarget = rows.filter((row) => row.id !== target.id);
   const ordered = [target, ...withoutTarget];
@@ -1412,6 +1485,7 @@ export async function steerQueuedTurnInTransaction(
         replacedTurnId: supersededTurnId,
         replacedAttemptId: supersededAttemptId,
         interruptionCount,
+        ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
       },
       updatedAt: now,
     })
@@ -1440,12 +1514,16 @@ export async function steerQueuedTurnInTransaction(
     sessionId: input.sessionId,
     sequence: ++sequence,
     type: "session.control.steer_requested",
-    turnId: supersededTurnId ?? target.id,
+    turnId: steerTargetTurn?.id ?? target.id,
+    turnGeneration: steerTargetTurn?.executionGeneration ?? null,
+    turnAttemptId: steerTargetTurn?.activeAttemptId ?? null,
+    turnAssociation: steerTargetTurn ? "current" : null,
     payload: {
       operationId: reserved.receipt.id,
       targetTurnId: target.id,
       replacedTurnId: supersededTurnId,
-      stopping: liveCurrentTurnId !== null,
+      stopping: liveCurrentTurnId !== null && !deferredUntilCompaction,
+      ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
     },
     occurredAt: now,
   });
@@ -1480,6 +1558,7 @@ export async function steerQueuedTurnInTransaction(
           operationId: reserved.receipt.id,
           replacedTurnId: supersededTurnId,
           interruptionCount,
+          deferredUntilCompaction,
         },
       },
       "metadata",
@@ -1501,6 +1580,7 @@ export async function steerQueuedTurnInTransaction(
     result: {
       interruptionCount,
       supersededTurnId,
+      deferredUntilCompaction,
       wakeRevision,
       workspaceControlEventId: resumed.workspaceControlEventId,
     },
@@ -1730,12 +1810,37 @@ export async function submitHumanPromptInTransaction(
     );
   }
 
-  // Send is queue admission, never a hidden control mutation. A paused Send
-  // remains inert behind the existing gate until the user explicitly resumes.
-  // Steer is the intentional exception: it replaces the current direction and
-  // therefore activates the selected branch atomically.
+  const draft =
+    input.expectedDraftRevision === null || input.expectedDraftRevision === undefined
+      ? null
+      : await getComposerDraftInTransaction(db, {
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          subjectId: input.subjectId,
+          lock: true,
+        });
+  const isQueueEditSubmission = draft?.sourceTurnId !== null && draft?.sourceTurnId !== undefined;
+
+  // A normal Send received while the active branch is waiting in
+  // `requires_action` is the human choosing to continue conversationally
+  // instead of through the pending decision surface. Promote only that active
+  // wait to Steer semantics so the frozen wait is cancelled and the new prompt
+  // runs next. A queue-edit submission preserves the identity and placement of
+  // already accepted queued work, so it must never cancel an unrelated active
+  // wait. An explicitly paused branch remains inert until Resume or an explicit
+  // Steer; running, recovering, and capacity-waiting work also retain ordinary
+  // queue semantics.
+  const effectiveDelivery =
+    input.delivery === "send" &&
+    (input.actor.type === "human" || input.actor.type === "operator") &&
+    !isQueueEditSubmission &&
+    before.state === "active" &&
+    session.status === "requires_action" &&
+    session.activeTurnId !== null
+      ? "steer"
+      : input.delivery;
   const resumed =
-    input.delivery === "send"
+    effectiveDelivery === "send"
       ? {
           revision: before.controlVersion,
           control: before,
@@ -1753,16 +1858,6 @@ export async function submitHumanPromptInTransaction(
           observedControlEtag: input.controlEtag ?? null,
           admission,
         });
-
-  const draft =
-    input.expectedDraftRevision === null || input.expectedDraftRevision === undefined
-      ? null
-      : await getComposerDraftInTransaction(db, {
-          workspaceId: input.workspaceId,
-          sessionId: input.sessionId,
-          subjectId: input.subjectId,
-          lock: true,
-        });
   if (input.expectedDraftRevision !== null && input.expectedDraftRevision !== undefined) {
     const actualRevision = draft?.revision ?? 0;
     if (actualRevision !== input.expectedDraftRevision) {
@@ -1928,7 +2023,7 @@ export async function submitHumanPromptInTransaction(
       : (input.modelContext ?? null);
   const existingQueued = await loadQueuedTurns(db, input.workspaceId, input.sessionId, true);
   const routing: SessionPromptRouting =
-    input.delivery === "steer"
+    effectiveDelivery === "steer"
       ? "accepted_for_steering"
       : before.state === "paused" || session.activeTurnId || existingQueued.length > 0
         ? "queued_for_execution"
@@ -1959,7 +2054,7 @@ export async function submitHumanPromptInTransaction(
         ...(input.model ? { model: input.model } : {}),
         ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
         ...(input.latencyMode ? { latencyMode: input.latencyMode } : {}),
-        delivery: input.delivery,
+        delivery: effectiveDelivery,
         routing,
         initiator: frozenInitiator.initiator,
       },
@@ -1980,7 +2075,7 @@ export async function submitHumanPromptInTransaction(
           status: "queued",
           source: input.source,
           promptRouting: routing,
-          position: input.delivery === "steer" ? 0 : existingQueued.length + 1,
+          position: effectiveDelivery === "steer" ? 0 : existingQueued.length + 1,
           prompt: input.text,
           annotations,
           modelContext: effectiveModelContext,
@@ -2072,7 +2167,7 @@ export async function submitHumanPromptInTransaction(
   });
 
   const supersession =
-    input.delivery === "steer"
+    effectiveDelivery === "steer"
       ? await supersedeSessionCurrentDirectionInTransaction(db, {
           accountId: input.accountId,
           workspaceId: input.workspaceId,
@@ -2085,8 +2180,10 @@ export async function submitHumanPromptInTransaction(
         })
       : {
           interruptionCount: 0,
+          steerTargetTurn: null,
           replacedTurn: null,
           liveCurrentTurnId: null,
+          deferredUntilCompaction: false,
           lastSequence: session.lastSequence,
         };
   // Ownerless Steer settlement may have appended interrupted tool results.
@@ -2094,9 +2191,11 @@ export async function submitHumanPromptInTransaction(
   sequence = supersession.lastSequence;
   for (const event of eventValues) event.sequence = ++sequence;
   const interruptionCount = supersession.interruptionCount;
+  const steerTargetTurn = supersession.steerTargetTurn;
   const replacedTurnId = supersession.replacedTurn?.id ?? null;
   const replacedAttemptId = supersession.replacedTurn?.activeAttemptId ?? null;
   const liveCurrentTurnId = supersession.liveCurrentTurnId;
+  const deferredUntilCompaction = supersession.deferredUntilCompaction;
   // Durable provenance for the queue projection. Until the superseded attempt
   // loses inference, user-visible output, and workspace-persistence authority,
   // its exact first-class attempt has no quiescence receipt. Pairing that
@@ -2104,7 +2203,7 @@ export async function submitHumanPromptInTransaction(
   // attempt…" truthfully across refresh/reconnect, even though logical
   // settlement has already cleared sessions.active_turn_id. Do not infer this
   // state from a local request spinner or queue position.
-  if (input.delivery === "steer") {
+  if (effectiveDelivery === "steer") {
     const [updatedTurn] = await db
       .update(schema.sessionTurns)
       .set({
@@ -2114,6 +2213,7 @@ export async function submitHumanPromptInTransaction(
           replacedTurnId,
           replacedAttemptId,
           interruptionCount,
+          ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
         },
         updatedAt: now,
       })
@@ -2130,8 +2230,8 @@ export async function submitHumanPromptInTransaction(
     }
     committedTurn = updatedTurn;
   }
-  if (supersession.replacedTurn) {
-    const current = supersession.replacedTurn;
+  if (steerTargetTurn) {
+    const current = steerTargetTurn;
     if (!liveCurrentTurnId) {
       eventValues.push({
         accountId: input.accountId,
@@ -2157,8 +2257,9 @@ export async function submitHumanPromptInTransaction(
       payload: {
         operationId: reserved.receipt.id,
         targetTurnId: turnId,
-        replacedTurnId: current.id,
-        stopping: liveCurrentTurnId !== null,
+        replacedTurnId,
+        stopping: liveCurrentTurnId !== null && !deferredUntilCompaction,
+        ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
       },
       occurredAt: now,
     });
@@ -2188,7 +2289,7 @@ export async function submitHumanPromptInTransaction(
   }
 
   const ordered =
-    input.delivery === "steer" ? [turn, ...existingQueued] : [...existingQueued, turn];
+    effectiveDelivery === "steer" ? [turn, ...existingQueued] : [...existingQueued, turn];
   await normalizeQueuePositions(
     db,
     input.workspaceId,
@@ -2196,7 +2297,7 @@ export async function submitHumanPromptInTransaction(
     ordered.map((row) => row.id),
   );
   const noCurrentAfter =
-    input.delivery === "steer" ? liveCurrentTurnId === null : !session.activeTurnId;
+    effectiveDelivery === "steer" ? liveCurrentTurnId === null : !session.activeTurnId;
   const nextStatus = noCurrentAfter ? "queued" : session.status;
   if (nextStatus !== session.status) {
     eventValues.push({
@@ -2223,12 +2324,12 @@ export async function submitHumanPromptInTransaction(
       turnId,
       channel: null,
       text: renderRealtimeHumanInputContext({
-        delivery: input.delivery,
+        delivery: effectiveDelivery,
         routing,
         text: renderTimelineAnnotationsForModel(input.text, annotations),
       }),
       payload: {
-        delivery: input.delivery,
+        delivery: effectiveDelivery,
         routing,
         acceptedEventId,
         instruction: "OpenGeni accepted and routed this user input; do not delegate it again.",
@@ -2242,7 +2343,7 @@ export async function submitHumanPromptInTransaction(
     .set({
       resources: mergeResourceRefs(session.resources as ResourceRef[], input.resources),
       tools: session.tools,
-      activeTurnId: input.delivery === "steer" ? liveCurrentTurnId : session.activeTurnId,
+      activeTurnId: effectiveDelivery === "steer" ? liveCurrentTurnId : session.activeTurnId,
       status: nextStatus,
       queueVersion,
       queueHeadPosition: 0,
@@ -2276,8 +2377,8 @@ export async function submitHumanPromptInTransaction(
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: workflowId,
-    reason: input.delivery === "steer" ? "prompt_steer" : "prompt_send",
-    controlRequested: input.delivery === "steer",
+    reason: effectiveDelivery === "steer" ? "prompt_steer" : "prompt_send",
+    controlRequested: effectiveDelivery === "steer",
   });
   await db.insert(schema.auditEvents).values(
     withLosslessContentWriteVersion(
@@ -2288,13 +2389,14 @@ export async function submitHumanPromptInTransaction(
           input.actor.type === "agent_attempt"
             ? `attempt:${input.actor.attemptId}`
             : input.actor.subjectId,
-        action: input.delivery === "steer" ? "session.prompt.steer" : "session.prompt.send",
+        action: effectiveDelivery === "steer" ? "session.prompt.steer" : "session.prompt.send",
         targetType: "session_turn",
         targetId: turnId,
         metadata: {
           operationId: reserved.receipt.id,
           replacedTurnId,
           interruptionCount,
+          deferredUntilCompaction,
           ...(input.turnExecutionPolicy
             ? turnExecutionPolicyAuditMetadata(input.turnExecutionPolicy, turnId)
             : {}),
@@ -2338,6 +2440,7 @@ export async function submitHumanPromptInTransaction(
       wakeRevision,
       interruptionCount,
       replacedTurnId,
+      deferredUntilCompaction,
       workspaceControlEventId: resumed.workspaceControlEventId,
       routing,
       ...(input.turnExecutionPolicy
@@ -2815,16 +2918,17 @@ export async function steerAgentSessionInTransaction(
       sessionId: input.targetSessionId,
       sequence: ++sequence,
       type: "session.control.steer_requested",
-      turnId: supersession.replacedTurn?.id ?? null,
-      turnGeneration: supersession.replacedTurn?.executionGeneration ?? null,
-      turnAttemptId: supersession.replacedTurn?.activeAttemptId ?? null,
-      turnAssociation: supersession.replacedTurn ? "current" : null,
+      turnId: supersession.steerTargetTurn?.id ?? null,
+      turnGeneration: supersession.steerTargetTurn?.executionGeneration ?? null,
+      turnAttemptId: supersession.steerTargetTurn?.activeAttemptId ?? null,
+      turnAssociation: supersession.steerTargetTurn ? "current" : null,
       payload: {
         operationId: reserved.receipt.id,
         targetUpdateId: update.id,
         replacedTurnId: supersession.replacedTurn?.id ?? null,
         actorSessionId: input.actor.sessionId,
-        stopping: supersession.liveCurrentTurnId !== null,
+        stopping: supersession.liveCurrentTurnId !== null && !supersession.deferredUntilCompaction,
+        ...(supersession.deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
       },
       occurredAt: now,
     },
@@ -2912,6 +3016,7 @@ export async function steerAgentSessionInTransaction(
           callerExecutionGeneration: input.actor.executionGeneration,
           controlRevision: resumed.revision,
           interruptionCount: supersession.interruptionCount,
+          deferredUntilCompaction: supersession.deferredUntilCompaction,
           workspaceControlEventId: resumed.workspaceControlEventId,
         },
       },
@@ -2928,6 +3033,7 @@ export async function steerAgentSessionInTransaction(
       wakeRevision,
       workflowId,
       interruptionCount: supersession.interruptionCount,
+      deferredUntilCompaction: supersession.deferredUntilCompaction,
     },
   });
   return {

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

@@ -19,9 +19,16 @@ export function historyCallId(item: Record<string, unknown>): string | null {
     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;
+  // Native tool-search `id` is the provider item id, not the call correlation
+  // id. Validate direct and provider identities before the item-id fallback.
+  const value = [
+    item.callId,
+    item.call_id,
+    providerData?.callId,
+    providerData?.call_id,
+    item.id,
+  ].find((candidate): candidate is string => typeof candidate === "string" && candidate.length > 0);
+  return value ?? null;
 }
 
 export function historyItemType(item: Record<string, unknown>): string | null {
@@ -68,13 +75,33 @@ export function interruptedToolCallResult(input: {
   }
   if (input.callType === "computer_call") return null;
   if (input.callType === "tool_search_call") {
+    const providerData =
+      input.callItem.providerData &&
+      typeof input.callItem.providerData === "object" &&
+      !Array.isArray(input.callItem.providerData)
+        ? (input.callItem.providerData as Record<string, unknown>)
+        : null;
+    const execution =
+      input.callItem.execution === "client" || input.callItem.execution === "server"
+        ? input.callItem.execution
+        : providerData?.execution === "client" || providerData?.execution === "server"
+          ? providerData.execution
+          : null;
+    const providerIdentity =
+      typeof providerData?.call_id === "string" || typeof providerData?.callId === "string";
     const snakeId = typeof input.callItem.call_id === "string";
     return {
       type: "tool_search_output",
-      ...(snakeId ? { call_id: input.callId } : { callId: input.callId }),
-      ...(input.callItem.execution === "client" || input.callItem.execution === "server"
-        ? { execution: input.callItem.execution }
-        : {}),
+      ...(providerIdentity
+        ? {
+            providerData: {
+              call_id: input.callId,
+              ...(execution ? { execution } : {}),
+            },
+          }
+        : snakeId
+          ? { call_id: input.callId, ...(execution ? { execution } : {}) }
+          : { callId: input.callId, ...(execution ? { execution } : {}) }),
       status: "incomplete",
       tools: [],
     };

package/src/user-resource-authority.ts

@@ -301,6 +301,62 @@ export async function issueSelfUserResourceGrant(
   });
 }
 
+export async function issueSelfLocalConnectionUseGrant(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    authorityId: string;
+    context: "user_private" | "workspace_shared";
+    workspaceSharedAcknowledged: boolean;
+  },
+): Promise<UserResourceAuthorityGrant> {
+  return await withOwnerContext(db, input, async (scopedDb) => {
+    const [row] = await rawRows<
+      Omit<UserResourceAuthorityGrant, "delegation"> & {
+        organizationId: string;
+        authorityGeneration: number;
+      }
+    >(
+      scopedDb,
+      sql`
+        select grant_id as "grantId", organization_id as "organizationId",
+          authority_generation::int as "authorityGeneration",
+          target_workspace_id as "targetWorkspaceId",
+          target_session_id as "targetSessionId", action, grant_mode as mode,
+          grant_context as context, authority_epoch::int as "authorityEpoch",
+          grant_generation::int as generation, grant_status as status,
+          expires_at::text as "expiresAt"
+        from issue_self_local_connection_use_grant(
+          ${input.accountId}::uuid, ${input.authorityId}::uuid,
+          ${input.workspaceId}::uuid, ${input.context},
+          ${input.workspaceSharedAcknowledged}
+        )
+      `,
+    );
+    if (!row) throw new Error("local connection grant was not returned");
+    const { organizationId, authorityGeneration, ...grant } = row;
+    return {
+      ...grant,
+      expiresAt: rfc3339(grant.expiresAt),
+      delegation: {
+        authorityId: input.authorityId,
+        grantId: grant.grantId,
+        organizationId,
+        workspaceId: grant.targetWorkspaceId,
+        sessionId: grant.targetSessionId,
+        action: grant.action,
+        mode: grant.mode,
+        context: grant.context,
+        authorityEpoch: grant.authorityEpoch,
+        authorityGeneration,
+        grantGeneration: grant.generation,
+      },
+    };
+  });
+}
+
 export async function revokeSelfUserResourceGrant(
   db: Database,
   input: { accountId: string; workspaceId: string; subjectId: string; grantId: string },