create-windy 0.6.11 → 0.6.14

package/template/apps/server/src/agent/session-persistence/drizzle-invalidation-outbox.ts

@@ -0,0 +1,260 @@
+import { randomUUID } from "node:crypto";
+import {
+  agentSourceInvalidationDeliveries,
+  agentSourceInvalidations,
+} from "@southwind-ai/database";
+import { and, asc, desc, eq, isNull, lt, or, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import {
+  SOURCE_INVALIDATION_PROJECTION_TARGETS,
+  type SessionSourceInvalidationOutboxPort,
+  type SourceInvalidationDelivery,
+  type SourceInvalidationEnvelopeV1,
+  type SourceInvalidationProjectionTarget,
+} from "../session-invalidation/contracts.js";
+import {
+  assertSourceInvalidationEnvelope,
+  sourceInvalidationDeliveryId,
+} from "../session-invalidation/dispatcher.js";
+
+export class DrizzleSessionInvalidationOutbox
+  implements SessionSourceInvalidationOutboxPort
+{
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async append(envelope: SourceInvalidationEnvelopeV1) {
+    return this.db.transaction((transaction) =>
+      this.appendInTransaction(
+        transaction as unknown as NodePgDatabase,
+        envelope,
+      ),
+    );
+  }
+
+  async appendInTransaction(
+    db: NodePgDatabase,
+    envelope: SourceInvalidationEnvelopeV1,
+  ) {
+    assertSourceInvalidationEnvelope(envelope);
+    const [existingId] = await db
+        .select({ id: agentSourceInvalidations.invalidationId })
+        .from(agentSourceInvalidations)
+        .where(eq(agentSourceInvalidations.invalidationId, envelope.invalidationId))
+        .limit(1);
+    if (existingId) return "duplicate" as const;
+    const [latest] = await db
+        .select({ sequence: agentSourceInvalidations.sequence })
+        .from(agentSourceInvalidations)
+        .where(
+          and(
+            eq(
+              agentSourceInvalidations.sourceModuleKey,
+              envelope.source.moduleKey,
+            ),
+            eq(agentSourceInvalidations.sourceKind, envelope.source.sourceKind),
+            eq(agentSourceInvalidations.sourceId, envelope.source.sourceId),
+          ),
+        )
+        .orderBy(desc(agentSourceInvalidations.sequence))
+        .limit(1);
+    if (latest && latest.sequence >= envelope.source.sequence) {
+      return "stale" as const;
+    }
+    const occurredAt = Date.parse(envelope.occurredAt);
+    await db.insert(agentSourceInvalidations).values({
+        invalidationId: envelope.invalidationId,
+        sourceModuleKey: envelope.source.moduleKey,
+        sourceKind: envelope.source.sourceKind,
+        sourceId: envelope.source.sourceId,
+        sourceVersion: envelope.source.version,
+        sequence: envelope.source.sequence,
+        sourceDigest: envelope.source.digest,
+        cause: envelope.transition.reason,
+        payloadJson: envelope as unknown as Record<string, unknown>,
+        occurredAt,
+        updatedAt: occurredAt,
+    });
+    await db.insert(agentSourceInvalidationDeliveries).values(
+      SOURCE_INVALIDATION_PROJECTION_TARGETS.map((target) => ({
+          invalidationId: envelope.invalidationId,
+          sinkKey: target,
+          nextAttemptAt: occurredAt,
+      })),
+    );
+    return "appended" as const;
+  }
+
+  async claim(input: {
+    readonly workerId: string;
+    readonly limit: number;
+    readonly leaseUntil: string;
+  }) {
+    const now = Date.now();
+    const candidates = await this.db
+      .select({
+        invalidationId: agentSourceInvalidationDeliveries.invalidationId,
+        target: agentSourceInvalidationDeliveries.sinkKey,
+        attemptCount: agentSourceInvalidationDeliveries.attemptCount,
+        envelope: agentSourceInvalidations.payloadJson,
+      })
+      .from(agentSourceInvalidationDeliveries)
+      .innerJoin(
+        agentSourceInvalidations,
+        eq(
+          agentSourceInvalidationDeliveries.invalidationId,
+          agentSourceInvalidations.invalidationId,
+        ),
+      )
+      .where(
+        and(
+          or(
+            eq(agentSourceInvalidationDeliveries.status, "pending"),
+            and(
+              eq(agentSourceInvalidationDeliveries.status, "processing"),
+              or(
+                isNull(agentSourceInvalidationDeliveries.leaseUntil),
+                lt(agentSourceInvalidationDeliveries.leaseUntil, now),
+              ),
+            ),
+          ),
+          lt(agentSourceInvalidationDeliveries.nextAttemptAt, now + 1),
+        ),
+      )
+      .orderBy(asc(agentSourceInvalidationDeliveries.nextAttemptAt))
+      .limit(input.limit * 2);
+    const claimed: SourceInvalidationDelivery[] = [];
+    for (const candidate of candidates) {
+      if (claimed.length >= input.limit) break;
+      const leaseToken = `lease_${randomUUID()}`;
+      const [updated] = await this.db
+        .update(agentSourceInvalidationDeliveries)
+        .set({
+          status: "processing",
+          attemptCount: sql`${agentSourceInvalidationDeliveries.attemptCount} + 1`,
+          leaseToken,
+          leaseOwner: input.workerId,
+          leaseUntil: Date.parse(input.leaseUntil),
+        })
+        .where(
+          and(
+            eq(
+              agentSourceInvalidationDeliveries.invalidationId,
+              candidate.invalidationId,
+            ),
+            eq(agentSourceInvalidationDeliveries.sinkKey, candidate.target),
+            or(
+              eq(agentSourceInvalidationDeliveries.status, "pending"),
+              and(
+                eq(agentSourceInvalidationDeliveries.status, "processing"),
+                or(
+                  isNull(agentSourceInvalidationDeliveries.leaseUntil),
+                  lt(agentSourceInvalidationDeliveries.leaseUntil, now),
+                ),
+              ),
+            ),
+          ),
+        )
+        .returning({ attempt: agentSourceInvalidationDeliveries.attemptCount });
+      if (!updated) continue;
+      const target = candidate.target as SourceInvalidationProjectionTarget;
+      const envelope = candidate.envelope as unknown as SourceInvalidationEnvelopeV1;
+      assertSourceInvalidationEnvelope(envelope);
+      claimed.push({
+        deliveryId: sourceInvalidationDeliveryId(candidate.invalidationId, target),
+        target,
+        envelope,
+        attempt: updated.attempt,
+        leaseToken,
+      });
+    }
+    return claimed;
+  }
+
+  complete(deliveryId: string, leaseToken: string): Promise<void> {
+    return this.finish(deliveryId, leaseToken, {
+      status: "delivered",
+      deliveredAt: Date.now(),
+      leaseToken: null,
+      leaseOwner: null,
+      leaseUntil: null,
+    });
+  }
+
+  retry(input: {
+    readonly deliveryId: string;
+    readonly leaseToken: string;
+    readonly retryAt: string;
+    readonly errorCode: string;
+  }): Promise<void> {
+    return this.finish(input.deliveryId, input.leaseToken, {
+      status: "pending",
+      nextAttemptAt: Date.parse(input.retryAt),
+      lastErrorCode: input.errorCode,
+      leaseToken: null,
+      leaseOwner: null,
+      leaseUntil: null,
+    });
+  }
+
+  reject(input: {
+    readonly deliveryId: string;
+    readonly leaseToken: string;
+    readonly errorCode: string;
+  }): Promise<void> {
+    return this.finish(input.deliveryId, input.leaseToken, {
+      status: "rejected",
+      lastErrorCode: input.errorCode,
+      leaseToken: null,
+      leaseOwner: null,
+      leaseUntil: null,
+    });
+  }
+
+  private async finish(
+    deliveryId: string,
+    leaseToken: string,
+    values: Partial<typeof agentSourceInvalidationDeliveries.$inferInsert>,
+  ) {
+    const coordinate = parseDeliveryId(deliveryId);
+    await this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const [updated] = await db
+        .update(agentSourceInvalidationDeliveries)
+        .set(values)
+        .where(
+          and(
+            eq(agentSourceInvalidationDeliveries.invalidationId, coordinate.id),
+            eq(agentSourceInvalidationDeliveries.sinkKey, coordinate.target),
+            eq(agentSourceInvalidationDeliveries.status, "processing"),
+            eq(agentSourceInvalidationDeliveries.leaseToken, leaseToken),
+          ),
+        )
+        .returning({ id: agentSourceInvalidationDeliveries.invalidationId });
+      if (!updated) throw new Error("失效传播 Lease 已失效");
+      const deliveries = await db
+        .select({ status: agentSourceInvalidationDeliveries.status })
+        .from(agentSourceInvalidationDeliveries)
+        .where(eq(agentSourceInvalidationDeliveries.invalidationId, coordinate.id));
+      const status = deliveries.some(({ status }) => status === "rejected")
+        ? "failed"
+        : deliveries.every(({ status }) => status === "delivered")
+          ? "completed"
+          : deliveries.some(({ status }) => status === "processing")
+            ? "processing"
+            : "pending";
+      await db
+        .update(agentSourceInvalidations)
+        .set({ status, updatedAt: Date.now() })
+        .where(eq(agentSourceInvalidations.invalidationId, coordinate.id));
+    });
+  }
+}
+
+function parseDeliveryId(deliveryId: string) {
+  const separator = deliveryId.lastIndexOf(":");
+  if (separator <= 0) throw new Error("失效传播 Delivery ID 无效");
+  return {
+    id: deliveryId.slice(0, separator),
+    target: deliveryId.slice(separator + 1),
+  };
+}

package/template/apps/server/src/agent/session-persistence/drizzle-memory-projection-deletion.ts

@@ -0,0 +1,56 @@
+import { agentMemoryProjections } from "@southwind-ai/database";
+import { and, eq, inArray } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { SessionId } from "../session-log/domain.js";
+
+export type MemoryProjectionDeletionResult =
+  | "deleted"
+  | "already-deleted"
+  | "not-found";
+
+/**
+ * 删除的是单个派生 Memory Projection，不是它引用的权威来源。
+ * 该操作不得发布来源失效事件，也不得级联到其它投影或外部索引。
+ */
+export interface MemoryProjectionDeletionPort {
+  deleteProjection(input: {
+    readonly sessionId: SessionId;
+    readonly memoryId: string;
+    readonly deletedAt: number;
+  }): Promise<MemoryProjectionDeletionResult>;
+}
+
+export class DrizzleMemoryProjectionDeletion
+  implements MemoryProjectionDeletionPort
+{
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async deleteProjection(input: {
+    readonly sessionId: SessionId;
+    readonly memoryId: string;
+    readonly deletedAt: number;
+  }): Promise<MemoryProjectionDeletionResult> {
+    const coordinate = and(
+      eq(agentMemoryProjections.memoryId, input.memoryId),
+      eq(agentMemoryProjections.derivedFromSessionId, input.sessionId),
+    );
+    const [deleted] = await this.db
+      .update(agentMemoryProjections)
+      .set({ status: "deleted", updatedAt: input.deletedAt })
+      .where(
+        and(
+          coordinate,
+          inArray(agentMemoryProjections.status, ["active", "invalidated"]),
+        ),
+      )
+      .returning({ id: agentMemoryProjections.memoryId });
+    if (deleted) return "deleted";
+
+    const [existing] = await this.db
+      .select({ status: agentMemoryProjections.status })
+      .from(agentMemoryProjections)
+      .where(coordinate)
+      .limit(1);
+    return existing?.status === "deleted" ? "already-deleted" : "not-found";
+  }
+}

package/template/apps/server/src/agent/session-persistence/drizzle-run-projection-receipt.ts

@@ -0,0 +1,80 @@
+import { agentSessionRunProjectionReceipts } from "@southwind-ai/database";
+import { and, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  SessionRunProjectionReceipt,
+  SessionRunProjectionReceiptPort,
+} from "../session-result-memory.js";
+
+export class DrizzleSessionRunProjectionReceiptStore
+  implements SessionRunProjectionReceiptPort
+{
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async read(sessionId: string, runId: string) {
+    const [row] = await this.db
+      .select()
+      .from(agentSessionRunProjectionReceipts)
+      .where(
+        and(
+          eq(agentSessionRunProjectionReceipts.sessionId, sessionId),
+          eq(agentSessionRunProjectionReceipts.runId, runId),
+        ),
+      )
+      .limit(1);
+    return row ? mapReceipt(row) : undefined;
+  }
+
+  async append(receipt: SessionRunProjectionReceipt) {
+    const [created] = await this.db
+      .insert(agentSessionRunProjectionReceipts)
+      .values({
+        sessionId: receipt.sessionId,
+        runId: receipt.runId,
+        terminalSequence: receipt.terminalSequence,
+        resultDigest: receipt.resultDigest,
+        workingMemoryId: receipt.memoryIds[0],
+        summaryMemoryId: receipt.memoryIds[1],
+        projectedAt: Date.parse(receipt.projectedAt),
+      })
+      .onConflictDoNothing({
+        target: [
+          agentSessionRunProjectionReceipts.sessionId,
+          agentSessionRunProjectionReceipts.runId,
+        ],
+      })
+      .returning();
+    if (created) return;
+    const existing = await this.read(receipt.sessionId, receipt.runId);
+    if (!existing || !sameReceipt(existing, receipt)) {
+      throw new Error("Run Result Memory Receipt 坐标冲突");
+    }
+  }
+}
+
+function mapReceipt(
+  row: typeof agentSessionRunProjectionReceipts.$inferSelect,
+): SessionRunProjectionReceipt {
+  return {
+    sessionId: row.sessionId,
+    runId: row.runId,
+    terminalSequence: row.terminalSequence,
+    resultDigest: row.resultDigest,
+    memoryIds: [row.workingMemoryId, row.summaryMemoryId],
+    projectedAt: new Date(row.projectedAt).toISOString(),
+  };
+}
+
+function sameReceipt(
+  left: SessionRunProjectionReceipt,
+  right: SessionRunProjectionReceipt,
+) {
+  return (
+    left.sessionId === right.sessionId &&
+    left.runId === right.runId &&
+    left.terminalSequence === right.terminalSequence &&
+    left.resultDigest === right.resultDigest &&
+    left.memoryIds[0] === right.memoryIds[0] &&
+    left.memoryIds[1] === right.memoryIds[1]
+  );
+}

package/template/apps/server/src/agent/session-persistence/drizzle-session-fork.ts

@@ -0,0 +1,147 @@
+import { agentSessionEvents, agentSessions } from "@southwind-ai/database";
+import { and, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  SessionCheckpoint,
+  SessionId,
+  SessionRecord,
+} from "../session-log/domain.js";
+import type {
+  PendingSessionEvent,
+  SessionEventEnvelope,
+} from "../session-log/events.js";
+import {
+  SessionRepositoryConflict,
+  type ForkSessionInput,
+  type SessionForkResult,
+} from "../session-log/repository.js";
+import {
+  createdSession,
+  eventValues,
+  mapEvent,
+  mapSession,
+  sessionValues,
+} from "./drizzle-session-mapping.js";
+import type { AgentSessionPayloadCodec } from "./payload-codec.js";
+
+interface DrizzleSessionForkDependencies {
+  readonly db: NodePgDatabase;
+  readonly codec: AgentSessionPayloadCodec;
+  readonly lockSession: (
+    sessionId: SessionId,
+  ) => Promise<SessionRecord | undefined>;
+  readonly selectSession: (
+    sessionId: SessionId,
+  ) => Promise<SessionRecord | undefined>;
+  readonly getCheckpoint: (
+    checkpointId: string,
+  ) => Promise<SessionCheckpoint | undefined>;
+  readonly replayEvents: (
+    sessionId: SessionId,
+    pending: readonly PendingSessionEvent[],
+  ) => Promise<SessionEventEnvelope[] | undefined>;
+  readonly assertEventIdsFree: (
+    events: readonly PendingSessionEvent[],
+  ) => Promise<void>;
+}
+
+export async function forkDrizzleSession(
+  dependencies: DrizzleSessionForkDependencies,
+  input: ForkSessionInput,
+): Promise<SessionForkResult> {
+  const parent = await dependencies.lockSession(input.parentSessionId);
+  if (!parent) throw new SessionRepositoryConflict("SESSION_NOT_FOUND");
+  if (parent.status !== "active") {
+    throw new SessionRepositoryConflict("SESSION_NOT_ACTIVE");
+  }
+  const existingChild = await dependencies.selectSession(input.child.sessionId);
+  if (existingChild) {
+    return replayFork(dependencies, input, parent, existingChild);
+  }
+  if (parent.headSequence !== input.expectedParentSequence) {
+    throw new SessionRepositoryConflict("SEQUENCE_CONFLICT");
+  }
+  const checkpoint = await dependencies.getCheckpoint(input.checkpointId);
+  if (
+    !checkpoint ||
+    checkpoint.sessionId !== parent.sessionId ||
+    input.child.lineage?.checkpointId !== checkpoint.checkpointId
+  ) {
+    throw new SessionRepositoryConflict("FORK_CONFLICT");
+  }
+  await dependencies.assertEventIdsFree([
+    input.parentEvent,
+    input.child.createdEvent,
+  ]);
+  const child = createdSession(input.child);
+  const parentEvent = eventValues(
+    dependencies.codec,
+    parent.sessionId,
+    parent.headSequence + 1,
+    input.parentEvent,
+  );
+  const childEvent = eventValues(
+    dependencies.codec,
+    child.sessionId,
+    1,
+    input.child.createdEvent,
+  );
+  const [updatedParent] = await dependencies.db
+    .update(agentSessions)
+    .set({
+      headSequence: parent.headSequence + 1,
+      updatedAt: parentEvent.occurredAt,
+    })
+    .where(
+      and(
+        eq(agentSessions.sessionId, parent.sessionId),
+        eq(agentSessions.headSequence, parent.headSequence),
+      ),
+    )
+    .returning();
+  if (!updatedParent) {
+    throw new SessionRepositoryConflict("SEQUENCE_CONFLICT");
+  }
+  await dependencies.db.insert(agentSessions).values(sessionValues(child));
+  const inserted = await dependencies.db
+    .insert(agentSessionEvents)
+    .values([parentEvent, childEvent])
+    .returning();
+  return {
+    parent: mapSession(updatedParent),
+    child,
+    parentEvent: mapEvent(
+      dependencies.codec,
+      inserted.find((row) => row.sessionId === parent.sessionId)!,
+    ),
+    childEvent: mapEvent(
+      dependencies.codec,
+      inserted.find((row) => row.sessionId === child.sessionId)!,
+    ),
+    replayed: false,
+  };
+}
+
+async function replayFork(
+  dependencies: DrizzleSessionForkDependencies,
+  input: ForkSessionInput,
+  parent: SessionRecord,
+  child: SessionRecord,
+): Promise<SessionForkResult> {
+  const parentEvents = await dependencies.replayEvents(parent.sessionId, [
+    input.parentEvent,
+  ]);
+  const childEvents = await dependencies.replayEvents(child.sessionId, [
+    input.child.createdEvent,
+  ]);
+  if (!parentEvents || !childEvents) {
+    throw new SessionRepositoryConflict("FORK_CONFLICT");
+  }
+  return {
+    parent,
+    child,
+    parentEvent: parentEvents[0]!,
+    childEvent: childEvents[0]!,
+    replayed: true,
+  };
+}

package/template/apps/server/src/agent/session-persistence/drizzle-session-list.ts

@@ -0,0 +1,24 @@
+import { agentSessions } from "@southwind-ai/database";
+import { and, desc, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { mapSession } from "./drizzle-session-mapping.js";
+
+export async function listSessionsForGovernance(
+  db: NodePgDatabase,
+  actorId: string,
+  scopeDigest: string,
+  limit: number,
+) {
+  const rows = await db
+    .select()
+    .from(agentSessions)
+    .where(
+      and(
+        eq(agentSessions.actorId, actorId),
+        eq(agentSessions.scopeDigest, scopeDigest),
+      ),
+    )
+    .orderBy(desc(agentSessions.updatedAt))
+    .limit(limit);
+  return rows.map(mapSession);
+}