create-windy 0.6.12 → 0.6.14

package/template/apps/server/src/agent-workflow/in-memory-evaluation-repository.ts

@@ -0,0 +1,123 @@
+import type { AgentWorkflowEvaluationRecord } from "@southwind-ai/shared";
+import {
+  AgentWorkflowEvaluationRepositoryConflict,
+  assertEvaluationRecordIntegrity,
+  canonicalEvaluationJson,
+  evaluationTrialCoordinate,
+  immutableEvaluationClone,
+  type AgentWorkflowEvaluationOwner,
+  type AgentWorkflowEvaluationRepository,
+  type AgentWorkflowEvaluationTrialCoordinate,
+} from "./evaluation-repository.js";
+
+export class InMemoryAgentWorkflowEvaluationRepository implements AgentWorkflowEvaluationRepository {
+  private readonly records = new Map<string, AgentWorkflowEvaluationRecord>();
+  private readonly trialIndex = new Map<string, string>();
+
+  async getById(evaluationId: string, owner: AgentWorkflowEvaluationOwner) {
+    const record = this.records.get(evaluationId);
+    return record && ownedBy(record, owner) ? clone(record) : undefined;
+  }
+
+  async findByTrial(coordinate: AgentWorkflowEvaluationTrialCoordinate) {
+    const evaluationId = this.trialIndex.get(trialKey(coordinate));
+    return evaluationId ? clone(this.records.get(evaluationId)) : undefined;
+  }
+
+  async listBySet(
+    evaluationSetKey: string,
+    evaluationSetVersion: string,
+    owner: AgentWorkflowEvaluationOwner,
+  ) {
+    return [...this.records.values()]
+      .filter(
+        (record) =>
+          ownedBy(record, owner) &&
+          record.identity.evaluationSetKey === evaluationSetKey &&
+          record.identity.evaluationSetVersion === evaluationSetVersion,
+      )
+      .sort(compareRecords)
+      .map((record) => immutableEvaluationClone(record));
+  }
+
+  async appendTerminal(record: AgentWorkflowEvaluationRecord) {
+    assertEvaluationRecordIntegrity(record);
+    if (record.status === "pending") {
+      throw new AgentWorkflowEvaluationRepositoryConflict(
+        "PENDING_NOT_PERSISTABLE",
+      );
+    }
+    const frozen = immutableEvaluationClone(record);
+    const byId = this.records.get(record.evaluationId);
+    if (byId) {
+      if (!sameRecord(byId, frozen)) {
+        throw new AgentWorkflowEvaluationRepositoryConflict(
+          "EVALUATION_ID_CONFLICT",
+        );
+      }
+      return immutableEvaluationClone(byId);
+    }
+    const coordinateKey = trialKey(evaluationTrialCoordinate(record));
+    const existingId = this.trialIndex.get(coordinateKey);
+    if (existingId) {
+      const existing = this.records.get(existingId);
+      if (!existing || !sameRecord(existing, frozen)) {
+        throw new AgentWorkflowEvaluationRepositoryConflict("TRIAL_CONFLICT");
+      }
+      return immutableEvaluationClone(existing);
+    }
+    this.records.set(record.evaluationId, frozen);
+    this.trialIndex.set(coordinateKey, record.evaluationId);
+    return immutableEvaluationClone(frozen);
+  }
+}
+
+function ownedBy(
+  record: AgentWorkflowEvaluationRecord,
+  owner: AgentWorkflowEvaluationOwner,
+) {
+  return (
+    record.tenantId === owner.tenantId && record.createdBy === owner.createdBy
+  );
+}
+
+function trialKey(coordinate: AgentWorkflowEvaluationTrialCoordinate) {
+  return canonicalEvaluationJson(coordinate);
+}
+
+function compareRecords(
+  left: AgentWorkflowEvaluationRecord,
+  right: AgentWorkflowEvaluationRecord,
+) {
+  const leftIdentity = left.identity;
+  const rightIdentity = right.identity;
+  return (
+    leftIdentity.caseKey.localeCompare(rightIdentity.caseKey) ||
+    leftIdentity.caseVersion.localeCompare(rightIdentity.caseVersion) ||
+    leftIdentity.trialIndex - rightIdentity.trialIndex ||
+    leftIdentity.trialKey.localeCompare(rightIdentity.trialKey)
+  );
+}
+
+function sameRecord(
+  left: AgentWorkflowEvaluationRecord,
+  right: AgentWorkflowEvaluationRecord,
+) {
+  return (
+    canonicalEvaluationJson(withoutObservationTime(left)) ===
+    canonicalEvaluationJson(withoutObservationTime(right))
+  );
+}
+
+function clone<T>(value: T | undefined): T | undefined {
+  return value === undefined ? undefined : immutableEvaluationClone(value);
+}
+
+function withoutObservationTime(record: AgentWorkflowEvaluationRecord) {
+  const {
+    createdAt: _createdAt,
+    completedAt: _completedAt,
+    ...stable
+  } = structuredClone(record);
+  return stable;
+}

package/template/apps/server/src/agent-workflow/in-memory-mutation-validation.ts

@@ -0,0 +1,154 @@
+import type {
+  AgentWorkflowEventEnvelope,
+  AgentWorkflowNodeRun,
+  AgentWorkflowRun,
+} from "@southwind-ai/shared";
+import {
+  assertCanonicalWorkflowEventHistory,
+  assertParentChildEventCausality,
+} from "./event-validation.js";
+import {
+  assertPendingEvent,
+  conflict,
+} from "./in-memory-repository-support.js";
+import type {
+  AgentWorkflowRunMutation,
+  AgentWorkflowRunRecord,
+  CreateAgentWorkflowRunInput,
+  PendingAgentWorkflowEvent,
+} from "./repository.js";
+import {
+  assertImmutableNodeRunIdentity,
+  assertImmutableRunIdentity,
+  assertNodeInsertLineage,
+} from "./service-mutation-identity.js";
+import { canonicalJson } from "./canonical-json.js";
+
+export function assertInMemoryNodeChanges(
+  nodeRuns: ReadonlyMap<string, AgentWorkflowNodeRun>,
+  input: AgentWorkflowRunMutation,
+  currentRun?: AgentWorkflowRun,
+) {
+  if (input.runUpdate && currentRun) {
+    assertImmutableRunIdentity(currentRun, input.runUpdate.value);
+  }
+  for (const update of input.nodeUpdates ?? []) {
+    const current = nodeRuns.get(update.value.nodeRunId);
+    if (
+      !current ||
+      current.runId !== input.runId ||
+      current.version !== update.expectedVersion ||
+      update.value.version !== update.expectedVersion + 1
+    ) {
+      conflict("VERSION_CONFLICT");
+    }
+    assertImmutableNodeRunIdentity(current, update.value);
+  }
+  const ids = new Set<string>();
+  const attempts = new Set<string>();
+  for (const nodeRun of input.nodeInserts ?? []) {
+    const attemptKey = `${nodeRun.runId}\u0000${nodeRun.nodeId}\u0000${nodeRun.attempt}`;
+    if (
+      nodeRun.runId !== input.runId ||
+      ids.has(nodeRun.nodeRunId) ||
+      attempts.has(attemptKey) ||
+      nodeRuns.has(nodeRun.nodeRunId) ||
+      [...nodeRuns.values()].some(
+        (item) =>
+          item.runId === nodeRun.runId &&
+          item.nodeId === nodeRun.nodeId &&
+          item.attempt === nodeRun.attempt,
+      )
+    ) {
+      conflict("NODE_RUN_CONFLICT");
+    }
+    ids.add(nodeRun.nodeRunId);
+    attempts.add(attemptKey);
+    assertNodeInsertLineage(nodeRun, nodeRuns);
+  }
+}
+
+export function assertInMemoryRunLineage(input: {
+  readonly create: CreateAgentWorkflowRunInput;
+  readonly parentRun?: AgentWorkflowRunRecord;
+  readonly parentNode?: AgentWorkflowNodeRun;
+  readonly parentEvent?: AgentWorkflowEventEnvelope;
+}) {
+  const { create, parentRun, parentNode, parentEvent } = input;
+  const data = create.event.data;
+  if (data.type !== "workflow.run-created")
+    conflict("RUN_IDEMPOTENCY_CONFLICT");
+  if (
+    data.releaseId !== create.run.releaseId ||
+    canonicalJson(data.inputReceipt) !== canonicalJson(create.run.inputReceipt)
+  ) {
+    conflict("RUN_IDEMPOTENCY_CONFLICT");
+  }
+  const parentCoordinates = [
+    create.run.parentRunId,
+    create.run.parentNodeId,
+    create.run.parentNodeRunId,
+  ];
+  if (!parentCoordinates.every(Boolean)) {
+    if (
+      parentCoordinates.some(Boolean) ||
+      create.event.parentEventId ||
+      data.parentRunId ||
+      data.parentNodeId ||
+      data.parentNodeRunId ||
+      data.delegationId
+    ) {
+      conflict("RUN_IDEMPOTENCY_CONFLICT");
+    }
+    return;
+  }
+  const parentData = parentEvent?.data;
+  if (
+    data.parentRunId !== create.run.parentRunId ||
+    data.parentNodeId !== create.run.parentNodeId ||
+    data.parentNodeRunId !== create.run.parentNodeRunId ||
+    !data.delegationId ||
+    !parentRun ||
+    parentRun.run.tenantId !== create.run.tenantId ||
+    !parentNode ||
+    parentNode.runId !== parentRun.run.runId ||
+    parentNode.nodeId !== create.run.parentNodeId ||
+    !parentEvent ||
+    parentEvent.workflowRunId !== parentRun.run.runId ||
+    parentEvent.eventId !== create.event.parentEventId ||
+    parentEvent.childWorkflowRunId !== create.run.runId ||
+    parentData?.type !== "workflow.delegation-child-linked" ||
+    parentData.delegationId !== data.delegationId ||
+    parentData.parentNodeId !== create.run.parentNodeId ||
+    parentData.parentNodeRunId !== create.run.parentNodeRunId
+  ) {
+    conflict("RUN_IDEMPOTENCY_CONFLICT");
+  }
+}
+
+export async function assertInMemoryEventAppend(input: {
+  readonly runId: string;
+  readonly firstSequence: number;
+  readonly existing: readonly AgentWorkflowEventEnvelope[];
+  readonly events: readonly PendingAgentWorkflowEvent[];
+  readonly eventIds: ReadonlyMap<string, AgentWorkflowEventEnvelope>;
+  readonly envelopes: readonly AgentWorkflowEventEnvelope[];
+}) {
+  const ids = new Set<string>();
+  for (const [index, event] of input.events.entries()) {
+    assertPendingEvent(event, input.runId, input.firstSequence + index);
+    if (ids.has(event.eventId) || input.eventIds.has(event.eventId)) {
+      conflict("EVENT_ID_CONFLICT");
+    }
+    ids.add(event.eventId);
+  }
+  assertCanonicalWorkflowEventHistory([...input.existing, ...input.envelopes]);
+  for (const event of input.envelopes) {
+    await assertParentChildEventCausality({
+      event,
+      lookup: {
+        findCanonicalEvent: async (eventId) => input.eventIds.get(eventId),
+      },
+    });
+  }
+}

package/template/apps/server/src/agent-workflow/in-memory-repository-support.ts

@@ -0,0 +1,277 @@
+import {
+  AGENT_WORKFLOW_EVENT_SCHEMA_VERSION,
+  isAgentWorkflowNodeTerminal,
+  type AgentWorkflowEventEnvelope,
+  type AgentWorkflowNodeRun,
+  type AgentWorkflowRelease,
+  type AgentWorkflowSideEffectCommand,
+} from "@southwind-ai/shared";
+import {
+  AgentWorkflowRepositoryConflict,
+  type AgentWorkflowMutationResult,
+  type AgentWorkflowRunMutation,
+  type AgentWorkflowRunRecord,
+  type CreateAgentWorkflowRunInput,
+  type PendingAgentWorkflowEvent,
+} from "./repository.js";
+import { assertCanonicalWorkflowEvent } from "./event-validation.js";
+import { canonicalJson } from "./canonical-json.js";
+
+export function assertRunCreate(
+  input: CreateAgentWorkflowRunInput,
+  releaseExists: boolean,
+) {
+  if (
+    !releaseExists ||
+    input.run.status !== "accepted" ||
+    input.run.version !== 1 ||
+    input.run.finishedAt !== undefined ||
+    input.initialNodeRun.runId !== input.run.runId ||
+    input.initialNodeRun.status !== "pending" ||
+    input.initialNodeRun.attempt !== 1 ||
+    input.initialNodeRun.version !== 1 ||
+    input.event.data.type !== "workflow.run-created" ||
+    input.event.data.releaseId !== input.run.releaseId ||
+    !input.idempotencyKey.trim()
+  ) {
+    conflict("RUN_IDEMPOTENCY_CONFLICT");
+  }
+}
+
+export function validateRunMutation(
+  record: AgentWorkflowRunRecord,
+  input: AgentWorkflowRunMutation,
+) {
+  const update = input.runUpdate;
+  if (
+    update &&
+    (record.run.version !== update.expectedVersion ||
+      update.value.version !== update.expectedVersion + 1 ||
+      update.value.runId !== record.run.runId)
+  ) {
+    conflict("VERSION_CONFLICT");
+  }
+  if (
+    input.recovery &&
+    (record.recoveryCount !== input.recovery.expectedCount ||
+      input.recovery.nextCount !== input.recovery.expectedCount + 1)
+  ) {
+    conflict("VERSION_CONFLICT");
+  }
+  validateNodeTerminalEvents(input);
+}
+
+export function replayEvents(
+  runId: string,
+  events: readonly PendingAgentWorkflowEvent[],
+  ids: ReadonlyMap<string, AgentWorkflowEventEnvelope>,
+) {
+  const existing = events.map(({ eventId }) => ids.get(eventId));
+  if (existing.every(Boolean)) {
+    if (
+      existing.every(
+        (event, index) =>
+          event!.workflowRunId === runId && samePending(event!, events[index]!),
+      )
+    ) {
+      return existing as AgentWorkflowEventEnvelope[];
+    }
+    conflict("EVENT_ID_CONFLICT");
+  }
+  if (existing.some(Boolean)) conflict("EVENT_ID_CONFLICT");
+  return undefined;
+}
+
+export function assertPendingEvent(
+  event: PendingAgentWorkflowEvent,
+  runId: string,
+  sequence: number,
+) {
+  try {
+    assertCanonicalWorkflowEvent(envelope(runId, sequence, event));
+  } catch {
+    conflict("EVENT_ID_CONFLICT");
+  }
+}
+
+export function assertEventChronology(
+  previousAt: string | undefined,
+  events: readonly PendingAgentWorkflowEvent[],
+) {
+  let time = previousAt ? Date.parse(previousAt) : Number.NEGATIVE_INFINITY;
+  for (const event of events) {
+    const next = Date.parse(event.occurredAt);
+    if (!Number.isFinite(next) || next < time) conflict("EVENT_ID_CONFLICT");
+    time = next;
+  }
+}
+
+export function envelope(
+  runId: string,
+  sequence: number,
+  event: PendingAgentWorkflowEvent,
+): AgentWorkflowEventEnvelope {
+  return {
+    schemaVersion: AGENT_WORKFLOW_EVENT_SCHEMA_VERSION,
+    workflowRunId: runId,
+    sequence,
+    ...clone(event),
+  };
+}
+
+export function sameRunCreate(
+  record: AgentWorkflowRunRecord,
+  nodeRun: AgentWorkflowNodeRun,
+  input: CreateAgentWorkflowRunInput,
+) {
+  const {
+    createdAt: _existingCreated,
+    updatedAt: _existingUpdated,
+    ...existingRun
+  } = record.run;
+  const {
+    createdAt: _inputCreated,
+    updatedAt: _inputUpdated,
+    ...inputRun
+  } = input.run;
+  return (
+    record.idempotencyKey === input.idempotencyKey &&
+    same(existingRun, inputRun) &&
+    same(nodeRun, input.initialNodeRun)
+  );
+}
+
+export function assertMutationReplay(
+  record: AgentWorkflowRunRecord,
+  input: AgentWorkflowRunMutation,
+  nodeRuns: ReadonlyMap<string, AgentWorkflowNodeRun>,
+) {
+  if (
+    (input.runUpdate && !same(record.run, input.runUpdate.value)) ||
+    (input.recovery && record.recoveryCount !== input.recovery.nextCount) ||
+    [
+      ...(input.nodeUpdates ?? []),
+      ...(input.nodeInserts ?? []).map((value) => ({ value })),
+    ].some(({ value }) => !same(nodeRuns.get(value.nodeRunId), value))
+  ) {
+    conflict("EVENT_ID_CONFLICT");
+  }
+}
+
+export function releaseVersionKey(release: AgentWorkflowRelease) {
+  return `${release.definition.workflowKey}\u0000${release.definition.version}`;
+}
+
+export function sideEffectNodeKey(command: AgentWorkflowSideEffectCommand) {
+  return `${command.nodeRunId}\u0000${command.effectKind}\u0000${command.effectKey}`;
+}
+
+export function mutationResult(
+  record: AgentWorkflowRunRecord,
+  events: readonly AgentWorkflowEventEnvelope[],
+  replayed: boolean,
+): AgentWorkflowMutationResult {
+  return { record: clone(record), events: events.map(clone), replayed };
+}
+
+export function clone<T>(value: T): T {
+  return structuredClone(value);
+}
+
+export function cloneOptional<T>(value: T | undefined): T | undefined {
+  return value === undefined ? undefined : clone(value);
+}
+
+export function conflict(
+  code: ConstructorParameters<typeof AgentWorkflowRepositoryConflict>[0],
+): never {
+  throw new AgentWorkflowRepositoryConflict(code);
+}
+
+export function assertRunListLimit(limit: number) {
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200) {
+    throw new Error("Workflow Run list limit 无效");
+  }
+}
+
+export function assertRecoveryPolicies(
+  record: AgentWorkflowRunRecord,
+  input: import("./repository.js").AgentWorkflowRecoveryAdmissionInput,
+) {
+  const run = record.run;
+  if (
+    ["completed", "failed", "cancelled", "timed-out"].includes(run.status) ||
+    run.actorId !== input.actorId ||
+    run.scopeDigest !== input.scopeDigest ||
+    run.authorizationSnapshotDigest !== input.authorizationSnapshotDigest ||
+    run.toolPolicyDigest !== input.toolPolicyDigest ||
+    run.workspacePolicyDigest !== input.workspacePolicyDigest ||
+    run.executionPolicyDigest !== input.executionPolicyDigest
+  ) {
+    conflict("RECOVERY_ADMISSION_REJECTED");
+  }
+}
+
+export function runIdempotencyCoordinate(
+  run: AgentWorkflowRunRecord["run"],
+  callerKey: string,
+) {
+  return [
+    run.tenantId,
+    run.actorId,
+    run.releaseId,
+    run.routeKey,
+    run.inputDigest,
+    callerKey,
+  ].join("\u0000");
+}
+
+function validateNodeTerminalEvents(input: AgentWorkflowRunMutation) {
+  for (const { value } of input.nodeUpdates ?? []) {
+    if (
+      !isAgentWorkflowNodeTerminal(value.status) &&
+      value.status !== "retry-scheduled"
+    ) {
+      continue;
+    }
+    const eventType = `workflow.node-${value.status}`;
+    const event = input.events.find(
+      ({ data }) =>
+        "nodeRunId" in data &&
+        data.nodeRunId === value.nodeRunId &&
+        data.type === eventType,
+    );
+    if (!event || !("nodeRunId" in event.data)) conflict("EVENT_ID_CONFLICT");
+    if (value.status === "completed") {
+      const receipt = value.resultReceipt;
+      if (
+        !receipt ||
+        event.data.type !== "workflow.node-completed" ||
+        receipt.nodeRunId !== value.nodeRunId ||
+        event.data.receiptId !== receipt.receiptId ||
+        event.data.resultDigest !== receipt.resultDigest
+      ) {
+        conflict("EVENT_ID_CONFLICT");
+      }
+    }
+  }
+}
+
+function samePending(
+  event: AgentWorkflowEventEnvelope,
+  pending: PendingAgentWorkflowEvent,
+) {
+  const {
+    schemaVersion: _schema,
+    workflowRunId: _run,
+    sequence: _sequence,
+    ...value
+  } = event;
+  const { occurredAt: _existingAt, ...existing } = value;
+  const { occurredAt: _pendingAt, ...requested } = pending;
+  return same(existing, requested);
+}
+
+function same(left: unknown, right: unknown) {
+  return canonicalJson(left) === canonicalJson(right);
+}