create-windy 0.6.11 → 0.6.14

package/template/apps/server/src/agent-workflow/scheduler-workflow-cancellation.ts

@@ -0,0 +1,296 @@
+import type { AgentWorkflowNodeAdapterRegistry } from "./adapter-dispatch.js";
+import type { WorkflowEffectCommandFencePort } from "./effect-command-fence.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+import { schedulerAdapterContext } from "./scheduler-context.js";
+import {
+  cancelPreparedEffect,
+  reconcileEffectDuringCancellation,
+} from "./scheduler-cancellation-reconcile.js";
+import {
+  cancellationTerminalAt,
+  monotonicCancellationAt,
+  releaseCancelledReservation,
+  releaseActiveNodeReservations,
+  requireCancellationSnapshot,
+  terminalizeCancelledNode,
+} from "./scheduler-cancellation-support.js";
+import type { AgentWorkflowService } from "./service.js";
+import { transitionAgentWorkflowSideEffect } from "./side-effect-state.js";
+import { convergeFailedReservation } from "./scheduler-reservation-convergence.js";
+
+export async function cancelScheduledWorkflow(input: {
+  readonly repository: AgentWorkflowRepository;
+  readonly service: AgentWorkflowService;
+  readonly effectFence: WorkflowEffectCommandFencePort;
+  readonly adapters: AgentWorkflowNodeAdapterRegistry;
+  readonly runId: string;
+  readonly reasonCode: string;
+  readonly at: string;
+  readonly signal: AbortSignal;
+  readonly terminalCommand?: "cancel" | "timeout";
+}) {
+  let snapshot = await requireCancellationSnapshot(
+    input.repository,
+    input.runId,
+  );
+  if (!snapshot.run.cancellationRequestedAt) {
+    await input.service.transitionRun({
+      runId: input.runId,
+      expectedVersion: snapshot.run.version,
+      expectedSequence: snapshot.headSequence,
+      command: { type: "request-cancel", reasonCode: input.reasonCode },
+      idempotencyKey: `scheduler:cancel-request:${input.runId}`,
+      at: input.at,
+    });
+    snapshot = await requireCancellationSnapshot(input.repository, input.runId);
+  }
+  const release = await input.repository.getRelease(snapshot.run.releaseId);
+  if (!release) throw new Error("Workflow Release 不存在");
+  const unresolved: string[] = [];
+  for (const initial of snapshot.nodeRuns.filter(
+    ({ status }) =>
+      !["completed", "failed", "cancelled", "skipped", "timed-out"].includes(
+        status,
+      ),
+  )) {
+    snapshot = await requireCancellationSnapshot(input.repository, input.runId);
+    const nodeRun = snapshot.nodeRuns.find(
+      ({ nodeRunId }) => nodeRunId === initial.nodeRunId,
+    );
+    if (!nodeRun || isTerminal(nodeRun.status)) continue;
+    const node = release.definition.nodes.find(
+      ({ id }) => id === nodeRun.nodeId,
+    )!;
+    const command = snapshot.sideEffects.find(
+      ({ nodeRunId }) => nodeRunId === nodeRun.nodeRunId,
+    );
+    if (!command) {
+      const cancellation = await cancelAdapterWithoutEffect(
+        input,
+        snapshot,
+        release,
+        nodeRun,
+        node,
+      );
+      const released = await releaseActiveNodeReservations({
+        service: input.service,
+        runId: input.runId,
+        nodeRunId: nodeRun.nodeRunId,
+        at: input.at,
+        reasonCode: "DELEGATION_CANCELLED",
+      });
+      if (!cancellation.cancelled || !released)
+        unresolved.push(nodeRun.nodeRunId);
+      else
+        await terminalize(
+          input,
+          nodeRun.nodeRunId,
+          cancellation.cumulativeUsage,
+        );
+      continue;
+    }
+    if (command.status === "prepared") {
+      await cancelPreparedEffect({
+        repository: input.repository,
+        command,
+        at: input.at,
+      });
+      if (!(await releaseReservation(input, command))) {
+        unresolved.push(nodeRun.nodeRunId);
+      } else {
+        await terminalize(input, nodeRun.nodeRunId);
+      }
+      continue;
+    }
+    const reconciliation = await reconcileEffectDuringCancellation({
+      repository: input.repository,
+      service: input.service,
+      effectFence: input.effectFence,
+      adapters: input.adapters,
+      snapshot,
+      nodeRunId: nodeRun.nodeRunId,
+      at: input.at,
+      signal: input.signal,
+    });
+    if (reconciliation.outcome === "completed") continue;
+    snapshot = await requireCancellationSnapshot(input.repository, input.runId);
+    const latestCommand = snapshot.sideEffects.find(
+      (item) => item.commandId === command.commandId,
+    );
+    if (!latestCommand) {
+      unresolved.push(nodeRun.nodeRunId);
+      continue;
+    }
+    if (["committed", "reconciled"].includes(latestCommand.status)) {
+      if (!(await releaseReservation(input, latestCommand))) {
+        unresolved.push(nodeRun.nodeRunId);
+      } else {
+        await terminalize(input, nodeRun.nodeRunId);
+      }
+      continue;
+    }
+    let cancellable = latestCommand;
+    if (latestCommand.status === "dispatched") {
+      cancellable = await input.repository.updateSideEffect(
+        transitionAgentWorkflowSideEffect({
+          command: latestCommand,
+          expectedVersion: latestCommand.version,
+          transition: { type: "request-cancel" },
+          at: monotonicCancellationAt(input.at, latestCommand.updatedAt),
+        }),
+        latestCommand.version,
+      );
+    }
+    let cancellation:
+      | Awaited<
+          ReturnType<
+            NonNullable<ReturnType<typeof input.adapters.require>["cancel"]>
+          >
+        >
+      | undefined;
+    try {
+      cancellation = await input.adapters.require(node.type).cancel?.({
+        context: schedulerAdapterContext({
+          snapshot,
+          release,
+          nodeRun,
+          node,
+          signal: input.signal,
+        }),
+        command: cancellable,
+      });
+    } catch {
+      cancellation = undefined;
+    }
+    if (!cancellation?.cancelled) {
+      unresolved.push(nodeRun.nodeRunId);
+      continue;
+    }
+    if (cancellable.budgetReservationId) {
+      if (!cancellation.cumulativeUsage) {
+        unresolved.push(nodeRun.nodeRunId);
+        continue;
+      }
+      const convergence = await convergeFailedReservation({
+        service: input.service,
+        command: cancellable,
+        cumulativeUsage: cancellation.cumulativeUsage,
+        safeCode: cancellation.safeCode ?? "DELEGATION_CANCELLED",
+        at: input.at,
+      });
+      if (!convergence.settled) {
+        unresolved.push(nodeRun.nodeRunId);
+        continue;
+      }
+    }
+    if (cancellable.status === "cancellation-requested") {
+      await input.repository.updateSideEffect(
+        transitionAgentWorkflowSideEffect({
+          command: cancellable,
+          expectedVersion: cancellable.version,
+          transition: { type: "cancel" },
+          at: monotonicCancellationAt(input.at, cancellable.updatedAt),
+        }),
+        cancellable.version,
+      );
+    }
+    if (!(await releaseReservation(input, cancellable))) {
+      unresolved.push(nodeRun.nodeRunId);
+    } else {
+      await terminalize(
+        input,
+        nodeRun.nodeRunId,
+        cancellable.budgetReservationId
+          ? undefined
+          : cancellation.cumulativeUsage,
+      );
+    }
+  }
+  if (unresolved.length) {
+    return { outcome: "cancellation-pending" as const, unresolved };
+  }
+  snapshot = await requireCancellationSnapshot(input.repository, input.runId);
+  const activeReservations =
+    (await input.service.readBudget(input.runId))?.activeReservations ?? [];
+  const activeNodes = snapshot.nodeRuns.filter(
+    ({ status }) => !isTerminal(status),
+  );
+  if (activeReservations.length || activeNodes.length) {
+    return {
+      outcome: "cancellation-pending" as const,
+      unresolved: [
+        ...activeNodes.map(({ nodeRunId }) => nodeRunId),
+        ...activeReservations.map(({ parentNodeRunId }) => parentNodeRunId),
+      ],
+    };
+  }
+  return input.service.transitionRun({
+    runId: input.runId,
+    expectedVersion: snapshot.run.version,
+    expectedSequence: snapshot.headSequence,
+    command: { type: input.terminalCommand ?? "cancel" },
+    idempotencyKey: `scheduler:${input.terminalCommand ?? "cancel"}:${input.runId}`,
+    at: cancellationTerminalAt(snapshot, input.at),
+  });
+}
+
+async function cancelAdapterWithoutEffect(
+  input: Parameters<typeof cancelScheduledWorkflow>[0],
+  snapshot: Awaited<ReturnType<typeof requireCancellationSnapshot>>,
+  release: NonNullable<
+    Awaited<ReturnType<AgentWorkflowRepository["getRelease"]>>
+  >,
+  nodeRun: (typeof snapshot.nodeRuns)[number],
+  node: (typeof release.definition.nodes)[number],
+) {
+  const adapter = input.adapters.require(node.type);
+  if (!adapter.cancel) return { cancelled: true };
+  try {
+    return await adapter.cancel({
+      context: schedulerAdapterContext({
+        snapshot,
+        release,
+        nodeRun,
+        node,
+        signal: input.signal,
+      }),
+    });
+  } catch {
+    return { cancelled: false };
+  }
+}
+
+function terminalize(
+  input: Parameters<typeof cancelScheduledWorkflow>[0],
+  nodeRunId: string,
+  cumulativeUsage?: import("@southwind-ai/shared").AgentWorkflowUsage,
+) {
+  const terminalCommand = input.terminalCommand ?? "cancel";
+  return terminalizeCancelledNode({
+    repository: input.repository,
+    service: input.service,
+    runId: input.runId,
+    nodeRunId,
+    terminalCommand,
+    idempotencyKey: `scheduler:${terminalCommand}:${nodeRunId}`,
+    at: input.at,
+    cumulativeUsage,
+  });
+}
+
+function releaseReservation(
+  input: Parameters<typeof cancelScheduledWorkflow>[0],
+  command: Parameters<typeof releaseCancelledReservation>[0]["command"],
+) {
+  return releaseCancelledReservation({
+    service: input.service,
+    command,
+    at: input.at,
+  });
+}
+
+function isTerminal(status: string) {
+  return ["completed", "failed", "cancelled", "skipped", "timed-out"].includes(
+    status,
+  );
+}

package/template/apps/server/src/agent-workflow/scheduler.ts

@@ -0,0 +1,289 @@
+import type {
+  AgentWorkflowNode,
+  AgentWorkflowNodeRun,
+} from "@southwind-ai/shared";
+import type { WorkflowAuthorizationFence } from "./budget-validation.js";
+import type { WorkflowEffectCommandFencePort } from "./effect-command-fence.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+import type { AgentWorkflowService } from "./service.js";
+import { adapterKind, schedulableSuccessors } from "./scheduler-support.js";
+import { AgentWorkflowNodeAdapterRegistry } from "./adapter-dispatch.js";
+import {
+  maxAttempts,
+  nodeEventData,
+  workflowEvent,
+  workflowId,
+} from "./service-support.js";
+import {
+  cancelJoinAnyLosers,
+  cancelScheduledWorkflow,
+} from "./scheduler-cancellation.js";
+import { dispatchReadyNodeBatch } from "./scheduler-parallel-dispatch.js";
+import { SchedulerMutationQueue } from "./scheduler-mutation-queue.js";
+import {
+  expireScheduledNode,
+  firstOverdueNode,
+} from "./scheduler-node-timeout.js";
+import { successorInputArtifacts } from "./scheduler-context.js";
+import { activatePendingWorkflowNode } from "./scheduler-recovery-activation.js";
+import {
+  recoverAgentWorkflow,
+  type RecoverAgentWorkflowInput,
+} from "./service-recovery.js";
+
+type Snapshot = NonNullable<
+  Awaited<ReturnType<AgentWorkflowRepository["getSnapshot"]>>
+>;
+
+export class AgentWorkflowScheduler {
+  private readonly mutationQueue = new SchedulerMutationQueue();
+
+  constructor(
+    private readonly repository: AgentWorkflowRepository,
+    private readonly service: AgentWorkflowService,
+    private readonly effectFence: WorkflowEffectCommandFencePort,
+    private readonly adapters: AgentWorkflowNodeAdapterRegistry,
+  ) {}
+
+  async advance(input: {
+    readonly runId: string;
+    readonly authorizationFence: WorkflowAuthorizationFence;
+    readonly at: string;
+    readonly signal: AbortSignal;
+  }) {
+    const snapshot = await this.requireSnapshot(input.runId);
+    const deadlineExceeded =
+      Date.parse(input.at) >= Date.parse(snapshot.run.deadlineAt);
+    if (deadlineExceeded || snapshot.run.cancellationRequestedAt) {
+      return cancelScheduledWorkflow({
+        repository: this.repository,
+        service: this.service,
+        effectFence: this.effectFence,
+        adapters: this.adapters,
+        runId: input.runId,
+        reasonCode: deadlineExceeded
+          ? "WORKFLOW_DEADLINE_EXCEEDED"
+          : "CANCELLATION_REQUESTED",
+        terminalCommand: deadlineExceeded ? "timeout" : "cancel",
+        at: input.at,
+        signal: input.signal,
+      });
+    }
+    if (snapshot.run.status === "accepted") {
+      return this.service.transitionRun({
+        runId: input.runId,
+        expectedVersion: snapshot.run.version,
+        expectedSequence: snapshot.headSequence,
+        command: { type: "start" },
+        idempotencyKey: `scheduler:start-run:${input.runId}`,
+        at: input.at,
+      });
+    }
+    const release = await this.requireRelease(snapshot.run.releaseId);
+    if (snapshot.nodeRuns.some(({ status }) => status === "timed-out")) {
+      return cancelScheduledWorkflow({
+        repository: this.repository,
+        service: this.service,
+        effectFence: this.effectFence,
+        adapters: this.adapters,
+        runId: input.runId,
+        reasonCode: "NODE_DEADLINE_EXCEEDED",
+        terminalCommand: "timeout",
+        at: input.at,
+        signal: input.signal,
+      });
+    }
+    const overdue = firstOverdueNode({ release, snapshot, at: input.at });
+    if (overdue) {
+      return expireScheduledNode(this.executionDependencies(), {
+        ...input,
+        release,
+        nodeRun: overdue,
+      });
+    }
+    const activated = await activatePendingWorkflowNode({
+      snapshot,
+      release,
+      service: this.service,
+      at: input.at,
+    });
+    if (activated) return activated;
+    const completed = [...snapshot.nodeRuns]
+      .filter(({ status }) => status === "completed" || status === "skipped")
+      .sort((left, right) =>
+        (left.finishedAt ?? "").localeCompare(right.finishedAt ?? ""),
+      );
+    for (const source of completed) {
+      const next = schedulableSuccessors({
+        definition: release.definition,
+        completed: source,
+        nodeRuns: snapshot.nodeRuns,
+      });
+      if (next.length)
+        return this.insertReady(snapshot, next, source, input.at);
+    }
+    const ready = snapshot.nodeRuns.filter(({ status }) => status === "ready");
+    if (ready.length) {
+      for (const candidate of ready) {
+        const node = release.definition.nodes.find(
+          ({ id }) => id === candidate.nodeId,
+        )!;
+        if (node.type !== "join" || node.strategy !== "any") continue;
+        const losers = await cancelJoinAnyLosers({
+          repository: this.repository,
+          service: this.service,
+          effectFence: this.effectFence,
+          adapters: this.adapters,
+          join: node,
+          runId: input.runId,
+          at: input.at,
+          signal: input.signal,
+        });
+        if (losers.outcome === "cancellation-pending") return losers;
+      }
+      const current = await this.requireSnapshot(input.runId);
+      return dispatchReadyNodeBatch(this.executionDependencies(), {
+        ...input,
+        release,
+        ready: current.nodeRuns.filter(({ status }) => status === "ready"),
+        maxParallelism: current.run.budget.maxParallelism,
+      });
+    }
+    const final = completed.find((nodeRun) =>
+      release.definition.nodes.some(
+        ({ id, type }) => id === nodeRun.nodeId && type === "final",
+      ),
+    );
+    const completionBlocked = Boolean(
+      final && !(await this.service.completionReadiness(input.runId)),
+    );
+    if (final && !completionBlocked) {
+      return this.service.transitionRun({
+        runId: input.runId,
+        expectedVersion: snapshot.run.version,
+        expectedSequence: snapshot.headSequence,
+        command: { type: "complete" },
+        idempotencyKey: `scheduler:complete-run:${input.runId}`,
+        at: input.at,
+      });
+    }
+    if (completionBlocked) return { outcome: "completion-blocked" as const };
+    return { outcome: "idle" as const };
+  }
+
+  async cancel(input: {
+    readonly runId: string;
+    readonly reasonCode: string;
+    readonly at: string;
+    readonly signal: AbortSignal;
+  }) {
+    return cancelScheduledWorkflow({
+      repository: this.repository,
+      service: this.service,
+      effectFence: this.effectFence,
+      adapters: this.adapters,
+      ...input,
+    });
+  }
+
+  async recover(input: RecoverAgentWorkflowInput) {
+    const recovered = await recoverAgentWorkflow({
+      dependencies: this.executionDependencies(),
+      request: input,
+    });
+    if (recovered.outcome !== "completed") return recovered;
+    const advanced = await this.advance(input);
+    return { ...recovered, advanced };
+  }
+
+  private async insertReady(
+    snapshot: Snapshot,
+    nodes: readonly AgentWorkflowNode[],
+    source: AgentWorkflowNodeRun,
+    at: string,
+  ) {
+    const release = await this.requireRelease(snapshot.run.releaseId);
+    const inserted = nodes.map((node) => ({
+      nodeRunId: workflowId(
+        "workflow_node_run",
+        snapshot.run.runId,
+        node.id,
+        "1",
+      ),
+      runId: snapshot.run.runId,
+      nodeId: node.id,
+      nodeType: node.type,
+      status: "ready" as const,
+      attempt: 1,
+      maxAttempts: maxAttempts(node),
+      idempotencyKey: workflowId(
+        "workflow_node_attempt",
+        snapshot.run.runId,
+        node.id,
+        "1",
+      ),
+      adapter: {
+        kind: adapterKind(node),
+        coordinate: workflowId(
+          "workflow_adapter",
+          snapshot.run.runId,
+          node.id,
+          "1",
+        ),
+      },
+      inputArtifacts: successorInputArtifacts({
+        snapshot,
+        release,
+        node,
+        source,
+      }),
+      outputArtifacts: [],
+      createdAt: at,
+      updatedAt: at,
+      version: 1,
+    }));
+    return this.repository.commit({
+      runId: snapshot.run.runId,
+      expectedSequence: snapshot.headSequence,
+      nodeInserts: inserted,
+      events: inserted.map((nodeRun) =>
+        workflowEvent({
+          runId: snapshot.run.runId,
+          idempotencyKey: `scheduler:ready:${nodeRun.nodeRunId}`,
+          at,
+          data: nodeEventData(nodeRun, { type: "ready" }),
+        }),
+      ),
+    });
+  }
+
+  private executionDependencies() {
+    return {
+      repository: this.repository,
+      service: this.service,
+      effectFence: this.effectFence,
+      adapters: this.adapters,
+      requireSnapshot: (runId: string) => this.requireSnapshot(runId),
+      requireRelease: (releaseId: string) => this.requireRelease(releaseId),
+      insertReady: (
+        snapshot: Snapshot,
+        nodes: readonly AgentWorkflowNode[],
+        source: AgentWorkflowNodeRun,
+        at: string,
+      ) => this.insertReady(snapshot, nodes, source, at),
+      serializeMutation: <T>(mutation: () => Promise<T>) =>
+        this.mutationQueue.run(mutation),
+    };
+  }
+
+  private async requireSnapshot(runId: string) {
+    const value = await this.repository.getSnapshot(runId);
+    if (!value) throw new Error("Workflow Run 不存在");
+    return value;
+  }
+  private async requireRelease(releaseId: string) {
+    const value = await this.repository.getRelease(releaseId);
+    if (!value) throw new Error("Workflow Release 不存在");
+    return value;
+  }
+}

package/template/apps/server/src/agent-workflow/service-completion.ts

@@ -0,0 +1,102 @@
+import type {
+  AgentWorkflowDefinition,
+  AgentWorkflowNodeResultReceipt,
+  AgentWorkflowRun,
+} from "@southwind-ai/shared";
+import { isAgentWorkflowNodeTerminal } from "@southwind-ai/shared";
+import type { WorkflowBudgetLedgerPort } from "./budget-ledger.js";
+import type { WorkflowEffectCommandFencePort } from "./effect-command-fence.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+
+export async function assertWorkflowNodeCompletion(input: {
+  readonly repository: AgentWorkflowRepository;
+  readonly effectFence: WorkflowEffectCommandFencePort;
+  readonly run: AgentWorkflowRun;
+  readonly node: AgentWorkflowDefinition["nodes"][number];
+  readonly receipt: AgentWorkflowNodeResultReceipt;
+  readonly commandId?: string;
+}) {
+  const { node, receipt } = input;
+  if (
+    node.outputSchemaKey !== receipt.outputSchemaKey ||
+    (node.type === "condition" &&
+      !node.branches.includes(receipt.selectedBranch ?? ""))
+  ) {
+    throw new Error("Node Result Receipt 不符合 immutable Definition");
+  }
+  const controlled =
+    node.type === "approval" ||
+    node.type === "job" ||
+    node.type === "subagent" ||
+    (node.type === "tool" && node.effect === "write");
+  if (!controlled) return;
+  if (!input.commandId) {
+    throw new Error("受控 Node 缺少 side-effect command receipt");
+  }
+  const [command, effectReceipt] = await Promise.all([
+    input.repository.getSideEffect(input.commandId),
+    input.effectFence.reconcile(input.commandId),
+  ]);
+  const expectedKind = node.type === "tool" ? "tool" : node.type;
+  if (
+    !command ||
+    !effectReceipt ||
+    !["committed", "reconciled"].includes(command.status) ||
+    command.runId !== input.run.runId ||
+    command.nodeRunId !== receipt.nodeRunId ||
+    command.effectKind !== expectedKind ||
+    !command.fenceTokenDigest ||
+    !/^sha256:[a-f0-9]{64}$/.test(command.fenceTokenDigest) ||
+    command.generation < 1 ||
+    effectReceipt.receiptId !== receipt.receiptId ||
+    effectReceipt.commandId !== command.commandId ||
+    effectReceipt.runId !== command.runId ||
+    effectReceipt.nodeRunId !== command.nodeRunId ||
+    effectReceipt.effectKind !== command.effectKind ||
+    effectReceipt.generation !== command.generation ||
+    effectReceipt.fenceTokenDigest !== command.fenceTokenDigest ||
+    effectReceipt.requestDigest !== command.requestDigest ||
+    effectReceipt.resultDigest !== receipt.resultDigest ||
+    effectReceipt.authorizationSnapshotDigest !==
+      command.authorizationSnapshotDigest ||
+    effectReceipt.authorizationSnapshotDigest !==
+      input.run.authorizationSnapshotDigest ||
+    effectReceipt.runPolicyDigest !== command.runPolicyDigest ||
+    effectReceipt.runPolicyDigest !== input.run.executionPolicyDigest ||
+    (node.type === "subagent" && !command.budgetReservationId)
+  ) {
+    throw new Error("Node Result Receipt 未绑定已提交的 side-effect receipt");
+  }
+}
+
+export async function workflowRunCompletionReadiness(input: {
+  readonly repository: AgentWorkflowRepository;
+  readonly budgetLedger: WorkflowBudgetLedgerPort;
+  readonly runId: string;
+}) {
+  const snapshot = await input.repository.getSnapshot(input.runId);
+  if (!snapshot) return false;
+  const release = await input.repository.getRelease(snapshot.run.releaseId);
+  if (!release) return false;
+  const finalId = release.definition.nodes.find(
+    ({ type }) => type === "final",
+  )?.id;
+  const final = snapshot.nodeRuns.find(
+    ({ nodeId, status, resultReceipt }) =>
+      nodeId === finalId && status === "completed" && resultReceipt,
+  );
+  const ledger = await input.budgetLedger.read(input.runId);
+  const activeEffect = snapshot.sideEffects.some(({ status }) =>
+    ["prepared", "dispatched", "cancellation-requested"].includes(status),
+  );
+  const activeNode = snapshot.nodeRuns.some(
+    ({ status }) => !isAgentWorkflowNodeTerminal(status),
+  );
+  return Boolean(
+    final &&
+    ledger &&
+    ledger.activeReservations.length === 0 &&
+    !activeEffect &&
+    !activeNode,
+  );
+}