@opengeni/db 0.13.4 → 0.14.3

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,10 +842,12 @@ 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[]>(),
-    // Durable tool-policy origin. NULL is retained for pre-migration rows;
-    // mapSession exposes those rows as `legacy` instead of guessing omitted vs
-    // explicit [].
-    toolPolicy: jsonb("tool_policy").$type<SessionToolPolicy>(),
+    // Exact model-visible first-party tool selection. All catalogued tools are
+    // selected by default; [] intentionally selects no broad-server tools.
+    firstPartyMcpTools: jsonb("first_party_mcp_tools").$type<FirstPartyMcpToolName[]>().notNull(),
+    // Durable tool-policy origin. Migration 0136 removes the old null/legacy
+    // representation so every session has one explicit policy mode.
+    toolPolicy: jsonb("tool_policy").$type<SessionToolPolicy>().notNull(),
     // Optimistic-concurrency fence for durable session tool-policy writes.
     toolPolicyVersion: integer("tool_policy_version").notNull().default(1),
     // The manager session that spawned this one via session_create. Set only
@@ -1913,14 +1919,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 +1942,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 +1955,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

@@ -1,12 +1,9 @@
 import {
   metadataWithTurnExecutionPolicyV1,
   mergeResourceRefs,
-  mergeToolRefs,
   turnExecutionPolicyAuditMetadata,
   type ReasoningEffort,
   type ResourceRef,
-  type SessionToolPolicy,
-  type ToolRef,
   type TurnExecutionPolicyV1,
 } from "@opengeni/contracts";
 import { and, asc, eq, inArray, sql } from "drizzle-orm";
@@ -279,17 +276,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)
@@ -378,13 +364,7 @@ async function normalizeQueuePositions(
 }
 
 function draftIsNonEmpty(draft: ComposerDraftRow): boolean {
-  return (
-    draft.text.length > 0 ||
-    draft.resources.length > 0 ||
-    draft.tools.length > 0 ||
-    draft.toolsProvided ||
-    draft.sourceTurnId !== null
-  );
+  return draft.text.length > 0 || draft.resources.length > 0 || draft.sourceTurnId !== null;
 }
 
 export async function getComposerDraftInTransaction(
@@ -421,8 +401,6 @@ export async function saveComposerDraftInTransaction(
     expectedRevision: number;
     text: string;
     resources: ResourceRef[];
-    tools: ToolRef[];
-    toolsProvided: boolean;
     model: string;
     reasoningEffort: ReasoningEffort;
   },
@@ -453,8 +431,8 @@ export async function saveComposerDraftInTransaction(
     revision,
     text: input.text,
     resources: input.resources,
-    tools: input.tools,
-    toolsProvided: input.toolsProvided,
+    tools: [],
+    toolsProvided: false,
     model: input.model,
     reasoningEffort: input.reasoningEffort,
     // A queue edit is still the same accepted work item. Preserve its frozen
@@ -825,8 +803,8 @@ export async function editQueuedTurnInTransaction(
     revision: nextDraftRevision,
     text: turn.prompt,
     resources: turn.resources,
-    tools: turn.tools,
-    toolsProvided: turn.toolsProvided,
+    tools: [],
+    toolsProvided: false,
     model: turn.model,
     reasoningEffort: turn.reasoningEffort,
     sourceTurnId: turn.id,
@@ -1142,8 +1120,6 @@ export async function submitHumanPromptInTransaction(
     text: string;
     turnInstructions?: string | null;
     resources: ResourceRef[];
-    tools: ToolRef[];
-    toolsProvided?: boolean;
     model?: string | null;
     reasoningEffort?: ReasoningEffort | null;
     reasoningEffortFallback: ReasoningEffort;
@@ -1174,8 +1150,6 @@ export async function submitHumanPromptInTransaction(
     text: input.text,
     turnInstructions: input.turnInstructions ?? null,
     resources: input.resources,
-    tools: input.tools,
-    toolsProvided: input.toolsProvided === true,
     model: input.model ?? null,
     reasoningEffort: input.reasoningEffort ?? null,
     source: input.source,
@@ -1283,16 +1257,12 @@ export async function submitHumanPromptInTransaction(
       canonicalSessionCommandHash({
         text: draft.text,
         resources: draft.resources,
-        tools: draft.tools,
-        toolsProvided: draft.toolsProvided,
         model: draft.model,
         reasoningEffort: draft.reasoningEffort,
       }) !==
         canonicalSessionCommandHash({
           text: input.text,
           resources: input.resources,
-          tools: input.tools,
-          toolsProvided: input.toolsProvided === true,
           model: input.model ?? session.model,
           reasoningEffort: input.reasoningEffort ?? input.reasoningEffortFallback,
         })
@@ -1412,11 +1382,6 @@ export async function submitHumanPromptInTransaction(
       payload: sanitizeEventPayload({
         text: input.text,
         ...(input.resources.length ? { resources: input.resources } : {}),
-        ...(input.toolsProvided === true
-          ? { tools: input.tools }
-          : input.tools.length
-            ? { tools: input.tools }
-            : {}),
         ...(input.model ? { model: input.model } : {}),
         ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
         delivery: input.delivery,
@@ -1444,8 +1409,8 @@ export async function submitHumanPromptInTransaction(
           ? editedSourceTurnInstructions
           : (input.turnInstructions ?? null),
       resources: input.resources,
-      tools: input.tools,
-      toolsProvided: input.toolsProvided === true,
+      tools: [],
+      toolsProvided: false,
       model: input.model ?? session.model,
       reasoningEffort: input.reasoningEffort ?? input.reasoningEffortFallback,
       sandboxBackend: session.sandboxBackend,
@@ -1589,9 +1554,7 @@ export async function submitHumanPromptInTransaction(
     .update(schema.sessions)
     .set({
       resources: mergeResourceRefs(session.resources as ResourceRef[], input.resources),
-      tools: sessionToolPolicyIsFixed(session.toolPolicy)
-        ? session.tools
-        : mergeToolRefs(session.tools as ToolRef[], input.tools),
+      tools: session.tools,
       activeTurnId: input.delivery === "steer" ? liveCurrentTurnId : session.activeTurnId,
       status: nextStatus,
       queueVersion,
@@ -1664,12 +1627,6 @@ export async function submitHumanPromptInTransaction(
   };
 }
 
-function sessionToolPolicyIsFixed(value: unknown): boolean {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const mode = (value as Partial<SessionToolPolicy>).mode;
-  return mode === "workspace_default" || mode === "explicit" || mode === "inherited";
-}
-
 export async function sendAgentMessageInTransaction(
   db: Database,
   input: {
@@ -1927,7 +1884,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 +1892,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 +1957,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,