create-windy 0.6.12 → 0.6.15

package/template/apps/server/src/agent-workflow/drizzle-repository-lineage.ts

@@ -0,0 +1,103 @@
+import {
+  agentWorkflowDelegations,
+  agentWorkflowEvents,
+  agentWorkflowNodeRuns,
+  agentWorkflowRuns,
+} from "@southwind-ai/database";
+import { eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { CreateAgentWorkflowRunInput } from "./repository.js";
+import { AgentWorkflowRepositoryConflict } from "./repository.js";
+import { canonicalJson } from "./canonical-json.js";
+
+export async function assertDrizzleRunLineage(
+  tx: Transaction,
+  input: CreateAgentWorkflowRunInput,
+) {
+  const data = input.event.data;
+  if (data.type !== "workflow.run-created") conflict();
+  if (
+    data.releaseId !== input.run.releaseId ||
+    canonicalJson(data.inputReceipt) !== canonicalJson(input.run.inputReceipt)
+  ) {
+    conflict();
+  }
+  const parentCoordinates = [
+    input.run.parentRunId,
+    input.run.parentNodeId,
+    input.run.parentNodeRunId,
+  ];
+  const hasParent = parentCoordinates.every(Boolean);
+  if (!hasParent) {
+    if (
+      parentCoordinates.some(Boolean) ||
+      input.event.parentEventId ||
+      data.parentRunId ||
+      data.parentNodeId ||
+      data.parentNodeRunId ||
+      data.delegationId
+    ) {
+      conflict();
+    }
+    return;
+  }
+  if (
+    data.parentRunId !== input.run.parentRunId ||
+    data.parentNodeId !== input.run.parentNodeId ||
+    data.parentNodeRunId !== input.run.parentNodeRunId ||
+    !data.delegationId ||
+    !input.event.parentEventId
+  ) {
+    conflict();
+  }
+  const [[parentRun], [parentNode], [parentEvent], [delegation]] =
+    await Promise.all([
+      tx
+        .select()
+        .from(agentWorkflowRuns)
+        .where(eq(agentWorkflowRuns.runId, input.run.parentRunId!))
+        .limit(1),
+      tx
+        .select()
+        .from(agentWorkflowNodeRuns)
+        .where(eq(agentWorkflowNodeRuns.nodeRunId, input.run.parentNodeRunId!))
+        .limit(1),
+      tx
+        .select()
+        .from(agentWorkflowEvents)
+        .where(eq(agentWorkflowEvents.eventId, input.event.parentEventId!))
+        .limit(1),
+      tx
+        .select()
+        .from(agentWorkflowDelegations)
+        .where(eq(agentWorkflowDelegations.delegationId, data.delegationId!))
+        .limit(1),
+    ]);
+  const parentData = parentEvent?.payloadJson;
+  if (
+    !parentRun ||
+    parentRun.tenantId !== input.run.tenantId ||
+    !parentNode ||
+    parentNode.runId !== parentRun.runId ||
+    parentNode.nodeId !== input.run.parentNodeId ||
+    !parentEvent ||
+    parentEvent.runId !== parentRun.runId ||
+    parentEvent.childWorkflowRunId !== input.run.runId ||
+    parentData?.type !== "workflow.delegation-child-linked" ||
+    parentData.delegationId !== data.delegationId ||
+    parentData.parentNodeId !== input.run.parentNodeId ||
+    parentData.parentNodeRunId !== input.run.parentNodeRunId ||
+    !delegation ||
+    delegation.parentRunId !== parentRun.runId ||
+    delegation.parentNodeId !== input.run.parentNodeId ||
+    delegation.parentNodeRunId !== input.run.parentNodeRunId
+  ) {
+    conflict();
+  }
+}
+
+function conflict(): never {
+  throw new AgentWorkflowRepositoryConflict("RUN_IDEMPOTENCY_CONFLICT");
+}
+
+type Transaction = Parameters<Parameters<NodePgDatabase["transaction"]>[0]>[0];

package/template/apps/server/src/agent-workflow/drizzle-repository-mappers.ts

@@ -0,0 +1,317 @@
+import {
+  agentWorkflowEvents,
+  agentWorkflowNodeRuns,
+  agentWorkflowReleases,
+  agentWorkflowRuns,
+  agentWorkflowSideEffectCommands,
+  agentWorkflowSideEffectReceipts,
+} from "@southwind-ai/database";
+import type {
+  AgentWorkflowEventEnvelope,
+  AgentWorkflowNodeRun,
+  AgentWorkflowRelease,
+  AgentWorkflowRun,
+  AgentWorkflowSideEffectCommand,
+  AgentWorkflowSideEffectReceipt,
+} from "@southwind-ai/shared";
+import { AGENT_WORKFLOW_EVENT_SCHEMA_VERSION } from "@southwind-ai/shared";
+import type { PendingAgentWorkflowEvent } from "./repository.js";
+
+type ReleaseRow = typeof agentWorkflowReleases.$inferSelect;
+type RunRow = typeof agentWorkflowRuns.$inferSelect;
+type NodeRunRow = typeof agentWorkflowNodeRuns.$inferSelect;
+type EventRow = typeof agentWorkflowEvents.$inferSelect;
+type SideEffectRow = typeof agentWorkflowSideEffectCommands.$inferSelect;
+type SideEffectReceiptRow = typeof agentWorkflowSideEffectReceipts.$inferSelect;
+
+export function toRelease(row: ReleaseRow): AgentWorkflowRelease {
+  return {
+    releaseId: row.releaseId,
+    releaseDigest: row.releaseDigest,
+    definitionId: row.definitionId,
+    definitionDigest: row.definitionDigest,
+    definition: row.releaseJson.definition,
+    coordinates: row.releaseJson.coordinates,
+    publishedBy: row.publishedBy,
+    publishedAt: iso(row.publishedAt),
+  };
+}
+
+export function releaseRows(release: AgentWorkflowRelease) {
+  return {
+    definition: {
+      definitionId: release.definitionId,
+      workflowKey: release.definition.workflowKey,
+      version: release.definition.version,
+      definitionDigest: release.definitionDigest,
+      definitionJson: release.definition,
+      createdBy: release.publishedBy,
+      createdAt: epoch(release.publishedAt),
+    },
+    release: {
+      releaseId: release.releaseId,
+      releaseDigest: release.releaseDigest,
+      definitionId: release.definitionId,
+      definitionDigest: release.definitionDigest,
+      releaseJson: {
+        definition: release.definition,
+        coordinates: release.coordinates,
+      },
+      publishedBy: release.publishedBy,
+      publishedAt: epoch(release.publishedAt),
+    },
+  };
+}
+
+export function toRun(row: RunRow): AgentWorkflowRun {
+  return {
+    runId: row.runId,
+    releaseId: row.releaseId,
+    tenantId: row.tenantId,
+    actorId: row.actorId,
+    routeKey: row.routeKey,
+    inputDigest: row.inputDigest,
+    inputReceipt: row.inputReceiptJson,
+    scopeDigest: row.scopeDigest,
+    authorizationSnapshotDigest: row.authorizationSnapshotDigest,
+    toolPolicyDigest: row.toolPolicyDigest,
+    workspacePolicyDigest: row.workspacePolicyDigest,
+    executionPolicyDigest: row.executionPolicyDigest,
+    status: row.status as AgentWorkflowRun["status"],
+    budget: row.budgetJson,
+    usage: row.usageJson,
+    deadlineAt: iso(row.deadlineAt),
+    ...(row.sessionId ? { sessionId: row.sessionId } : {}),
+    ...(row.parentRunId ? { parentRunId: row.parentRunId } : {}),
+    ...(row.parentNodeId ? { parentNodeId: row.parentNodeId } : {}),
+    ...(row.parentNodeRunId ? { parentNodeRunId: row.parentNodeRunId } : {}),
+    ...(row.cancellationRequestedAt
+      ? { cancellationRequestedAt: iso(row.cancellationRequestedAt) }
+      : {}),
+    createdAt: iso(row.createdAt),
+    updatedAt: iso(row.updatedAt),
+    ...(row.finishedAt ? { finishedAt: iso(row.finishedAt) } : {}),
+    version: row.version,
+    ...(row.safeErrorCode ? { safeErrorCode: row.safeErrorCode } : {}),
+  };
+}
+
+export function runRow(run: AgentWorkflowRun, idempotencyKey?: string) {
+  return {
+    runId: run.runId,
+    releaseId: run.releaseId,
+    ...(idempotencyKey ? { idempotencyKey } : {}),
+    tenantId: run.tenantId,
+    actorId: run.actorId,
+    routeKey: run.routeKey,
+    inputDigest: run.inputDigest,
+    inputReceiptJson: run.inputReceipt,
+    scopeDigest: run.scopeDigest,
+    authorizationSnapshotDigest: run.authorizationSnapshotDigest,
+    toolPolicyDigest: run.toolPolicyDigest,
+    workspacePolicyDigest: run.workspacePolicyDigest,
+    executionPolicyDigest: run.executionPolicyDigest,
+    sessionId: run.sessionId ?? null,
+    parentRunId: run.parentRunId ?? null,
+    parentNodeId: run.parentNodeId ?? null,
+    parentNodeRunId: run.parentNodeRunId ?? null,
+    status: run.status,
+    budgetJson: run.budget,
+    usageJson: run.usage,
+    deadlineAt: epoch(run.deadlineAt),
+    cancellationRequestedAt: optionalEpoch(run.cancellationRequestedAt),
+    safeErrorCode: run.safeErrorCode ?? null,
+    version: run.version,
+    createdAt: epoch(run.createdAt),
+    updatedAt: epoch(run.updatedAt),
+    finishedAt: optionalEpoch(run.finishedAt),
+  };
+}
+
+export function runCreateRow(run: AgentWorkflowRun, idempotencyKey: string) {
+  return { ...runRow(run), idempotencyKey };
+}
+
+export function toNodeRun(row: NodeRunRow): AgentWorkflowNodeRun {
+  return {
+    nodeRunId: row.nodeRunId,
+    runId: row.runId,
+    nodeId: row.nodeId,
+    ...(row.previousNodeRunId
+      ? { previousNodeRunId: row.previousNodeRunId }
+      : {}),
+    nodeType: row.nodeType as AgentWorkflowNodeRun["nodeType"],
+    status: row.status as AgentWorkflowNodeRun["status"],
+    attempt: row.attempt,
+    maxAttempts: row.maxAttempts,
+    idempotencyKey: row.idempotencyKey,
+    ...(row.adapterKind && row.adapterCoordinate
+      ? {
+          adapter: {
+            kind: row.adapterKind as NonNullable<
+              AgentWorkflowNodeRun["adapter"]
+            >["kind"],
+            coordinate: row.adapterCoordinate,
+          },
+        }
+      : {}),
+    inputArtifacts: row.inputArtifactsJson,
+    outputArtifacts: row.outputArtifactsJson,
+    ...(row.resultReceiptJson ? { resultReceipt: row.resultReceiptJson } : {}),
+    ...(row.safeErrorCode ? { safeErrorCode: row.safeErrorCode } : {}),
+    createdAt: iso(row.createdAt),
+    updatedAt: iso(row.updatedAt),
+    ...(row.startedAt ? { startedAt: iso(row.startedAt) } : {}),
+    ...(row.finishedAt ? { finishedAt: iso(row.finishedAt) } : {}),
+    version: row.version,
+  };
+}
+
+export function nodeRunRow(node: AgentWorkflowNodeRun) {
+  return {
+    nodeRunId: node.nodeRunId,
+    runId: node.runId,
+    nodeId: node.nodeId,
+    previousNodeRunId: node.previousNodeRunId ?? null,
+    nodeType: node.nodeType,
+    status: node.status,
+    attempt: node.attempt,
+    maxAttempts: node.maxAttempts,
+    idempotencyKey: node.idempotencyKey,
+    adapterKind: node.adapter?.kind ?? null,
+    adapterCoordinate: node.adapter?.coordinate ?? null,
+    inputArtifactsJson: node.inputArtifacts,
+    outputArtifactsJson: node.outputArtifacts,
+    resultReceiptJson: node.resultReceipt ?? null,
+    safeErrorCode: node.safeErrorCode ?? null,
+    createdAt: epoch(node.createdAt),
+    updatedAt: epoch(node.updatedAt),
+    startedAt: optionalEpoch(node.startedAt),
+    finishedAt: optionalEpoch(node.finishedAt),
+    version: node.version,
+  };
+}
+
+export function toEvent(row: EventRow): AgentWorkflowEventEnvelope {
+  return {
+    schemaVersion: AGENT_WORKFLOW_EVENT_SCHEMA_VERSION,
+    eventId: row.eventId,
+    workflowRunId: row.runId,
+    sequence: row.sequence,
+    occurredAt: iso(row.occurredAt),
+    ...(row.causationEventId ? { causationEventId: row.causationEventId } : {}),
+    ...(row.parentEventId ? { parentEventId: row.parentEventId } : {}),
+    ...(row.childWorkflowRunId
+      ? { childWorkflowRunId: row.childWorkflowRunId }
+      : {}),
+    data: row.payloadJson,
+  };
+}
+
+export function eventRow(
+  runId: string,
+  sequence: number,
+  event: PendingAgentWorkflowEvent,
+) {
+  return {
+    eventId: event.eventId,
+    runId,
+    sequence,
+    eventType: event.data.type,
+    parentEventId: event.parentEventId ?? null,
+    causationEventId: event.causationEventId ?? null,
+    childWorkflowRunId: event.childWorkflowRunId ?? null,
+    payloadJson: event.data,
+    occurredAt: epoch(event.occurredAt),
+  };
+}
+
+export function toSideEffect(
+  row: SideEffectRow,
+): AgentWorkflowSideEffectCommand {
+  return {
+    commandId: row.commandId,
+    runId: row.runId,
+    nodeRunId: row.nodeRunId,
+    effectKind: row.effectKind,
+    effectKey: row.effectKey,
+    adapter: {
+      kind: row.adapterKind as AgentWorkflowSideEffectCommand["adapter"]["kind"],
+      coordinate: row.adapterCoordinate,
+    },
+    idempotencyKey: row.idempotencyKey,
+    requestDigest: row.requestDigest,
+    generation: row.generation,
+    ...(row.fenceTokenDigest ? { fenceTokenDigest: row.fenceTokenDigest } : {}),
+    ...(row.authorizationSnapshotDigest
+      ? { authorizationSnapshotDigest: row.authorizationSnapshotDigest }
+      : {}),
+    ...(row.runPolicyDigest ? { runPolicyDigest: row.runPolicyDigest } : {}),
+    ...(row.budgetReservationId
+      ? { budgetReservationId: row.budgetReservationId }
+      : {}),
+    ...(row.delegationId ? { delegationId: row.delegationId } : {}),
+    status: row.status,
+    ...(row.safeErrorCode ? { safeErrorCode: row.safeErrorCode } : {}),
+    ...(row.claimedAt ? { claimedAt: iso(row.claimedAt) } : {}),
+    ...(row.committedAt ? { committedAt: iso(row.committedAt) } : {}),
+    version: row.version,
+    createdAt: iso(row.createdAt),
+    updatedAt: iso(row.updatedAt),
+  };
+}
+
+export function sideEffectRow(command: AgentWorkflowSideEffectCommand) {
+  const { adapter, ...value } = command;
+  return {
+    ...value,
+    adapterKind: adapter.kind,
+    adapterCoordinate: adapter.coordinate,
+    fenceTokenDigest: command.fenceTokenDigest ?? null,
+    authorizationSnapshotDigest: command.authorizationSnapshotDigest ?? null,
+    runPolicyDigest: command.runPolicyDigest ?? null,
+    budgetReservationId: command.budgetReservationId ?? null,
+    delegationId: command.delegationId ?? null,
+    safeErrorCode: command.safeErrorCode ?? null,
+    claimedAt: optionalEpoch(command.claimedAt),
+    committedAt: optionalEpoch(command.committedAt),
+    createdAt: epoch(command.createdAt),
+    updatedAt: epoch(command.updatedAt),
+  };
+}
+
+export function toSideEffectReceipt(
+  row: SideEffectReceiptRow,
+): AgentWorkflowSideEffectReceipt {
+  const { artifactRefsJson, smallResultJson, ...rest } = row;
+  return {
+    ...rest,
+    ...(smallResultJson === null ? {} : { smallResult: smallResultJson }),
+    ...(artifactRefsJson === null ? {} : { artifactRefs: artifactRefsJson }),
+    committedAt: iso(row.committedAt),
+  };
+}
+
+export function sideEffectReceiptRow(receipt: AgentWorkflowSideEffectReceipt) {
+  const { artifactRefs, smallResult, ...rest } = receipt;
+  return {
+    ...rest,
+    smallResultJson: smallResult ?? null,
+    artifactRefsJson: artifactRefs ?? null,
+    committedAt: epoch(receipt.committedAt),
+  };
+}
+
+function epoch(value: string) {
+  const result = Date.parse(value);
+  if (!Number.isFinite(result)) throw new Error("Workflow timestamp 无效");
+  return result;
+}
+
+function optionalEpoch(value: string | undefined) {
+  return value === undefined ? null : epoch(value);
+}
+
+function iso(value: number) {
+  return new Date(value).toISOString();
+}