create-windy 0.6.11 → 0.6.14

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

@@ -0,0 +1,339 @@
+import {
+  type AgentWorkflowEventEnvelope,
+  type AgentWorkflowNodeRun,
+  type AgentWorkflowRelease,
+  type AgentWorkflowSideEffectCommand,
+} from "@southwind-ai/shared";
+import { sameAgentWorkflowRelease } from "./release.js";
+import {
+  type AgentWorkflowEventReadInput,
+  type AgentWorkflowRepository,
+  type AgentWorkflowRecoveryAdmissionInput,
+  type AgentWorkflowMutationResult,
+  type AgentWorkflowRunMutation,
+  type AgentWorkflowRunRecord,
+  type CreateAgentWorkflowRunInput,
+} from "./repository.js";
+import { calculateRemainingBudget } from "./budget-validation.js";
+import { InMemorySideEffectStore } from "./in-memory-side-effect-store.js";
+import {
+  assertMutationReplay,
+  assertEventChronology,
+  assertRecoveryPolicies,
+  assertRunListLimit,
+  assertRunCreate,
+  clone,
+  cloneOptional,
+  conflict,
+  envelope,
+  mutationResult,
+  releaseVersionKey,
+  runIdempotencyCoordinate,
+  replayEvents,
+  sameRunCreate,
+  validateRunMutation,
+} from "./in-memory-repository-support.js";
+import {
+  assertInMemoryEventAppend,
+  assertInMemoryNodeChanges,
+  assertInMemoryRunLineage,
+} from "./in-memory-mutation-validation.js";
+
+/** Contract double only; production uses DrizzleAgentWorkflowRepository. */
+export class InMemoryAgentWorkflowRepository implements AgentWorkflowRepository {
+  readonly #releases = new Map<string, AgentWorkflowRelease>();
+  readonly #releaseVersions = new Map<string, string>();
+  readonly #releaseDigests = new Map<string, string>();
+  readonly #definitionDigests = new Map<string, string>();
+  readonly #runs = new Map<string, AgentWorkflowRunRecord>();
+  readonly #runIdempotency = new Map<string, string>();
+  readonly #nodeRuns = new Map<string, AgentWorkflowNodeRun>();
+  readonly #events = new Map<string, AgentWorkflowEventEnvelope[]>();
+  readonly #eventIds = new Map<string, AgentWorkflowEventEnvelope>();
+  readonly #sideEffects = new InMemorySideEffectStore((nodeRunId) =>
+    this.#nodeRuns.get(nodeRunId),
+  );
+
+  async publishRelease(release: AgentWorkflowRelease) {
+    const keys = [
+      this.#releases.get(release.releaseId),
+      this.#releaseById(this.#releaseVersions.get(releaseVersionKey(release))),
+      this.#releaseById(this.#releaseDigests.get(release.releaseDigest)),
+      this.#releaseById(
+        this.#definitionDigests.get(
+          `${release.definition.workflowKey}\u0000${release.definitionDigest}`,
+        ),
+      ),
+    ].filter((item): item is AgentWorkflowRelease => Boolean(item));
+    if (keys.length) {
+      const existing = keys[0]!;
+      if (
+        keys.every((item) => item.releaseId === existing.releaseId) &&
+        sameAgentWorkflowRelease(existing, release)
+      ) {
+        return { release: clone(existing), created: false };
+      }
+      conflict("RELEASE_IMMUTABLE_CONFLICT");
+    }
+    this.#releases.set(release.releaseId, clone(release));
+    this.#releaseVersions.set(releaseVersionKey(release), release.releaseId);
+    this.#releaseDigests.set(release.releaseDigest, release.releaseId);
+    this.#definitionDigests.set(
+      `${release.definition.workflowKey}\u0000${release.definitionDigest}`,
+      release.releaseId,
+    );
+    return { release: clone(release), created: true };
+  }
+
+  async getRelease(releaseId: string) {
+    return cloneOptional(this.#releases.get(releaseId));
+  }
+
+  async findRelease(workflowKey: string, version: string) {
+    return this.getRelease(
+      this.#releaseVersions.get(`${workflowKey}\u0000${version}`) ?? "",
+    );
+  }
+
+  async createRun(input: CreateAgentWorkflowRunInput) {
+    assertRunCreate(input, this.#releases.has(input.run.releaseId));
+    const idempotencyCoordinate = runIdempotencyCoordinate(
+      input.run,
+      input.idempotencyKey,
+    );
+    const existingId = this.#runIdempotency.get(idempotencyCoordinate);
+    if (existingId) {
+      const existing = this.#runs.get(existingId)!;
+      const existingNode = [...this.#nodeRuns.values()].find(
+        (node) =>
+          node.runId === existingId &&
+          node.nodeId === input.initialNodeRun.nodeId &&
+          node.attempt === 1,
+      );
+      const replay = this.#eventIds.get(input.event.eventId);
+      if (
+        existingNode &&
+        sameRunCreate(existing, existingNode, input) &&
+        replay?.workflowRunId === existingId
+      ) {
+        return mutationResult(existing, [replay], true);
+      }
+      conflict("RUN_IDEMPOTENCY_CONFLICT");
+    }
+    if (this.#runs.has(input.run.runId)) conflict("RUN_IDEMPOTENCY_CONFLICT");
+    this.assertNodeInsert(input.initialNodeRun);
+    assertInMemoryRunLineage({
+      create: input,
+      parentRun: input.run.parentRunId
+        ? this.#runs.get(input.run.parentRunId)
+        : undefined,
+      parentNode: input.run.parentNodeRunId
+        ? this.#nodeRuns.get(input.run.parentNodeRunId)
+        : undefined,
+      parentEvent: input.event.parentEventId
+        ? this.#eventIds.get(input.event.parentEventId)
+        : undefined,
+    });
+    const event = envelope(input.run.runId, 1, input.event);
+    await assertInMemoryEventAppend({
+      runId: input.run.runId,
+      firstSequence: 1,
+      existing: [],
+      events: [input.event],
+      eventIds: this.#eventIds,
+      envelopes: [event],
+    });
+    const record: AgentWorkflowRunRecord = {
+      run: clone(input.run),
+      idempotencyKey: input.idempotencyKey,
+      headSequence: 1,
+      recoveryCount: 0,
+    };
+    this.#runs.set(input.run.runId, record);
+    this.#runIdempotency.set(idempotencyCoordinate, input.run.runId);
+    this.#nodeRuns.set(
+      input.initialNodeRun.nodeRunId,
+      clone(input.initialNodeRun),
+    );
+    this.#events.set(input.run.runId, [event]);
+    this.#eventIds.set(event.eventId, event);
+    return mutationResult(record, [event], false);
+  }
+
+  async getRun(runId: string) {
+    return cloneOptional(this.#runs.get(runId));
+  }
+
+  async listRunsForActor(
+    tenantId: string,
+    actorId: string,
+    scopeDigest: string,
+    limit: number,
+  ) {
+    assertRunListLimit(limit);
+    return [...this.#runs.values()]
+      .filter(
+        ({ run }) =>
+          run.tenantId === tenantId &&
+          run.actorId === actorId &&
+          run.scopeDigest === scopeDigest,
+      )
+      .sort((left, right) =>
+        right.run.createdAt.localeCompare(left.run.createdAt),
+      )
+      .slice(0, limit)
+      .map(clone);
+  }
+
+  async getSnapshot(runId: string) {
+    const record = this.#runs.get(runId);
+    if (!record) return undefined;
+    return {
+      ...clone(record),
+      nodeRuns: await this.listNodeRuns(runId),
+      sideEffects: await this.listSideEffects(runId),
+    };
+  }
+
+  async getNodeRun(nodeRunId: string) {
+    return cloneOptional(this.#nodeRuns.get(nodeRunId));
+  }
+
+  async listNodeRuns(runId: string) {
+    return [...this.#nodeRuns.values()]
+      .filter((item) => item.runId === runId)
+      .sort(
+        (left, right) =>
+          left.nodeId.localeCompare(right.nodeId) ||
+          left.attempt - right.attempt,
+      )
+      .map(clone);
+  }
+
+  async readEvents(input: AgentWorkflowEventReadInput) {
+    if (
+      !Number.isSafeInteger(input.afterSequence) ||
+      input.afterSequence < 0 ||
+      !Number.isSafeInteger(input.limit) ||
+      input.limit < 1 ||
+      input.limit > 1_000
+    ) {
+      throw new Error("Workflow Event 读取范围无效");
+    }
+    return (this.#events.get(input.runId) ?? [])
+      .filter(({ sequence }) => sequence > input.afterSequence)
+      .slice(0, input.limit)
+      .map(clone);
+  }
+
+  async findEvent(eventId: string) {
+    return cloneOptional(this.#eventIds.get(eventId));
+  }
+
+  async commit(
+    input: AgentWorkflowRunMutation,
+  ): Promise<AgentWorkflowMutationResult> {
+    const record = this.#runs.get(input.runId);
+    if (!record) conflict("RUN_NOT_FOUND");
+    if (!input.events.length)
+      throw new Error("Workflow mutation 必须追加 Event");
+    const replay = replayEvents(input.runId, input.events, this.#eventIds);
+    if (replay) {
+      assertMutationReplay(record, input, this.#nodeRuns);
+      return mutationResult(record, replay, true);
+    }
+    if (record.headSequence !== input.expectedSequence)
+      conflict("SEQUENCE_CONFLICT");
+    assertEventChronology(
+      this.#events.get(input.runId)?.at(-1)?.occurredAt,
+      input.events,
+    );
+    validateRunMutation(record, input);
+    const appended = input.events.map((event, index) =>
+      envelope(input.runId, record.headSequence + index + 1, event),
+    );
+    await assertInMemoryEventAppend({
+      runId: input.runId,
+      firstSequence: record.headSequence + 1,
+      existing: this.#events.get(input.runId) ?? [],
+      events: input.events,
+      eventIds: this.#eventIds,
+      envelopes: appended,
+    });
+    assertInMemoryNodeChanges(this.#nodeRuns, input, record.run);
+    const updated: AgentWorkflowRunRecord = {
+      run: clone(input.runUpdate?.value ?? record.run),
+      idempotencyKey: record.idempotencyKey,
+      headSequence: record.headSequence + appended.length,
+      recoveryCount: input.recovery?.nextCount ?? record.recoveryCount,
+    };
+    for (const update of input.nodeUpdates ?? []) {
+      this.#nodeRuns.set(update.value.nodeRunId, clone(update.value));
+    }
+    for (const nodeRun of input.nodeInserts ?? []) {
+      this.#nodeRuns.set(nodeRun.nodeRunId, clone(nodeRun));
+    }
+    this.#runs.set(input.runId, updated);
+    this.#events.get(input.runId)!.push(...appended);
+    for (const event of appended) this.#eventIds.set(event.eventId, event);
+    return mutationResult(updated, appended, false);
+  }
+
+  async admitRecovery(input: AgentWorkflowRecoveryAdmissionInput) {
+    const record = this.#runs.get(input.runId);
+    if (!record) conflict("RUN_NOT_FOUND");
+    assertRecoveryPolicies(record, input);
+    const remainingBudget = calculateRemainingBudget({
+      budget: record.run.budget,
+      consumed: record.run.usage,
+      activeReservations: [],
+    });
+    const result = await this.commit({
+      runId: input.runId,
+      expectedSequence: input.expectedSequence,
+      recovery: {
+        expectedCount: input.expectedRecoveryCount,
+        nextCount: input.expectedRecoveryCount + 1,
+      },
+      events: [input.event],
+    });
+    return { ...result, remainingBudget };
+  }
+
+  async prepareSideEffect(command: AgentWorkflowSideEffectCommand) {
+    return this.#sideEffects.prepare(command);
+  }
+
+  async getSideEffect(commandId: string) {
+    return this.#sideEffects.get(commandId);
+  }
+
+  async listSideEffects(runId: string) {
+    return this.#sideEffects.list(runId);
+  }
+
+  async updateSideEffect(
+    command: AgentWorkflowSideEffectCommand,
+    expectedVersion: number,
+  ) {
+    return this.#sideEffects.update(command, expectedVersion);
+  }
+
+  #releaseById(id: string | undefined) {
+    return id ? this.#releases.get(id) : undefined;
+  }
+
+  assertNodeInsert(nodeRun: AgentWorkflowNodeRun) {
+    if (
+      this.#nodeRuns.has(nodeRun.nodeRunId) ||
+      [...this.#nodeRuns.values()].some(
+        (item) =>
+          item.runId === nodeRun.runId &&
+          item.nodeId === nodeRun.nodeId &&
+          item.attempt === nodeRun.attempt,
+      )
+    ) {
+      conflict("NODE_RUN_CONFLICT");
+    }
+  }
+}

package/template/apps/server/src/agent-workflow/in-memory-side-effect-store.ts

@@ -0,0 +1,78 @@
+import type {
+  AgentWorkflowNodeRun,
+  AgentWorkflowSideEffectCommand,
+} from "@southwind-ai/shared";
+import {
+  clone,
+  cloneOptional,
+  conflict,
+  sideEffectNodeKey,
+} from "./in-memory-repository-support.js";
+import { samePreparedSideEffect } from "./side-effect-state.js";
+
+/** Side-effect portion of the in-memory repository contract double. */
+export class InMemorySideEffectStore {
+  readonly #commands = new Map<string, AgentWorkflowSideEffectCommand>();
+  readonly #idempotency = new Map<string, string>();
+  readonly #nodeKeys = new Map<string, string>();
+
+  constructor(
+    private readonly getNode: (
+      nodeRunId: string,
+    ) => AgentWorkflowNodeRun | undefined,
+  ) {}
+
+  prepare(command: AgentWorkflowSideEffectCommand) {
+    const existingId =
+      this.#idempotency.get(command.idempotencyKey) ??
+      this.#nodeKeys.get(sideEffectNodeKey(command));
+    if (existingId) {
+      const existing = this.#commands.get(existingId)!;
+      if (samePreparedSideEffect(existing, command)) {
+        return { command: clone(existing), created: false };
+      }
+      conflict("SIDE_EFFECT_CONFLICT");
+    }
+    if (this.#commands.has(command.commandId)) {
+      conflict("SIDE_EFFECT_CONFLICT");
+    }
+    const node = this.getNode(command.nodeRunId);
+    if (
+      !node ||
+      node.runId !== command.runId ||
+      command.status !== "prepared" ||
+      command.version !== 1
+    ) {
+      conflict("SIDE_EFFECT_CONFLICT");
+    }
+    this.#commands.set(command.commandId, clone(command));
+    this.#idempotency.set(command.idempotencyKey, command.commandId);
+    this.#nodeKeys.set(sideEffectNodeKey(command), command.commandId);
+    return { command: clone(command), created: true };
+  }
+
+  get(commandId: string) {
+    return cloneOptional(this.#commands.get(commandId));
+  }
+
+  list(runId: string) {
+    return [...this.#commands.values()]
+      .filter((item) => item.runId === runId)
+      .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+      .map(clone);
+  }
+
+  update(command: AgentWorkflowSideEffectCommand, expectedVersion: number) {
+    const existing = this.#commands.get(command.commandId);
+    if (!existing) conflict("SIDE_EFFECT_CONFLICT");
+    if (
+      existing.version !== expectedVersion ||
+      command.version !== expectedVersion + 1 ||
+      !samePreparedSideEffect(existing, command)
+    ) {
+      conflict("VERSION_CONFLICT");
+    }
+    this.#commands.set(command.commandId, clone(command));
+    return clone(command);
+  }
+}

package/template/apps/server/src/agent-workflow/input-receipt.ts

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import type {
+  AgentWorkflowInputReceipt,
+  AgentWorkflowNode,
+  JsonValue,
+} from "@southwind-ai/shared";
+import { canonicalJson } from "./canonical-json.js";
+import { assertCanonicalWorkflowSafeValue } from "./event-validation.js";
+
+const MAX_INPUT_BYTES = 16 * 1024;
+
+export function buildAgentWorkflowInputReceipt(input: {
+  readonly entry: AgentWorkflowNode;
+  readonly value: JsonValue;
+  readonly at: string;
+}): AgentWorkflowInputReceipt {
+  if (!input.entry.inputSchemaKey) {
+    throw new Error("Workflow entry Node 缺少 inputSchemaKey");
+  }
+  assertCanonicalWorkflowSafeValue(
+    input.value,
+    "workflowInput",
+    MAX_INPUT_BYTES,
+  );
+  return {
+    schemaKey: input.entry.inputSchemaKey,
+    value: structuredClone(input.value),
+    valueDigest: digest(input.value),
+    recordedAt: input.at,
+  };
+}
+
+export function assertAgentWorkflowInputReceipt(
+  receipt: AgentWorkflowInputReceipt,
+  expectedDigest: string,
+) {
+  assertCanonicalWorkflowSafeValue(
+    receipt.value,
+    "workflowInput",
+    MAX_INPUT_BYTES,
+  );
+  if (
+    !receipt.schemaKey.trim() ||
+    receipt.schemaKey.length > 200 ||
+    !Number.isFinite(Date.parse(receipt.recordedAt)) ||
+    receipt.valueDigest !== expectedDigest ||
+    receipt.valueDigest !== digest(receipt.value)
+  ) {
+    throw new Error("Workflow Input Receipt 坐标或 digest 无效");
+  }
+}
+
+function digest(value: JsonValue) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}

package/template/apps/server/src/agent-workflow/model-node-adapter.ts

@@ -0,0 +1,86 @@
+import type { RequestGuardContext } from "../guards.js";
+import type { AgentWorkflowNodeAdapter } from "./adapter-dispatch.js";
+import type {
+  AgentWorkflowModelExecutionPort,
+  AgentWorkflowNodeInputPort,
+} from "./node-execution-ports.js";
+import { AgentWorkflowModelExecutionError } from "./node-execution-ports.js";
+import {
+  directPlatformResult,
+  failedPlatformResult,
+} from "./platform-node-adapter-support.js";
+import { scheduledNodeDeadlineAt } from "./scheduler-deadline.js";
+
+export function modelNodeAdapter(input: {
+  readonly context: RequestGuardContext;
+  readonly inputs: AgentWorkflowNodeInputPort;
+  readonly agentRuns: AgentWorkflowModelExecutionPort;
+}): AgentWorkflowNodeAdapter {
+  return {
+    nodeType: "model",
+    async prepare(nodeContext) {
+      const node = nodeContext.node;
+      if (node.type !== "model") {
+        return failedPlatformResult("NODE_TYPE_MISMATCH");
+      }
+      const value = await input.inputs.readJson({
+        context: nodeContext,
+        schemaKey: node.inputSchemaKey,
+      });
+      let execution;
+      try {
+        execution = await input.agentRuns.execute({
+          operationKey: node.operationKey,
+          promptKey: node.promptKey,
+          value,
+          idempotencyKey: nodeContext.nodeRun.idempotencyKey,
+          context: input.context,
+          sessionId: nodeContext.run.sessionId,
+          deadlineAt: scheduledNodeDeadlineAt({
+            run: nodeContext.run,
+            node,
+            nodeRun: nodeContext.nodeRun,
+          }),
+          currentUsage: nodeContext.run.usage,
+          budget: nodeContext.run.budget,
+          signal: nodeContext.signal,
+        });
+      } catch (error) {
+        if (nodeContext.signal.aborted) throw error;
+        return error instanceof AgentWorkflowModelExecutionError
+          ? failedPlatformResult(error.safeCode, error.cumulativeUsage)
+          : failedPlatformResult("MODEL_EXECUTION_FAILED");
+      }
+      if (
+        execution.cumulativeUsage.inputTokens.status !== "measured" ||
+        execution.cumulativeUsage.outputTokens.status !== "measured" ||
+        execution.cumulativeUsage.cost.status !== "measured"
+      ) {
+        return failedPlatformResult(
+          "MODEL_USAGE_UNMEASURED",
+          execution.cumulativeUsage,
+        );
+      }
+      return directPlatformResult({
+        context: nodeContext,
+        result: execution.result,
+        resultDigest: execution.resultDigest,
+        cumulativeUsage: execution.cumulativeUsage,
+        executionEvidence: execution.executionEvidence,
+      });
+    },
+    async cancel({ context: nodeContext }) {
+      return input.agentRuns.cancelByIdempotencyKey({
+        operationKey:
+          nodeContext.node.type === "model"
+            ? nodeContext.node.operationKey
+            : "invalid",
+        idempotencyKey: nodeContext.nodeRun.idempotencyKey,
+        context: input.context,
+        sessionId: nodeContext.run.sessionId,
+        currentUsage: nodeContext.run.usage,
+        signal: nodeContext.signal,
+      });
+    },
+  };
+}