@opengeni/db 0.13.4 → 0.14.0

package/src/schema.ts

@@ -1,4 +1,8 @@
-import type { McpServerConnectionRef, SessionMcpApprovalPolicy } from "@opengeni/contracts";
+import type {
+  FirstPartyMcpToolName,
+  McpServerConnectionRef,
+  SessionMcpApprovalPolicy,
+} from "@opengeni/contracts";
 import { sql } from "drizzle-orm";
 import type { SessionToolPolicy } from "@opengeni/contracts";
 import type { HumanInputQuestion, HumanInputResponse } from "@opengeni/contracts";
@@ -838,6 +842,9 @@ export const sessions = pgTable(
     // Non-default first-party MCP token permissions (manager-style sessions);
     // null means the fixed worker default set in @opengeni/runtime.
     firstPartyMcpPermissions: jsonb("first_party_mcp_permissions").$type<string[]>(),
+    // Exact model-visible first-party tool selection. NULL resolves to the
+    // fixed minimal default; [] intentionally selects no broad-server tools.
+    firstPartyMcpTools: jsonb("first_party_mcp_tools").$type<FirstPartyMcpToolName[]>(),
     // Durable tool-policy origin. NULL is retained for pre-migration rows;
     // mapSession exposes those rows as `legacy` instead of guessing omitted vs
     // explicit [].
@@ -1913,14 +1920,15 @@ export const sessionSystemUpdates = pgTable(
     summary: text("summary").notNull(),
     payload: jsonb("payload").$type<Record<string, unknown>>().notNull().default({}),
     lineage: jsonb("lineage").$type<Record<string, unknown>>().notNull().default({}),
-    // pending: eligible to start/attach to an inference; deferred: preserved
-    // after a failed internal-only inference but dormant until a real prompt or
-    // a genuinely new pending update arrives; delivered/cancelled/failed are
-    // terminal for that delivery attempt.
+    // pending is visible queue truth; delivered means its exact model-memory
+    // batch was durably claimed. Terminal cancellation/supersession is explicit.
     state: text("state").notNull().default("pending"),
     deliveredTurnId: uuid("delivered_turn_id").references(() => sessionTurns.id, {
       onDelete: "set null",
     }),
+    // Migration owns the forward FK to session_history_items, declared later.
+    // Every member of one claimed batch points at the exact model-memory row.
+    deliveredHistoryItemId: uuid("delivered_history_item_id"),
     deliveredAt: timestamp("delivered_at", { withTimezone: true }),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
   },
@@ -1935,7 +1943,7 @@ export const sessionSystemUpdates = pgTable(
     ),
     stateValid: check(
       "system_updates_state_check",
-      sql`${table.state} in ('pending', 'deferred', 'delivered', 'cancelled', 'superseded', 'failed')`,
+      sql`${table.state} in ('pending', 'delivered', 'cancelled', 'superseded', 'failed')`,
     ),
     dedupe: uniqueIndex("session_system_updates_dedupe_uq").on(
       table.workspaceId,
@@ -1948,6 +1956,17 @@ export const sessionSystemUpdates = pgTable(
       table.state,
       table.createdAt,
     ),
+    onePendingSteer: uniqueIndex("session_system_updates_one_pending_steer_idx")
+      .on(table.workspaceId, table.sessionId)
+      .where(sql`${table.kind} = 'agent_steer_instruction' and ${table.state} = 'pending'`),
+    deliveryHistoryValid: check(
+      "session_system_updates_delivery_history_check",
+      sql`(
+        (${table.state} = 'delivered' and ${table.deliveredHistoryItemId} is not null)
+        or
+        (${table.state} <> 'delivered' and ${table.deliveredHistoryItemId} is null)
+      )`,
+    ),
   }),
 );
 

package/src/session-queue-commands.ts

@@ -279,17 +279,6 @@ export async function supersedeSessionCurrentDirectionInTransaction(
       updatedAt: now,
     })
     .where(eq(schema.sessionTurns.id, current.id));
-  await db
-    .update(schema.sessionSystemUpdates)
-    .set({ state: "pending", deliveredTurnId: null, deliveredAt: null })
-    .where(
-      and(
-        eq(schema.sessionSystemUpdates.workspaceId, input.workspaceId),
-        eq(schema.sessionSystemUpdates.sessionId, input.sessionId),
-        eq(schema.sessionSystemUpdates.deliveredTurnId, current.id),
-        eq(schema.sessionSystemUpdates.state, "delivered"),
-      ),
-    );
   if (current.status === "waiting_capacity") {
     await db
       .update(schema.codexCapacityWaiters)
@@ -1927,7 +1916,7 @@ export async function steerAgentSessionInTransaction(
     controlRevision: resumed.revision,
     lastSequence: session.lastSequence,
   });
-  await db
+  const supersededUpdates = await db
     .update(schema.sessionSystemUpdates)
     .set({ state: "superseded" })
     .where(
@@ -1935,9 +1924,10 @@ export async function steerAgentSessionInTransaction(
         eq(schema.sessionSystemUpdates.workspaceId, input.workspaceId),
         eq(schema.sessionSystemUpdates.sessionId, input.targetSessionId),
         eq(schema.sessionSystemUpdates.kind, "agent_steer_instruction"),
-        inArray(schema.sessionSystemUpdates.state, ["pending", "deferred"]),
+        eq(schema.sessionSystemUpdates.state, "pending"),
       ),
-    );
+    )
+    .returning({ id: schema.sessionSystemUpdates.id });
   const now = new Date();
   const [update] = await db
     .insert(schema.sessionSystemUpdates)
@@ -1999,6 +1989,24 @@ export async function steerAgentSessionInTransaction(
       },
       occurredAt: now,
     },
+    ...(supersededUpdates.length > 0
+      ? [
+          {
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            sessionId: input.targetSessionId,
+            sequence: ++sequence,
+            type: "system.update.superseded" as const,
+            payload: {
+              updateIds: supersededUpdates.map((entry) => entry.id),
+              count: supersededUpdates.length,
+              replacementUpdateId: update.id,
+              reason: "newer_agent_steer",
+            },
+            occurredAt: now,
+          },
+        ]
+      : []),
     {
       accountId: input.accountId,
       workspaceId: input.workspaceId,