create-windy 0.6.12 → 0.6.15

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

@@ -0,0 +1,348 @@
+import {
+  agentContextSources,
+  agentContextVersions,
+  agentMemoryProjections,
+  agentMemorySources,
+} from "@southwind-ai/database";
+import { and, asc, desc, eq, gt, inArray, isNull, or } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { RequestGuardContext } from "../../guards.js";
+import type {
+  ContextSourceReference,
+  ContextVersion,
+  ContextVersionRecorder,
+  MemoryProjection,
+  MemoryProjectionPort,
+  MemoryProjectionRecorder,
+} from "../context-memory/contracts.js";
+import {
+  memoryProjectionScopeId,
+  sameMemoryProjectionCoordinates,
+} from "../context-memory/memory-content.js";
+import { AgentSessionPayloadCodec } from "./payload-codec.js";
+
+export class DrizzleContextVersionRecorder implements ContextVersionRecorder {
+  constructor(private readonly db: NodePgDatabase) {}
+
+  record(version: ContextVersion): Promise<void> {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const [created] = await db
+        .insert(agentContextVersions)
+        .values({
+          contextVersionId: version.contextVersionId,
+          sessionId: version.sessionId,
+          turnId: version.turnId,
+          runId: version.runId,
+          modelAttemptId: version.modelAttemptId,
+          currentCaseId: version.currentCaseId,
+          digest: version.digest,
+          createdAt: Date.parse(version.createdAt),
+        })
+        .onConflictDoNothing({ target: agentContextVersions.modelAttemptId })
+        .returning({ id: agentContextVersions.contextVersionId });
+      if (!created) {
+        const [existing] = await db
+          .select()
+          .from(agentContextVersions)
+          .where(
+            eq(agentContextVersions.modelAttemptId, version.modelAttemptId),
+          )
+          .limit(1);
+        if (
+          !existing ||
+          existing.contextVersionId !== version.contextVersionId ||
+          existing.sessionId !== version.sessionId ||
+          existing.turnId !== version.turnId ||
+          existing.runId !== version.runId ||
+          (existing.currentCaseId ?? undefined) !== version.currentCaseId ||
+          existing.digest !== version.digest
+        ) {
+          throw new Error("Model attempt 已绑定其它 Context Version");
+        }
+        return;
+      }
+      if (version.sources.length) {
+        await db
+          .insert(agentContextSources)
+          .values(
+            version.sources.map((source, ordinal) =>
+              contextSourceValues(version.contextVersionId, ordinal, source),
+            ),
+          );
+      }
+    });
+  }
+
+  async readByAttempt(
+    modelAttemptId: string,
+  ): Promise<ContextVersion | undefined> {
+    const [version] = await this.db
+      .select()
+      .from(agentContextVersions)
+      .where(eq(agentContextVersions.modelAttemptId, modelAttemptId))
+      .limit(1);
+    if (!version) return undefined;
+    const sources = await this.db
+      .select()
+      .from(agentContextSources)
+      .where(eq(agentContextSources.contextVersionId, version.contextVersionId))
+      .orderBy(asc(agentContextSources.ordinal));
+    return {
+      contextVersionId: version.contextVersionId,
+      sessionId: version.sessionId,
+      turnId: version.turnId,
+      runId: version.runId,
+      modelAttemptId: version.modelAttemptId,
+      ...(version.currentCaseId
+        ? { currentCaseId: version.currentCaseId }
+        : {}),
+      digest: version.digest,
+      createdAt: new Date(version.createdAt).toISOString(),
+      sources: sources.map((source) => ({
+        moduleKey: source.sourceModuleKey,
+        kind: source.sourceKind as ContextSourceReference["kind"],
+        id: source.sourceId,
+        version: source.sourceVersion,
+        sequence: source.sourceSequence,
+        digest: source.sourceDigest,
+        validity: {
+          status: source.validityStatus as "valid" | "invalid",
+          checkedAt: new Date(source.checkedAt).toISOString(),
+          ...(source.expiresAt
+            ? { expiresAt: new Date(source.expiresAt).toISOString() }
+            : {}),
+          ...(source.validityReason
+            ? {
+                reason:
+                  source.validityReason as ContextSourceReference["validity"]["reason"],
+              }
+            : {}),
+        },
+      })),
+    };
+  }
+}
+export class DrizzleMemoryProjectionStore
+  implements MemoryProjectionRecorder, MemoryProjectionPort
+{
+  constructor(
+    private readonly db: NodePgDatabase,
+    private readonly codec: AgentSessionPayloadCodec,
+  ) {}
+
+  append(projection: MemoryProjection): Promise<void> {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const encoded = this.codec.encode(projection);
+      const [created] = await db
+        .insert(agentMemoryProjections)
+        .values({
+          memoryId: projection.memoryId,
+          kind: projection.kind,
+          scopeKind: projection.scope.kind,
+          scopeId: memoryProjectionScopeId(projection),
+          currentCaseId: projection.currentCaseId,
+          derivedFromSessionId: projection.derivation.sessionId,
+          derivedThroughSequence: projection.derivation.throughSequence,
+          payloadCipher: encoded.cipher,
+          payloadDigest: encoded.digest,
+          expiresAt: projection.expiresAt
+            ? Date.parse(projection.expiresAt)
+            : undefined,
+          createdAt: Date.parse(projection.createdAt),
+          updatedAt: Date.parse(projection.createdAt),
+        })
+        .onConflictDoNothing({ target: agentMemoryProjections.memoryId })
+        .returning({ id: agentMemoryProjections.memoryId });
+      if (!created) {
+        const existing = await this.read(
+          projection.memoryId,
+          {} as RequestGuardContext,
+          new AbortController().signal,
+        );
+        if (
+          !existing ||
+          existing.version !== projection.version ||
+          existing.digest !== projection.digest ||
+          existing.derivation.sessionId !== projection.derivation.sessionId ||
+          existing.derivation.throughSequence !==
+            projection.derivation.throughSequence ||
+          !sameMemoryProjectionCoordinates(existing, projection)
+        )
+          throw new Error("Memory trigger 已绑定其它投影");
+        return;
+      }
+      if (projection.sources.length) {
+        await db
+          .insert(agentMemorySources)
+          .values(
+            projection.sources.map((source, ordinal) =>
+              memorySourceValues(projection.memoryId, ordinal, source),
+            ),
+          );
+      }
+    });
+  }
+
+  async read(
+    memoryId: string,
+    _guardContext: RequestGuardContext,
+    _signal: AbortSignal,
+  ) {
+    const now = Date.now();
+    const [row] = await this.db
+      .select()
+      .from(agentMemoryProjections)
+      .where(
+        and(
+          eq(agentMemoryProjections.memoryId, memoryId),
+          eq(agentMemoryProjections.status, "active"),
+        ),
+      )
+      .limit(1);
+    if (!row || (row.expiresAt !== null && row.expiresAt <= now))
+      return undefined;
+    return decodeMemoryRow(this.codec, row);
+  }
+
+  async listForSession(sessionId: string, limit = 100) {
+    const rows = await this.db
+      .select()
+      .from(agentMemoryProjections)
+      .where(
+        and(
+          eq(agentMemoryProjections.derivedFromSessionId, sessionId),
+          eq(agentMemoryProjections.status, "active"),
+          or(
+            isNull(agentMemoryProjections.expiresAt),
+            gt(agentMemoryProjections.expiresAt, Date.now()),
+          ),
+        ),
+      )
+      .orderBy(desc(agentMemoryProjections.updatedAt))
+      .limit(limit);
+    return rows.map((row) => ({
+      projection: decodeMemoryRow(this.codec, row),
+      status: row.status as "active" | "invalidated" | "deleted",
+      derivedFromSessionId: row.derivedFromSessionId,
+      derivedThroughSequence: row.derivedThroughSequence,
+    }));
+  }
+
+  async readForSession(sessionId: string, memoryId: string) {
+    const [row] = await this.db
+      .select()
+      .from(agentMemoryProjections)
+      .where(
+        and(
+          eq(agentMemoryProjections.memoryId, memoryId),
+          eq(agentMemoryProjections.derivedFromSessionId, sessionId),
+          eq(agentMemoryProjections.status, "active"),
+        ),
+      )
+      .limit(1);
+    if (!row || (row.expiresAt !== null && row.expiresAt <= Date.now())) {
+      return undefined;
+    }
+    return {
+      projection: decodeMemoryRow(this.codec, row),
+      status: row.status as "active" | "invalidated" | "deleted",
+      derivedFromSessionId: row.derivedFromSessionId,
+      derivedThroughSequence: row.derivedThroughSequence,
+    };
+  }
+}
+export class DrizzleContextProjectionReader {
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async listForSession(sessionId: string, limit = 100) {
+    const versions = await this.db
+      .select()
+      .from(agentContextVersions)
+      .where(eq(agentContextVersions.sessionId, sessionId))
+      .orderBy(desc(agentContextVersions.createdAt))
+      .limit(limit);
+    if (!versions.length) return [];
+    const sources = await this.db
+      .select()
+      .from(agentContextSources)
+      .where(
+        inArray(
+          agentContextSources.contextVersionId,
+          versions.map(({ contextVersionId }) => contextVersionId),
+        ),
+      )
+      .orderBy(asc(agentContextSources.ordinal));
+    return versions.map((version) => ({
+      ...version,
+      sources: sources.filter(
+        (source) => source.contextVersionId === version.contextVersionId,
+      ),
+    }));
+  }
+}
+function contextSourceValues(
+  contextVersionId: string,
+  ordinal: number,
+  source: ContextSourceReference,
+) {
+  return {
+    contextVersionId,
+    ordinal,
+    sourceModuleKey: source.moduleKey,
+    sourceKind: source.kind,
+    sourceId: source.id,
+    sourceVersion: source.version,
+    sourceSequence: source.sequence,
+    sourceDigest: source.digest,
+    validityStatus: source.validity.status,
+    validityReason: source.validity.reason,
+    checkedAt: Date.parse(source.validity.checkedAt),
+    expiresAt: source.validity.expiresAt
+      ? Date.parse(source.validity.expiresAt)
+      : undefined,
+  };
+}
+function memorySourceValues(
+  memoryId: string,
+  ordinal: number,
+  source: ContextSourceReference,
+) {
+  return {
+    memoryId,
+    ordinal,
+    sourceModuleKey: source.moduleKey,
+    sourceKind: source.kind,
+    sourceId: source.id,
+    sourceVersion: source.version,
+    sourceSequence: source.sequence,
+    sourceDigest: source.digest,
+    validityStatus: source.validity.status,
+    validityReason: source.validity.reason,
+    checkedAt: Date.parse(source.validity.checkedAt),
+    expiresAt: source.validity.expiresAt
+      ? Date.parse(source.validity.expiresAt)
+      : undefined,
+  };
+}
+
+function decodeMemoryRow(
+  codec: AgentSessionPayloadCodec,
+  row: typeof agentMemoryProjections.$inferSelect,
+): MemoryProjection {
+  const projection = codec.decode<MemoryProjection>(
+    row.payloadCipher,
+    row.payloadDigest,
+  );
+  if (
+    projection.kind !== row.kind ||
+    projection.scope.kind !== row.scopeKind ||
+    memoryProjectionScopeId(projection) !== row.scopeId ||
+    projection.derivation.sessionId !== row.derivedFromSessionId ||
+    projection.derivation.throughSequence !== row.derivedThroughSequence ||
+    projection.currentCaseId !== (row.currentCaseId ?? undefined)
+  )
+    throw new Error("Memory 投影坐标与持久行不一致");
+  return projection;
+}

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

@@ -0,0 +1,328 @@
+import {
+  agentContextMessages,
+  agentContextSources,
+  agentContextVersions,
+} from "@southwind-ai/database";
+import { and, asc, desc, eq, isNull, ne } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import type {
+  ContextMessageOrigin,
+  GovernedContextMessage,
+  GovernedContextVersion,
+  PreparedContextSource,
+} from "../context-memory/attempt-context-contracts.js";
+import type { ContextSourceReference } from "../context-memory/contracts.js";
+import { stableDigest } from "../context-memory/digest.js";
+import { recoverContextMessage } from "../context-message-recovery.js";
+import { AgentSessionPayloadCodec } from "./payload-codec.js";
+
+export class DrizzleGovernedContextStore {
+  constructor(
+    private readonly db: NodePgDatabase,
+    private readonly codec: AgentSessionPayloadCodec,
+  ) {}
+
+  record(version: GovernedContextVersion): Promise<void> {
+    return this.db.transaction(async (transaction) => {
+      const db = transaction as unknown as NodePgDatabase;
+      const [created] = await db
+        .insert(agentContextVersions)
+        .values({
+          contextVersionId: version.contextVersionId,
+          sessionId: version.sessionId,
+          turnId: version.turnId,
+          runId: version.runId,
+          modelAttemptId: version.modelAttemptId,
+          currentCaseId: version.currentCaseId,
+          digest: version.digest,
+          providerDeploymentKey: version.provider.deploymentKey,
+          providerModel: version.provider.model,
+          providerRequestDigest: version.provider.requestDigest,
+          toolsDigest: version.provider.toolsDigest,
+          outputSchemaDigest: version.provider.outputSchemaDigest,
+          committedAt: Date.parse(version.committedAt),
+          createdAt: Date.parse(version.createdAt),
+        })
+        .onConflictDoNothing({ target: agentContextVersions.modelAttemptId })
+        .returning({ id: agentContextVersions.contextVersionId });
+      if (!created) {
+        await this.requireSameAttempt(db, version);
+        await db
+          .update(agentContextVersions)
+          .set({
+            status: "active",
+            invalidatedAt: null,
+            invalidationReason: null,
+          })
+          .where(
+            eq(agentContextVersions.contextVersionId, version.contextVersionId),
+          );
+        return;
+      }
+      if (version.messages.length) {
+        await db
+          .insert(agentContextMessages)
+          .values(
+            version.messages.map((message) =>
+              messageValues(this.codec, version.contextVersionId, message),
+            ),
+          );
+      }
+      if (version.sources.length) {
+        await db
+          .insert(agentContextSources)
+          .values(
+            version.sources.map((source, ordinal) =>
+              sourceValues(version.contextVersionId, ordinal, source),
+            ),
+          );
+      }
+    });
+  }
+
+  async readByAttempt(
+    modelAttemptId: string,
+  ): Promise<GovernedContextVersion | undefined> {
+    const [version] = await this.db
+      .select()
+      .from(agentContextVersions)
+      .where(eq(agentContextVersions.modelAttemptId, modelAttemptId))
+      .limit(1);
+    if (!version || version.status !== "active" || !completeProvider(version)) {
+      return undefined;
+    }
+    const [messages, sources] = await Promise.all([
+      this.messages(version.contextVersionId),
+      this.sources(version.contextVersionId),
+    ]);
+    return mapVersion(version, messages, sources);
+  }
+
+  async invalidateAttempt(modelAttemptId: string, reason: string) {
+    await this.db
+      .update(agentContextVersions)
+      .set({
+        status: "invalidated",
+        invalidatedAt: Date.now(),
+        invalidationReason: reason,
+      })
+      .where(
+        and(
+          eq(agentContextVersions.modelAttemptId, modelAttemptId),
+          eq(agentContextVersions.status, "active"),
+        ),
+      );
+  }
+
+  async historySources(
+    sessionId: string,
+    currentRunId: string,
+    currentCaseId?: string,
+    _limitRuns = 12,
+  ): Promise<readonly PreparedContextSource[]> {
+    const versions = await this.db
+      .select()
+      .from(agentContextVersions)
+      .where(
+        and(
+          eq(agentContextVersions.sessionId, sessionId),
+          eq(agentContextVersions.status, "active"),
+          ne(agentContextVersions.runId, currentRunId),
+          currentCaseId
+            ? eq(agentContextVersions.currentCaseId, currentCaseId)
+            : isNull(agentContextVersions.currentCaseId),
+        ),
+      )
+      .orderBy(desc(agentContextVersions.createdAt))
+      .limit(1);
+    const result: PreparedContextSource[] = [];
+    for (const version of versions) {
+      for (const message of await this.messages(version.contextVersionId)) {
+        if (message.role === "system") continue;
+        const recovered = recoverContextMessage(message.role, message.content);
+        result.push({
+          role: recovered.role,
+          content: recovered.content,
+          reference: {
+            moduleKey: "system.agent",
+            kind: "working-context",
+            id: `${version.contextVersionId}:${message.ordinal}`,
+            version: version.contextVersionId,
+            sequence: message.ordinal + 1,
+            digest: recovered.digest,
+            validity: {
+              status: "valid",
+              checkedAt: new Date(
+                version.committedAt ?? version.createdAt,
+              ).toISOString(),
+            },
+          },
+        });
+      }
+    }
+    return result;
+  }
+
+  private async messages(contextVersionId: string) {
+    const rows = await this.db
+      .select()
+      .from(agentContextMessages)
+      .where(eq(agentContextMessages.contextVersionId, contextVersionId))
+      .orderBy(asc(agentContextMessages.ordinal));
+    return rows.map((row): GovernedContextMessage => {
+      const content = this.codec.decode<ModuleAiJsonValue>(
+        row.contentCipher,
+        row.payloadDigest,
+      );
+      return {
+        ordinal: row.ordinal,
+        role: row.role as GovernedContextMessage["role"],
+        content,
+        digest: row.contentDigest,
+        recoveryDigest: stableDigest({ role: row.role, content }),
+        origins: row.originsJson as unknown as readonly ContextMessageOrigin[],
+      };
+    });
+  }
+
+  private async sources(contextVersionId: string) {
+    const rows = await this.db
+      .select()
+      .from(agentContextSources)
+      .where(eq(agentContextSources.contextVersionId, contextVersionId))
+      .orderBy(asc(agentContextSources.ordinal));
+    return rows.map(mapSource);
+  }
+
+  private async requireSameAttempt(
+    db: NodePgDatabase,
+    version: GovernedContextVersion,
+  ) {
+    const [existing] = await db
+      .select()
+      .from(agentContextVersions)
+      .where(eq(agentContextVersions.modelAttemptId, version.modelAttemptId))
+      .limit(1);
+    if (
+      !existing ||
+      existing.contextVersionId !== version.contextVersionId ||
+      existing.sessionId !== version.sessionId ||
+      existing.turnId !== version.turnId ||
+      existing.runId !== version.runId ||
+      (existing.currentCaseId ?? undefined) !== version.currentCaseId ||
+      existing.digest !== version.digest ||
+      existing.providerRequestDigest !== version.provider.requestDigest
+    ) {
+      throw new Error("Model attempt 已绑定其它 governed Context Version");
+    }
+  }
+}
+
+function messageValues(
+  codec: AgentSessionPayloadCodec,
+  contextVersionId: string,
+  message: GovernedContextMessage,
+) {
+  const encoded = codec.encode(message.content);
+  return {
+    contextVersionId,
+    ordinal: message.ordinal,
+    role: message.role,
+    contentCipher: encoded.cipher,
+    payloadDigest: encoded.digest,
+    contentDigest: message.digest,
+    originsJson: message.origins as unknown as readonly Record<
+      string,
+      unknown
+    >[],
+  };
+}
+
+function sourceValues(
+  contextVersionId: string,
+  ordinal: number,
+  source: ContextSourceReference,
+) {
+  return {
+    contextVersionId,
+    ordinal,
+    sourceModuleKey: source.moduleKey,
+    sourceKind: source.kind,
+    sourceId: source.id,
+    sourceVersion: source.version,
+    sourceSequence: source.sequence,
+    sourceDigest: source.digest,
+    validityStatus: source.validity.status,
+    validityReason: source.validity.reason,
+    checkedAt: Date.parse(source.validity.checkedAt),
+    expiresAt: source.validity.expiresAt
+      ? Date.parse(source.validity.expiresAt)
+      : undefined,
+  };
+}
+
+function mapSource(
+  row: typeof agentContextSources.$inferSelect,
+): ContextSourceReference {
+  return {
+    moduleKey: row.sourceModuleKey,
+    kind: row.sourceKind as ContextSourceReference["kind"],
+    id: row.sourceId,
+    version: row.sourceVersion,
+    sequence: row.sourceSequence,
+    digest: row.sourceDigest,
+    validity: {
+      status: row.validityStatus as "valid" | "invalid",
+      checkedAt: new Date(row.checkedAt).toISOString(),
+      ...(row.expiresAt
+        ? { expiresAt: new Date(row.expiresAt).toISOString() }
+        : {}),
+      ...(row.validityReason
+        ? {
+            reason:
+              row.validityReason as ContextSourceReference["validity"]["reason"],
+          }
+        : {}),
+    },
+  };
+}
+
+function completeProvider(row: typeof agentContextVersions.$inferSelect) {
+  return Boolean(
+    row.providerDeploymentKey &&
+    row.providerModel &&
+    row.providerRequestDigest &&
+    row.toolsDigest &&
+    row.outputSchemaDigest &&
+    row.committedAt,
+  );
+}
+
+function mapVersion(
+  row: typeof agentContextVersions.$inferSelect,
+  messages: readonly GovernedContextMessage[],
+  sources: readonly ContextSourceReference[],
+): GovernedContextVersion {
+  if (!completeProvider(row)) throw new Error("Context Version 未完成");
+  return {
+    contextVersionId: row.contextVersionId,
+    sessionId: row.sessionId,
+    turnId: row.turnId,
+    runId: row.runId,
+    modelAttemptId: row.modelAttemptId,
+    ...(row.currentCaseId ? { currentCaseId: row.currentCaseId } : {}),
+    digest: row.digest,
+    sources,
+    messages,
+    provider: {
+      deploymentKey: row.providerDeploymentKey!,
+      model: row.providerModel!,
+      requestDigest: row.providerRequestDigest!,
+      toolsDigest: row.toolsDigest!,
+      outputSchemaDigest: row.outputSchemaDigest!,
+    },
+    committedAt: new Date(row.committedAt!).toISOString(),
+    createdAt: new Date(row.createdAt).toISOString(),
+  };
+}