@opengeni/db 1.0.1 → 3.2.0-canary.0

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

@@ -1,6 +1,6 @@
 import type { SessionEvent } from "@opengeni/contracts";
-import { boundModelToolOutputItem } from "@opengeni/codex";
-import { and, asc, eq, sql } from "drizzle-orm";
+import { canonicalizePersistedHistoryItem, omitOutputOnlyHistoryItemFields } from "@opengeni/codex";
+import { and, asc, eq, inArray, sql } from "drizzle-orm";
 import type { Database } from "./database";
 import { fromPostgresLosslessJson, LOSSLESS_CONTENT_CODEC_VERSION } from "./lossless-json";
 import * as schema from "./schema";
@@ -85,6 +85,8 @@ export type ClosePendingSessionToolCallsInput = {
   reason: string;
   sequence: number;
   now: Date;
+  turnAssociation?: "current" | null;
+  preserveInterruptionRows?: boolean;
 };
 
 function mapEvent(row: typeof schema.sessionEvents.$inferSelect): SessionEvent {
@@ -107,10 +109,13 @@ function mapEvent(row: typeof schema.sessionEvents.$inferSelect): SessionEvent {
 }
 
 /**
- * Close every unresolved raw tool call for a logical turn while its owning
- * session/turn locks are held. Durable results win; otherwise the model gets an
- * explicit interrupted/outcome-unknown result for protocols that can represent
- * one. Repeated settlement is an exact no-op after ledger deletion.
+ * Close raw tool calls for a logical turn while its owning session/turn locks
+ * are held. Recoverable transitions preserve interruption rows because those
+ * rows are the exact open-suffix resume authority for a replacement attempt;
+ * ordinary in-flight rows still receive durable outcome-unknown settlement.
+ * Terminal and superseding transitions close every row. Durable results win;
+ * repeated settlement is an exact no-op after the selected ledger rows are
+ * deleted.
  */
 export async function closePendingSessionToolCallsInTransaction(
   tx: Database,
@@ -128,18 +133,20 @@ export async function closePendingSessionToolCallsInTransaction(
     )
     .orderBy(asc(schema.sessionPendingToolCalls.createdAt), asc(schema.sessionPendingToolCalls.id))
     .for("update");
-  const pending = pendingRows.map((row) => ({
-    ...row,
-    callItem: fromPostgresLosslessJson(row.callItem, row.callItemCodecVersion),
-    resultItem:
-      row.resultItem === null
-        ? null
-        : fromPostgresLosslessJson(row.resultItem, row.resultItemCodecVersion),
-    eventOutput:
-      row.eventOutput === null
-        ? null
-        : fromPostgresLosslessJson(row.eventOutput, row.eventOutputCodecVersion),
-  }));
+  const pending = pendingRows
+    .filter((row) => !(input.preserveInterruptionRows && row.interruptionKind !== null))
+    .map((row) => ({
+      ...row,
+      callItem: fromPostgresLosslessJson(row.callItem, row.callItemCodecVersion),
+      resultItem:
+        row.resultItem === null
+          ? null
+          : fromPostgresLosslessJson(row.resultItem, row.resultItemCodecVersion),
+      eventOutput:
+        row.eventOutput === null
+          ? null
+          : fromPostgresLosslessJson(row.eventOutput, row.eventOutputCodecVersion),
+    }));
   if (pending.length === 0) return { sequence: input.sequence, events: [], closed: 0 };
 
   const history = await tx
@@ -250,7 +257,7 @@ export async function closePendingSessionToolCallsInTransaction(
         sessionId: input.sessionId,
         turnId: input.turnId,
         position: nextPosition++,
-        item: resolution.call.callItem,
+        item: omitOutputOnlyHistoryItemFields(resolution.call.callItem),
         itemCodecVersion: LOSSLESS_CONTENT_CODEC_VERSION,
         active: true,
       });
@@ -274,7 +281,7 @@ export async function closePendingSessionToolCallsInTransaction(
         sessionId: input.sessionId,
         turnId: input.turnId,
         position: nextPosition++,
-        item: boundModelToolOutputItem(
+        item: canonicalizePersistedHistoryItem(
           resolution.result,
           resolution.call.modelToolOutputTruncationTokens ?? undefined,
         ),
@@ -297,7 +304,7 @@ export async function closePendingSessionToolCallsInTransaction(
       turnId: input.turnId,
       turnGeneration: resolution.call.executionGeneration,
       turnAttemptId: resolution.call.attemptId,
-      turnAssociation: "current",
+      turnAssociation: input.turnAssociation === undefined ? "current" : input.turnAssociation,
       payload: {
         id: resolution.call.callId,
         output: resolution.interrupted
@@ -341,14 +348,16 @@ export async function closePendingSessionToolCallsInTransaction(
     reason: input.reason,
     now: input.now,
   });
-  await tx
-    .delete(schema.sessionPendingToolCalls)
-    .where(
-      and(
-        eq(schema.sessionPendingToolCalls.workspaceId, input.workspaceId),
-        eq(schema.sessionPendingToolCalls.sessionId, input.sessionId),
-        eq(schema.sessionPendingToolCalls.turnId, input.turnId),
+  await tx.delete(schema.sessionPendingToolCalls).where(
+    and(
+      eq(schema.sessionPendingToolCalls.workspaceId, input.workspaceId),
+      eq(schema.sessionPendingToolCalls.sessionId, input.sessionId),
+      eq(schema.sessionPendingToolCalls.turnId, input.turnId),
+      inArray(
+        schema.sessionPendingToolCalls.id,
+        pending.map((call) => call.id),
       ),
-    );
+    ),
+  );
   return { sequence, events: inserted.map(mapEvent), closed: pending.length };
 }

package/src/slack-routing-personal-workspace.ts

@@ -0,0 +1,67 @@
+// The personal-workspace pointer, in its own leaf module.
+//
+// Both the Slack routing resolvers and the Slack access-request path need it,
+// and this keeps that from becoming an import cycle between them.
+import { sql } from "drizzle-orm";
+
+import { type Database } from "./database";
+import { listSelfOrganizationMemberships } from "./organization-membership-lifecycle";
+import { rlsSubjectIdOrEmpty } from "./workspace-authority";
+
+/**
+ * The subject's own personal workspace in one organization, or null.
+ *
+ * Only an `active` membership counts, and only that membership's own
+ * `personalWorkspaceId` pointer is read - never a default workspace, a
+ * `created_by`, or current access.
+ *
+ * Non-`user:` subjects (API keys, delegated service principals, configured and
+ * local principals) can never own an organization membership, so they
+ * short-circuit rather than tripping `list_self_organization_memberships`'
+ * `42501` guard.
+ *
+ * ORACLE, NOT AN AUTHORIZATION. This answers "which workspace is this named
+ * subject's own" for whatever subject it is handed; it does not establish that
+ * the caller IS that subject. Pass only a subject authenticated out of band -
+ * for Slack, one named by a durable `slack_bot_user_links` row. Never pass a
+ * subject taken from a request payload.
+ */
+export async function namedSubjectPersonalWorkspaceId(
+  db: Database,
+  input: { accountId: string; subjectId: string },
+): Promise<string | null> {
+  if (!input.subjectId.startsWith("user:")) return null;
+  // `listSelfOrganizationMemberships` opens its own scope and sets
+  // `opengeni.subject_id` to the probed subject. Under drizzle a nested
+  // transaction is a SAVEPOINT, and releasing a savepoint does NOT undo a
+  // transaction-local `set_config`, so without this the probed subject would
+  // leak out and silently re-scope the rest of a caller-owned transaction.
+  // `namedSubjectHasLiveWorkspaceAuthority` guards the same hazard the same
+  // way; empty string is the canonical "unset" because `current_subject_id()`
+  // is `nullif(current_setting(...), '')`.
+  const priorSubjectId = await rlsSubjectIdOrEmpty(db);
+  let completed = false;
+  try {
+    const memberships = await listSelfOrganizationMemberships(db, input.subjectId);
+    const membership = memberships.find(
+      (candidate) =>
+        candidate.status === "active" &&
+        candidate.organizationId === input.accountId &&
+        candidate.personalWorkspaceId !== null,
+    );
+    completed = true;
+    return membership?.personalWorkspaceId ?? null;
+  } finally {
+    const restore = db.execute(
+      sql`select set_config('opengeni.subject_id', ${priorSubjectId}, true)`,
+    );
+    if (completed) {
+      await restore;
+    } else {
+      // A failed statement can leave a caller-owned transaction aborted.
+      // Preserve the original diagnostic rather than replacing it with the
+      // restore's `25P02`.
+      await restore.catch(() => undefined);
+    }
+  }
+}