create-windy 0.6.12 → 0.6.14

package/template/apps/server/src/agent/context-version-runtime.ts

@@ -0,0 +1,332 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import type { RequestActor, RequestGuardContext } from "../guards.js";
+import type { createServerRuntime } from "../runtime.js";
+import type {
+  GovernedContextMessage,
+  GovernedContextVersion,
+  ProviderContextEnvelope,
+} from "./context-memory/attempt-context-contracts.js";
+import { ContextBuilder } from "./context-memory/context-builder.js";
+import type { ContextSourceRequest } from "./context-memory/contracts.js";
+import { MEMORY_KINDS } from "./context-memory/contracts.js";
+import { stableDigest } from "./context-memory/digest.js";
+import type { GovernedMemoryRetriever } from "./context-memory/memory-retriever.js";
+import type { MemoryProjectionTriggerPort } from "./context-memory/memory-projector.js";
+import { AgentRunAuthorizationStore } from "./run-authorization.js";
+import { AgentRunSessionBindingAuthorizer } from "./run-session-authorization.js";
+import { SessionTurnContextSourcePort } from "./session-context-source.js";
+import type { SessionProjectionSourceAuthorizer } from "./session-projection-access.js";
+import type { SessionId, SessionTurnId } from "./session-log/domain.js";
+import { DrizzleGovernedContextStore } from "./session-persistence/drizzle-governed-context.js";
+import { DrizzleSessionEventRepository } from "./session-persistence/drizzle-session-repository.js";
+import { AgentSessionPayloadCodec } from "./session-persistence/payload-codec.js";
+import type { SessionTerminalReconciler } from "./session-terminal-reconciler.js";
+import {
+  coordinate,
+  deduplicate,
+  deduplicateReferences,
+  memorySource,
+  messageReference,
+  referenceKey,
+  validateCommit,
+} from "./context-version-validation.js";
+import { normalizeCaseId } from "./memory-scope-binding.js";
+import {
+  contextVersionUnavailable as unavailable,
+  linkedTurn,
+  preparationId,
+  recoveryText,
+  versionId,
+  workingItems,
+} from "./context-version-support.js";
+
+type ServerRuntime = ReturnType<typeof createServerRuntime>;
+
+export interface AttemptContextBaseInput {
+  readonly sessionId: string;
+  readonly turnId: string;
+  readonly runId: string;
+  readonly modelAttemptId: string;
+  readonly authorizationGrant: string;
+  readonly sources: readonly ContextSourceRequest[];
+  readonly requestId: string;
+  readonly caseId?: string;
+}
+
+export interface CommitAttemptContextInput extends AttemptContextBaseInput {
+  readonly preparationId: string;
+  readonly provider: ProviderContextEnvelope;
+  readonly messages: readonly GovernedContextMessage[];
+}
+
+export class AgentContextVersionRuntime {
+  readonly #store: DrizzleGovernedContextStore;
+
+  constructor(
+    db: NodePgDatabase,
+    secret: string,
+    private readonly repository: DrizzleSessionEventRepository,
+    private readonly runtime: ServerRuntime,
+    private readonly authorizations: AgentRunAuthorizationStore,
+    private readonly sessionAuthorization: AgentRunSessionBindingAuthorizer,
+    private readonly resolveActor: (
+      actorId: string,
+    ) => Promise<RequestActor | undefined>,
+    private readonly sourceAuthorizer: SessionProjectionSourceAuthorizer,
+    private readonly memories: GovernedMemoryRetriever,
+    private readonly memoryFeature: FeatureFlagDefinition,
+    private readonly memoryProjector: MemoryProjectionTriggerPort,
+    private readonly terminalReconciler: SessionTerminalReconciler,
+  ) {
+    this.#store = new DrizzleGovernedContextStore(
+      db,
+      new AgentSessionPayloadCodec(secret),
+    );
+  }
+
+  async prepare(input: AttemptContextBaseInput, signal: AbortSignal) {
+    const context = await this.guard(input);
+    await this.terminalReconciler.reconcile(input.sessionId, context, signal);
+    const resolved = await this.resolveSources(input, context, signal);
+    return {
+      preparationId: preparationId(input, resolved.prepared),
+      sources: resolved.prepared,
+    };
+  }
+
+  async commit(input: CommitAttemptContextInput, signal: AbortSignal) {
+    const context = await this.guard(input);
+    const currentCaseId = normalizeCaseId(input.caseId);
+    const resolved = await this.resolveSources(input, context, signal);
+    if (input.preparationId !== preparationId(input, resolved.prepared)) {
+      throw unavailable();
+    }
+    validateCommit(input, resolved.prepared);
+    const contextVersionId = versionId(input.modelAttemptId);
+    await this.sourceAuthorizer.requireAll(
+      resolved.authority.map(coordinate),
+      context,
+    );
+    const now = new Date().toISOString();
+    const version: GovernedContextVersion = {
+      contextVersionId,
+      sessionId: input.sessionId,
+      turnId: input.turnId,
+      runId: input.runId,
+      modelAttemptId: input.modelAttemptId,
+      ...(currentCaseId ? { currentCaseId } : {}),
+      sources: [
+        ...resolved.authority,
+        ...input.messages.map((message) =>
+          messageReference(contextVersionId, message),
+        ),
+      ],
+      messages: structuredClone(input.messages),
+      provider: input.provider,
+      digest: stableDigest({
+        contractVersion: 2,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        runId: input.runId,
+        modelAttemptId: input.modelAttemptId,
+        currentCaseId,
+        provider: input.provider,
+        messages: input.messages,
+        prepared: resolved.prepared.map(({ reference }) => reference),
+      }),
+      committedAt: now,
+      createdAt: now,
+    };
+    await this.#store.record(version);
+    try {
+      await this.projectAttemptMemories(version, context, signal);
+    } catch {
+      await this.#store.invalidateAttempt(
+        input.modelAttemptId,
+        "projection-failed",
+      );
+      throw unavailable();
+    }
+    return version;
+  }
+
+  async abort(input: AttemptContextBaseInput & { preparationId: string }) {
+    await this.guard(input);
+    const existing = await this.#store.readByAttempt(input.modelAttemptId);
+    return existing ? ("absent" as const) : ("aborted" as const);
+  }
+
+  private async resolveSources(
+    input: AttemptContextBaseInput,
+    context: RequestGuardContext,
+    signal: AbortSignal,
+  ) {
+    if (input.sources.length !== 1) throw unavailable();
+    const sourcePort = new SessionTurnContextSourcePort(
+      this.repository,
+      input.sessionId as SessionId,
+      input.turnId as SessionTurnId,
+    );
+    const builder = new ContextBuilder(sourcePort, {
+      record: async () => {
+        throw unavailable();
+      },
+    });
+    const current = await builder.resolve(
+      { ...input, guardContext: context },
+      signal,
+    );
+    const currentCaseId = normalizeCaseId(input.caseId);
+    const history = await this.#store.historySources(
+      input.sessionId,
+      input.runId,
+      currentCaseId,
+    );
+    await this.sourceAuthorizer.requireAll(
+      history.map(({ reference }) => coordinate(reference)),
+      context,
+    );
+    const memory = await this.memories.retrieve(
+      {
+        query: current.map(({ content }) => content).join("\n"),
+        sessionId: input.sessionId,
+        kinds: [
+          "working-context",
+          "session-summary",
+          "user-preference",
+          "case-memory-candidate",
+          "verified-fact-reference",
+        ],
+        limit: 20,
+        feature: this.memoryFeature,
+        permissionKey: `${this.memoryFeature.key}.manage`,
+        guardContext: context,
+        ...(currentCaseId ? { caseId: currentCaseId } : {}),
+      },
+      signal,
+    );
+    const currentKeys = new Set(
+      current.map(({ reference }) => referenceKey(reference)),
+    );
+    const memorySources = memory.items.map(({ projection }) =>
+      memorySource(projection),
+    );
+    const optional = deduplicate([...history, ...memorySources]).filter(
+      ({ reference }) => !currentKeys.has(referenceKey(reference)),
+    );
+    const prepared = [...current, ...optional.slice(-(128 - current.length))];
+    const authority = deduplicateReferences([
+      ...current.map(({ reference }) => reference),
+      ...history.map(({ reference }) => reference),
+      ...memorySources.map(({ reference }) => reference),
+      ...memory.items.flatMap(({ projection }) => projection.sources),
+    ]);
+    return { prepared, authority };
+  }
+
+  private async guard(input: AttemptContextBaseInput) {
+    const binding = await this.authorizations.authorizeTool(
+      input.authorizationGrant,
+      input.runId,
+    );
+    const currentCaseId = normalizeCaseId(input.caseId);
+    if (binding.authorizationSnapshot.memoryScopeCaseId !== currentCaseId)
+      throw unavailable();
+    const actor = await this.resolveActor(binding.actorId);
+    if (!actor || actor.type === "anonymous") throw unavailable();
+    const context = await this.runtime.createGuardContextForActor(
+      new Request("http://windy.internal/api/internal/agent/context-versions", {
+        headers: { "x-request-id": input.requestId },
+      }),
+      actor,
+    );
+    this.authorizations.assertCurrentScope(binding, context);
+    await this.sessionAuthorization.requireManage(context);
+    const session = await this.repository.get(input.sessionId as SessionId);
+    const scope = `sha256:${captureAuthorizationScope(actor.scopeContext).hash}`;
+    if (
+      !session ||
+      session.status !== "active" ||
+      session.governance.actorId !== actor.id ||
+      session.governance.scopeDigest !== scope ||
+      !(await linkedTurn(
+        this.repository,
+        session.sessionId,
+        input.runId,
+        input.turnId,
+      ))
+    )
+      throw unavailable();
+    return context;
+  }
+
+  private async projectAttemptMemories(
+    version: GovernedContextVersion,
+    context: RequestGuardContext,
+    signal: AbortSignal,
+  ) {
+    const session = await this.repository.get(version.sessionId as SessionId);
+    if (!session) throw unavailable();
+    const sources = deduplicateReferences([
+      ...version.messages.map((message) =>
+        messageReference(version.contextVersionId, message),
+      ),
+      ...version.sources.filter(
+        ({ moduleKey, kind, id }) =>
+          moduleKey === "system.agent" &&
+          MEMORY_KINDS.includes(kind as (typeof MEMORY_KINDS)[number]) &&
+          id.startsWith("memory_"),
+      ),
+    ]);
+    const items = workingItems(version.messages);
+    if (items.length) {
+      await this.memoryProjector.projectWorkingContext(
+        {
+          kind: "working-context",
+          triggerId: `${version.contextVersionId}:working`,
+          sessionId: version.sessionId,
+          derivation: {
+            sessionId: version.sessionId,
+            throughSequence: session.headSequence,
+          },
+          sources,
+          items,
+          ...(version.currentCaseId
+            ? { currentCaseId: version.currentCaseId }
+            : {}),
+        },
+        context,
+        signal,
+      );
+    }
+    const summary = version.messages
+      .filter(({ role }) => role === "assistant")
+      .map(({ content }) => recoveryText(content))
+      .filter(Boolean)
+      .slice(-4)
+      .join("\n");
+    if (summary) {
+      await this.memoryProjector.projectSessionSummary(
+        {
+          kind: "session-summary",
+          triggerId: `${version.contextVersionId}:summary`,
+          sessionId: version.sessionId,
+          derivation: {
+            sessionId: version.sessionId,
+            throughSequence: session.headSequence,
+          },
+          sources,
+          summary: summary.slice(0, 8_000),
+          coveredThroughSequence: session.headSequence,
+          ...(version.currentCaseId
+            ? { currentCaseId: version.currentCaseId }
+            : {}),
+        },
+        context,
+        signal,
+      );
+    }
+  }
+}

package/template/apps/server/src/agent/context-version-support.ts

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import type {
+  GovernedContextMessage,
+  PreparedContextSource,
+} from "./context-memory/attempt-context-contracts.js";
+import { stableDigest } from "./context-memory/digest.js";
+import type { WorkingContextItem } from "./context-memory/memory-projector.js";
+import { normalizeCaseId } from "./memory-scope-binding.js";
+import type { SessionId } from "./session-log/domain.js";
+import type { DrizzleSessionEventRepository } from "./session-persistence/drizzle-session-repository.js";
+
+export async function linkedTurn(
+  repository: DrizzleSessionEventRepository,
+  sessionId: SessionId,
+  runId: string,
+  turnId: string,
+) {
+  const session = await repository.get(sessionId);
+  if (!session) return false;
+  const events = await repository.read({
+    sessionId,
+    afterSequence: 0,
+    throughSequence: session.headSequence,
+    limit: Math.max(1, session.headSequence),
+  });
+  return events.some(
+    ({ data }) =>
+      data.type === "run.linked" &&
+      data.runId === runId &&
+      data.turnId === turnId,
+  );
+}
+
+export function workingItems(
+  messages: readonly GovernedContextMessage[],
+): WorkingContextItem[] {
+  const items: WorkingContextItem[] = [];
+  for (const message of messages) {
+    const content = recoveryText(message.content);
+    if (!content) continue;
+    if (message.role === "user") {
+      items.push({ type: "user-message", content });
+    } else if (message.role === "assistant") {
+      items.push({ type: "assistant-summary", summary: content });
+    } else if (message.role === "tool") {
+      const receipt = message.origins.find(
+        ({ type }) => type === "tool-receipt",
+      );
+      if (receipt)
+        items.push({
+          type: "tool-receipt",
+          toolKey: "provider-tool",
+          receiptId: receipt.sourceId,
+          resultDigest: `sha256:${message.digest}`,
+        });
+    }
+  }
+  return items.slice(-64);
+}
+
+export function recoveryText(value: unknown) {
+  if (typeof value === "string") return value.trim();
+  if (value === null || value === undefined) return "";
+  return JSON.stringify(value);
+}
+
+export function preparationId(
+  input: {
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly runId: string;
+    readonly modelAttemptId: string;
+    readonly caseId?: string;
+  },
+  sources: readonly PreparedContextSource[],
+) {
+  return `context_prepare_${stableDigest({
+    sessionId: input.sessionId,
+    turnId: input.turnId,
+    runId: input.runId,
+    modelAttemptId: input.modelAttemptId,
+    currentCaseId: normalizeCaseId(input.caseId),
+    sources,
+  }).slice(0, 48)}`;
+}
+
+export function versionId(modelAttemptId: string) {
+  return `context_${createHash("sha256").update(modelAttemptId).digest("hex").slice(0, 48)}`;
+}
+
+export function contextVersionUnavailable() {
+  return new Error("Context Version 暂不可用");
+}

package/template/apps/server/src/agent/context-version-validation.ts

@@ -0,0 +1,118 @@
+import type {
+  ContextMessageOrigin,
+  GovernedContextMessage,
+  PreparedContextSource,
+} from "./context-memory/attempt-context-contracts.js";
+import type {
+  ContextSourceReference,
+  MemoryProjection,
+} from "./context-memory/contracts.js";
+import { stableDigest } from "./context-memory/digest.js";
+import { memoryProjectionContent } from "./context-memory/memory-content.js";
+import type { CommitAttemptContextInput } from "./context-version-runtime.js";
+
+export function validateCommit(
+  input: CommitAttemptContextInput,
+  prepared: readonly PreparedContextSource[],
+) {
+  if (!input.messages.length || input.messages.length > 256) throw unavailable();
+  const expected = new Set(prepared.map(({ reference }) => referenceKey(reference)));
+  const observed = new Set<string>();
+  input.messages.forEach((message, ordinal) => {
+    if (
+      message.ordinal !== ordinal ||
+      !["system", "user", "assistant", "tool"].includes(message.role) ||
+      !/^[a-f0-9]{64}$/.test(message.digest) ||
+      !/^[a-f0-9]{64}$/.test(message.recoveryDigest) ||
+      message.recoveryDigest !== stableDigest({ role: message.role, content: message.content }) ||
+      !message.origins.length
+    ) throw unavailable();
+    for (const origin of message.origins) {
+      validateOrigin(origin);
+      if (origin.source) observed.add(referenceKey(origin.source));
+    }
+  });
+  if ([...expected].some((key) => !observed.has(key))) throw unavailable();
+  if (
+    !input.provider.deploymentKey.trim() ||
+    !input.provider.model.trim() ||
+    ![input.provider.requestDigest, input.provider.toolsDigest, input.provider.outputSchemaDigest]
+      .every((value) => /^[a-f0-9]{64}$/.test(value))
+  ) throw unavailable();
+}
+
+function validateOrigin(origin: ContextMessageOrigin) {
+  if (
+    !origin.sourceId.trim() ||
+    !origin.sourceVersion.trim() ||
+    !/^[a-f0-9]{64}$/.test(origin.digest)
+  ) throw unavailable();
+  if (origin.source && origin.digest !== origin.source.digest) throw unavailable();
+}
+
+export function messageReference(
+  contextVersionId: string,
+  message: GovernedContextMessage,
+): ContextSourceReference {
+  return {
+    moduleKey: "system.agent",
+    kind: messageSourceKind(message),
+    id: `${contextVersionId}:${message.ordinal}`,
+    version: contextVersionId,
+    sequence: message.ordinal + 1,
+    digest: message.recoveryDigest,
+    validity: { status: "valid", checkedAt: new Date().toISOString() },
+  };
+}
+
+function messageSourceKind(message: GovernedContextMessage) {
+  const types = new Set(message.origins.map(({ type }) => type));
+  if (types.has("instructions")) return "system-instruction" as const;
+  if (types.has("user-prompt")) return "operation-instruction" as const;
+  if (types.has("artifact")) return "artifact-summary" as const;
+  return "working-context" as const;
+}
+
+export function coordinate(reference: ContextSourceReference) {
+  return { ...reference, valid: reference.validity.status === "valid" };
+}
+
+export function deduplicate(sources: readonly PreparedContextSource[]) {
+  const found = new Map<string, PreparedContextSource>();
+  for (const source of sources) found.set(referenceKey(source.reference), source);
+  return [...found.values()];
+}
+
+export function deduplicateReferences(
+  references: readonly ContextSourceReference[],
+) {
+  const found = new Map<string, ContextSourceReference>();
+  for (const reference of references) found.set(referenceKey(reference), reference);
+  return [...found.values()];
+}
+
+export function memorySource(projection: MemoryProjection): PreparedContextSource {
+  const content = memoryProjectionContent(projection);
+  return {
+    role: "system",
+    content,
+    reference: {
+      moduleKey: "system.agent",
+      kind: projection.kind,
+      id: projection.memoryId,
+      version: projection.version,
+      sequence: projection.derivation.throughSequence,
+      digest: stableDigest({ role: "system", content }),
+      validity: projection.validity,
+    },
+  };
+}
+
+export function referenceKey(reference: ContextSourceReference) {
+  return [reference.moduleKey, reference.kind, reference.id, reference.version,
+    reference.sequence, reference.digest].join("\u0000");
+}
+
+function unavailable() {
+  return new Error("Context Version 暂不可用");
+}

package/template/apps/server/src/agent/drizzle-run-binding-repository.ts

@@ -50,6 +50,15 @@ export class DrizzleAgentRunBindingRepository implements AgentRunBindingReposito
     return binding ? map(binding) : undefined;
   }
 
+  async findByIdempotencyHash(hash: string) {
+    const [binding] = await this.db
+      .select()
+      .from(agentRunBindings)
+      .where(eq(agentRunBindings.idempotencyHash, hash))
+      .limit(1);
+    return binding ? map(binding) : undefined;
+  }
+
   async findByTokenHash(tokenHash: string) {
     const [binding] = await this.db
       .select()
@@ -81,6 +90,7 @@ function values(binding: AgentRunBinding) {
   return {
     bindingId: binding.bindingId,
     runId: binding.runId,
+    sessionId: binding.sessionId,
     operationKey: binding.operationKey,
     actorId: binding.actorId,
     idempotencyHash: binding.idempotencyHash,
@@ -100,6 +110,7 @@ function map(row: typeof agentRunBindings.$inferSelect): AgentRunBinding {
   return {
     bindingId: row.bindingId,
     runId: row.runId ?? undefined,
+    sessionId: row.sessionId ?? undefined,
     operationKey: row.operationKey,
     actorId: row.actorId,
     idempotencyHash: row.idempotencyHash,

package/template/apps/server/src/agent/idempotency-key.ts

@@ -4,8 +4,16 @@ export function scopedRuntimeIdempotencyKey(
   actorId: string,
   operationKey: string,
   idempotencyKey: string,
+  sessionId?: string,
 ) {
   return createHash("sha256")
-    .update(`${actorId}\u0000${operationKey}\u0000${idempotencyKey}`)
+    .update(
+      [
+        actorId,
+        operationKey,
+        idempotencyKey,
+        ...(sessionId ? [`session:${sessionId}`] : []),
+      ].join("\u0000"),
+    )
     .digest("hex");
 }